repo stringlengths 5 92 | file_url stringlengths 80 287 | file_path stringlengths 5 197 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 7 values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:37:27 2026-01-04 17:58:21 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/serialized_execution_delegator.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/serialized_execution_delegator.rb | require 'delegate'
require 'concurrent/executor/serial_executor_service'
require 'concurrent/executor/serialized_execution'
module Concurrent
# A wrapper/delegator for any `ExecutorService` that
# guarantees serialized execution of tasks.
#
# @see [SimpleDelegator](http://www.ruby-doc.org/stdlib-2.1.2/libdoc/delegate/rdoc/SimpleDelegator.html)
# @see Concurrent::SerializedExecution
class SerializedExecutionDelegator < SimpleDelegator
include SerialExecutorService
def initialize(executor)
@executor = executor
@serializer = SerializedExecution.new
super(executor)
end
# @!macro executor_service_method_post
def post(*args, &task)
raise ArgumentError.new('no block given') unless block_given?
return false unless running?
@serializer.post(@executor, *args, &task)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/immediate_executor.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/immediate_executor.rb | require 'concurrent/atomic/event'
require 'concurrent/executor/abstract_executor_service'
require 'concurrent/executor/serial_executor_service'
module Concurrent
# An executor service which runs all operations on the current thread,
# blocking as necessary. Operations are performed in the order they are
# received and no two operations can be performed simultaneously.
#
# This executor service exists mainly for testing an debugging. When used
# it immediately runs every `#post` operation on the current thread, blocking
# that thread until the operation is complete. This can be very beneficial
# during testing because it makes all operations deterministic.
#
# @note Intended for use primarily in testing and debugging.
class ImmediateExecutor < AbstractExecutorService
include SerialExecutorService
# Creates a new executor
def initialize
@stopped = Concurrent::Event.new
end
# @!macro executor_service_method_post
def post(*args, &task)
raise ArgumentError.new('no block given') unless block_given?
return false unless running?
task.call(*args)
true
end
# @!macro executor_service_method_left_shift
def <<(task)
post(&task)
self
end
# @!macro executor_service_method_running_question
def running?
! shutdown?
end
# @!macro executor_service_method_shuttingdown_question
def shuttingdown?
false
end
# @!macro executor_service_method_shutdown_question
def shutdown?
@stopped.set?
end
# @!macro executor_service_method_shutdown
def shutdown
@stopped.set
true
end
alias_method :kill, :shutdown
# @!macro executor_service_method_wait_for_termination
def wait_for_termination(timeout = nil)
@stopped.wait(timeout)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/java_executor_service.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/java_executor_service.rb | if Concurrent.on_jruby?
require 'concurrent/errors'
require 'concurrent/utility/engine'
require 'concurrent/executor/abstract_executor_service'
module Concurrent
# @!macro abstract_executor_service_public_api
# @!visibility private
class JavaExecutorService < AbstractExecutorService
java_import 'java.lang.Runnable'
FALLBACK_POLICY_CLASSES = {
abort: java.util.concurrent.ThreadPoolExecutor::AbortPolicy,
discard: java.util.concurrent.ThreadPoolExecutor::DiscardPolicy,
caller_runs: java.util.concurrent.ThreadPoolExecutor::CallerRunsPolicy
}.freeze
private_constant :FALLBACK_POLICY_CLASSES
def initialize(*args, &block)
super
ns_make_executor_runnable
end
def post(*args, &task)
raise ArgumentError.new('no block given') unless block_given?
return handle_fallback(*args, &task) unless running?
@executor.submit_runnable Job.new(args, task)
true
rescue Java::JavaUtilConcurrent::RejectedExecutionException
raise RejectedExecutionError
end
def wait_for_termination(timeout = nil)
if timeout.nil?
ok = @executor.awaitTermination(60, java.util.concurrent.TimeUnit::SECONDS) until ok
true
else
@executor.awaitTermination(1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
end
end
def shutdown
synchronize do
self.ns_auto_terminate = false
@executor.shutdown
nil
end
end
def kill
synchronize do
self.ns_auto_terminate = false
@executor.shutdownNow
nil
end
end
private
def ns_running?
!(ns_shuttingdown? || ns_shutdown?)
end
def ns_shuttingdown?
if @executor.respond_to? :isTerminating
@executor.isTerminating
else
false
end
end
def ns_shutdown?
@executor.isShutdown || @executor.isTerminated
end
def ns_make_executor_runnable
if !defined?(@executor.submit_runnable)
@executor.class.class_eval do
java_alias :submit_runnable, :submit, [java.lang.Runnable.java_class]
end
end
end
class Job
include Runnable
def initialize(args, block)
@args = args
@block = block
end
def run
@block.call(*@args)
end
end
private_constant :Job
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/safe_task_executor.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/safe_task_executor.rb | require 'concurrent/synchronization'
module Concurrent
# A simple utility class that executes a callable and returns and array of three elements:
# success - indicating if the callable has been executed without errors
# value - filled by the callable result if it has been executed without errors, nil otherwise
# reason - the error risen by the callable if it has been executed with errors, nil otherwise
class SafeTaskExecutor < Synchronization::LockableObject
def initialize(task, opts = {})
@task = task
@exception_class = opts.fetch(:rescue_exception, false) ? Exception : StandardError
super() # ensures visibility
end
# @return [Array]
def execute(*args)
synchronize do
success = false
value = reason = nil
begin
value = @task.call(*args)
success = true
rescue @exception_class => ex
reason = ex
success = false
end
[success, value, reason]
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/ruby_single_thread_executor.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/ruby_single_thread_executor.rb | require 'concurrent/executor/ruby_thread_pool_executor'
module Concurrent
# @!macro single_thread_executor
# @!macro abstract_executor_service_public_api
# @!visibility private
class RubySingleThreadExecutor < RubyThreadPoolExecutor
# @!macro single_thread_executor_method_initialize
def initialize(opts = {})
super(
min_threads: 1,
max_threads: 1,
max_queue: 0,
idletime: DEFAULT_THREAD_IDLETIMEOUT,
fallback_policy: opts.fetch(:fallback_policy, :discard),
auto_terminate: opts.fetch(:auto_terminate, true)
)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/serialized_execution.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/serialized_execution.rb | require 'concurrent/errors'
require 'concurrent/concern/logging'
require 'concurrent/synchronization'
module Concurrent
# Ensures passed jobs in a serialized order never running at the same time.
class SerializedExecution < Synchronization::LockableObject
include Concern::Logging
def initialize()
super()
synchronize { ns_initialize }
end
Job = Struct.new(:executor, :args, :block) do
def call
block.call(*args)
end
end
# Submit a task to the executor for asynchronous processing.
#
# @param [Executor] executor to be used for this job
#
# @param [Array] args zero or more arguments to be passed to the task
#
# @yield the asynchronous task to perform
#
# @return [Boolean] `true` if the task is queued, `false` if the executor
# is not running
#
# @raise [ArgumentError] if no task is given
def post(executor, *args, &task)
posts [[executor, args, task]]
true
end
# As {#post} but allows to submit multiple tasks at once, it's guaranteed that they will not
# be interleaved by other tasks.
#
# @param [Array<Array(ExecutorService, Array<Object>, Proc)>] posts array of triplets where
# first is a {ExecutorService}, second is array of args for task, third is a task (Proc)
def posts(posts)
# if can_overflow?
# raise ArgumentError, 'SerializedExecution does not support thread-pools which can overflow'
# end
return nil if posts.empty?
jobs = posts.map { |executor, args, task| Job.new executor, args, task }
job_to_post = synchronize do
if @being_executed
@stash.push(*jobs)
nil
else
@being_executed = true
@stash.push(*jobs[1..-1])
jobs.first
end
end
call_job job_to_post if job_to_post
true
end
private
def ns_initialize
@being_executed = false
@stash = []
end
def call_job(job)
did_it_run = begin
job.executor.post { work(job) }
true
rescue RejectedExecutionError => ex
false
end
# TODO not the best idea to run it myself
unless did_it_run
begin
work job
rescue => ex
# let it fail
log DEBUG, ex
end
end
end
# ensures next job is executed if any is stashed
def work(job)
job.call
ensure
synchronize do
job = @stash.shift || (@being_executed = false)
end
# TODO maybe be able to tell caching pool to just enqueue this job, because the current one end at the end
# of this block
call_job job if job
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/serial_executor_service.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/serial_executor_service.rb | require 'concurrent/executor/executor_service'
module Concurrent
# Indicates that the including `ExecutorService` guarantees
# that all operations will occur in the order they are post and that no
# two operations may occur simultaneously. This module provides no
# functionality and provides no guarantees. That is the responsibility
# of the including class. This module exists solely to allow the including
# object to be interrogated for its serialization status.
#
# @example
# class Foo
# include Concurrent::SerialExecutor
# end
#
# foo = Foo.new
#
# foo.is_a? Concurrent::ExecutorService #=> true
# foo.is_a? Concurrent::SerialExecutor #=> true
# foo.serialized? #=> true
#
# @!visibility private
module SerialExecutorService
include ExecutorService
# @!macro executor_service_method_serialized_question
#
# @note Always returns `true`
def serialized?
true
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/executor_service.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/executor_service.rb | require 'concurrent/concern/logging'
module Concurrent
###################################################################
# @!macro [new] executor_service_method_post
#
# Submit a task to the executor for asynchronous processing.
#
# @param [Array] args zero or more arguments to be passed to the task
#
# @yield the asynchronous task to perform
#
# @return [Boolean] `true` if the task is queued, `false` if the executor
# is not running
#
# @raise [ArgumentError] if no task is given
# @!macro [new] executor_service_method_left_shift
#
# Submit a task to the executor for asynchronous processing.
#
# @param [Proc] task the asynchronous task to perform
#
# @return [self] returns itself
# @!macro [new] executor_service_method_can_overflow_question
#
# Does the task queue have a maximum size?
#
# @return [Boolean] True if the task queue has a maximum size else false.
# @!macro [new] executor_service_method_serialized_question
#
# Does this executor guarantee serialization of its operations?
#
# @return [Boolean] True if the executor guarantees that all operations
# will be post in the order they are received and no two operations may
# occur simultaneously. Else false.
###################################################################
# @!macro [new] executor_service_public_api
#
# @!method post(*args, &task)
# @!macro executor_service_method_post
#
# @!method <<(task)
# @!macro executor_service_method_left_shift
#
# @!method can_overflow?
# @!macro executor_service_method_can_overflow_question
#
# @!method serialized?
# @!macro executor_service_method_serialized_question
###################################################################
# @!macro [new] executor_service_attr_reader_fallback_policy
# @return [Symbol] The fallback policy in effect. Either `:abort`, `:discard`, or `:caller_runs`.
# @!macro [new] executor_service_method_shutdown
#
# Begin an orderly shutdown. Tasks already in the queue will be executed,
# but no new tasks will be accepted. Has no additional effect if the
# thread pool is not running.
# @!macro [new] executor_service_method_kill
#
# Begin an immediate shutdown. In-progress tasks will be allowed to
# complete but enqueued tasks will be dismissed and no new tasks
# will be accepted. Has no additional effect if the thread pool is
# not running.
# @!macro [new] executor_service_method_wait_for_termination
#
# Block until executor shutdown is complete or until `timeout` seconds have
# passed.
#
# @note Does not initiate shutdown or termination. Either `shutdown` or `kill`
# must be called before this method (or on another thread).
#
# @param [Integer] timeout the maximum number of seconds to wait for shutdown to complete
#
# @return [Boolean] `true` if shutdown complete or false on `timeout`
# @!macro [new] executor_service_method_running_question
#
# Is the executor running?
#
# @return [Boolean] `true` when running, `false` when shutting down or shutdown
# @!macro [new] executor_service_method_shuttingdown_question
#
# Is the executor shuttingdown?
#
# @return [Boolean] `true` when not running and not shutdown, else `false`
# @!macro [new] executor_service_method_shutdown_question
#
# Is the executor shutdown?
#
# @return [Boolean] `true` when shutdown, `false` when shutting down or running
# @!macro [new] executor_service_method_auto_terminate_question
#
# Is the executor auto-terminate when the application exits?
#
# @return [Boolean] `true` when auto-termination is enabled else `false`.
# @!macro [new] executor_service_method_auto_terminate_setter
#
# Set the auto-terminate behavior for this executor.
#
# @param [Boolean] value The new auto-terminate value to set for this executor.
#
# @return [Boolean] `true` when auto-termination is enabled else `false`.
###################################################################
# @!macro [new] abstract_executor_service_public_api
#
# @!macro executor_service_public_api
#
# @!attribute [r] fallback_policy
# @!macro executor_service_attr_reader_fallback_policy
#
# @!method shutdown
# @!macro executor_service_method_shutdown
#
# @!method kill
# @!macro executor_service_method_kill
#
# @!method wait_for_termination(timeout = nil)
# @!macro executor_service_method_wait_for_termination
#
# @!method running?
# @!macro executor_service_method_running_question
#
# @!method shuttingdown?
# @!macro executor_service_method_shuttingdown_question
#
# @!method shutdown?
# @!macro executor_service_method_shutdown_question
#
# @!method auto_terminate?
# @!macro executor_service_method_auto_terminate_question
#
# @!method auto_terminate=(value)
# @!macro executor_service_method_auto_terminate_setter
###################################################################
# @!macro executor_service_public_api
# @!visibility private
module ExecutorService
include Concern::Logging
# @!macro executor_service_method_post
def post(*args, &task)
raise NotImplementedError
end
# @!macro executor_service_method_left_shift
def <<(task)
post(&task)
self
end
# @!macro executor_service_method_can_overflow_question
#
# @note Always returns `false`
def can_overflow?
false
end
# @!macro executor_service_method_serialized_question
#
# @note Always returns `false`
def serialized?
false
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/abstract_executor_service.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/abstract_executor_service.rb | require 'concurrent/errors'
require 'concurrent/executor/executor_service'
require 'concurrent/synchronization'
require 'concurrent/utility/at_exit'
module Concurrent
# @!macro abstract_executor_service_public_api
# @!visibility private
class AbstractExecutorService < Synchronization::LockableObject
include ExecutorService
# The set of possible fallback policies that may be set at thread pool creation.
FALLBACK_POLICIES = [:abort, :discard, :caller_runs].freeze
# @!macro executor_service_attr_reader_fallback_policy
attr_reader :fallback_policy
# Create a new thread pool.
def initialize(*args, &block)
super(&nil)
synchronize { ns_initialize(*args, &block) }
end
# @!macro executor_service_method_shutdown
def shutdown
raise NotImplementedError
end
# @!macro executor_service_method_kill
def kill
raise NotImplementedError
end
# @!macro executor_service_method_wait_for_termination
def wait_for_termination(timeout = nil)
raise NotImplementedError
end
# @!macro executor_service_method_running_question
def running?
synchronize { ns_running? }
end
# @!macro executor_service_method_shuttingdown_question
def shuttingdown?
synchronize { ns_shuttingdown? }
end
# @!macro executor_service_method_shutdown_question
def shutdown?
synchronize { ns_shutdown? }
end
# @!macro executor_service_method_auto_terminate_question
def auto_terminate?
synchronize { ns_auto_terminate? }
end
# @!macro executor_service_method_auto_terminate_setter
def auto_terminate=(value)
synchronize { self.ns_auto_terminate = value }
end
private
# Handler which executes the `fallback_policy` once the queue size
# reaches `max_queue`.
#
# @param [Array] args the arguments to the task which is being handled.
#
# @!visibility private
def handle_fallback(*args)
case fallback_policy
when :abort
raise RejectedExecutionError
when :discard
false
when :caller_runs
begin
yield(*args)
rescue => ex
# let it fail
log DEBUG, ex
end
true
else
fail "Unknown fallback policy #{fallback_policy}"
end
end
def ns_execute(*args, &task)
raise NotImplementedError
end
# @!macro [attach] executor_service_method_ns_shutdown_execution
#
# Callback method called when an orderly shutdown has completed.
# The default behavior is to signal all waiting threads.
def ns_shutdown_execution
# do nothing
end
# @!macro [attach] executor_service_method_ns_kill_execution
#
# Callback method called when the executor has been killed.
# The default behavior is to do nothing.
def ns_kill_execution
# do nothing
end
def ns_auto_terminate?
!!@auto_terminate
end
def ns_auto_terminate=(value)
case value
when true
AtExit.add(self) { terminate_at_exit }
@auto_terminate = true
when false
AtExit.delete(self)
@auto_terminate = false
else
raise ArgumentError
end
end
def terminate_at_exit
kill # TODO be gentle first
wait_for_termination(10)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/fixed_thread_pool.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/fixed_thread_pool.rb | require 'concurrent/utility/engine'
require 'concurrent/executor/thread_pool_executor'
module Concurrent
# @!macro [new] thread_pool_executor_constant_default_max_pool_size
# Default maximum number of threads that will be created in the pool.
# @!macro [new] thread_pool_executor_constant_default_min_pool_size
# Default minimum number of threads that will be retained in the pool.
# @!macro [new] thread_pool_executor_constant_default_max_queue_size
# Default maximum number of tasks that may be added to the task queue.
# @!macro [new] thread_pool_executor_constant_default_thread_timeout
# Default maximum number of seconds a thread in the pool may remain idle
# before being reclaimed.
# @!macro [new] thread_pool_executor_attr_reader_max_length
# The maximum number of threads that may be created in the pool.
# @return [Integer] The maximum number of threads that may be created in the pool.
# @!macro [new] thread_pool_executor_attr_reader_min_length
# The minimum number of threads that may be retained in the pool.
# @return [Integer] The minimum number of threads that may be retained in the pool.
# @!macro [new] thread_pool_executor_attr_reader_largest_length
# The largest number of threads that have been created in the pool since construction.
# @return [Integer] The largest number of threads that have been created in the pool since construction.
# @!macro [new] thread_pool_executor_attr_reader_scheduled_task_count
# The number of tasks that have been scheduled for execution on the pool since construction.
# @return [Integer] The number of tasks that have been scheduled for execution on the pool since construction.
# @!macro [new] thread_pool_executor_attr_reader_completed_task_count
# The number of tasks that have been completed by the pool since construction.
# @return [Integer] The number of tasks that have been completed by the pool since construction.
# @!macro [new] thread_pool_executor_attr_reader_idletime
# The number of seconds that a thread may be idle before being reclaimed.
# @return [Integer] The number of seconds that a thread may be idle before being reclaimed.
# @!macro [new] thread_pool_executor_attr_reader_max_queue
# The maximum number of tasks that may be waiting in the work queue at any one time.
# When the queue size reaches `max_queue` subsequent tasks will be rejected in
# accordance with the configured `fallback_policy`.
#
# @return [Integer] The maximum number of tasks that may be waiting in the work queue at any one time.
# When the queue size reaches `max_queue` subsequent tasks will be rejected in
# accordance with the configured `fallback_policy`.
# @!macro [new] thread_pool_executor_attr_reader_length
# The number of threads currently in the pool.
# @return [Integer] The number of threads currently in the pool.
# @!macro [new] thread_pool_executor_attr_reader_queue_length
# The number of tasks in the queue awaiting execution.
# @return [Integer] The number of tasks in the queue awaiting execution.
# @!macro [new] thread_pool_executor_attr_reader_remaining_capacity
# Number of tasks that may be enqueued before reaching `max_queue` and rejecting
# new tasks. A value of -1 indicates that the queue may grow without bound.
#
# @return [Integer] Number of tasks that may be enqueued before reaching `max_queue` and rejecting
# new tasks. A value of -1 indicates that the queue may grow without bound.
# @!macro [new] thread_pool_executor_public_api
#
# @!macro abstract_executor_service_public_api
#
# @!attribute [r] max_length
# @!macro thread_pool_executor_attr_reader_max_length
#
# @!attribute [r] min_length
# @!macro thread_pool_executor_attr_reader_min_length
#
# @!attribute [r] largest_length
# @!macro thread_pool_executor_attr_reader_largest_length
#
# @!attribute [r] scheduled_task_count
# @!macro thread_pool_executor_attr_reader_scheduled_task_count
#
# @!attribute [r] completed_task_count
# @!macro thread_pool_executor_attr_reader_completed_task_count
#
# @!attribute [r] idletime
# @!macro thread_pool_executor_attr_reader_idletime
#
# @!attribute [r] max_queue
# @!macro thread_pool_executor_attr_reader_max_queue
#
# @!attribute [r] length
# @!macro thread_pool_executor_attr_reader_length
#
# @!attribute [r] queue_length
# @!macro thread_pool_executor_attr_reader_queue_length
#
# @!attribute [r] remaining_capacity
# @!macro thread_pool_executor_attr_reader_remaining_capacity
#
# @!method can_overflow?
# @!macro executor_service_method_can_overflow_question
# @!macro [new] thread_pool_options
#
# **Thread Pool Options**
#
# Thread pools support several configuration options:
#
# * `idletime`: The number of seconds that a thread may be idle before being reclaimed.
# * `max_queue`: The maximum number of tasks that may be waiting in the work queue at
# any one time. When the queue size reaches `max_queue` and no new threads can be created,
# subsequent tasks will be rejected in accordance with the configured `fallback_policy`.
# * `auto_terminate`: When true (default) an `at_exit` handler will be registered which
# will stop the thread pool when the application exits. See below for more information
# on shutting down thread pools.
# * `fallback_policy`: The policy defining how rejected tasks are handled.
#
# Three fallback policies are supported:
#
# * `:abort`: Raise a `RejectedExecutionError` exception and discard the task.
# * `:discard`: Discard the task and return false.
# * `:caller_runs`: Execute the task on the calling thread.
#
# **Shutting Down Thread Pools**
#
# Killing a thread pool while tasks are still being processed, either by calling
# the `#kill` method or at application exit, will have unpredictable results. There
# is no way for the thread pool to know what resources are being used by the
# in-progress tasks. When those tasks are killed the impact on those resources
# cannot be predicted. The *best* practice is to explicitly shutdown all thread
# pools using the provided methods:
#
# * Call `#shutdown` to initiate an orderly termination of all in-progress tasks
# * Call `#wait_for_termination` with an appropriate timeout interval an allow
# the orderly shutdown to complete
# * Call `#kill` *only when* the thread pool fails to shutdown in the allotted time
#
# On some runtime platforms (most notably the JVM) the application will not
# exit until all thread pools have been shutdown. To prevent applications from
# "hanging" on exit all thread pools include an `at_exit` handler that will
# stop the thread pool when the application exits. This handler uses a brute
# force method to stop the pool and makes no guarantees regarding resources being
# used by any tasks still running. Registration of this `at_exit` handler can be
# prevented by setting the thread pool's constructor `:auto_terminate` option to
# `false` when the thread pool is created. All thread pools support this option.
#
# ```ruby
# pool1 = Concurrent::FixedThreadPool.new(5) # an `at_exit` handler will be registered
# pool2 = Concurrent::FixedThreadPool.new(5, auto_terminate: false) # prevent `at_exit` handler registration
# ```
#
# @note Failure to properly shutdown a thread pool can lead to unpredictable results.
# Please read *Shutting Down Thread Pools* for more information.
#
# @see http://docs.oracle.com/javase/tutorial/essential/concurrency/pools.html Java Tutorials: Thread Pools
# @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html Java Executors class
# @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html Java ExecutorService interface
# @see http://ruby-doc.org//core-2.2.0/Kernel.html#method-i-at_exit Kernel#at_exit
# @!macro [attach] fixed_thread_pool
#
# A thread pool that reuses a fixed number of threads operating off an unbounded queue.
# At any point, at most `num_threads` will be active processing tasks. When all threads are busy new
# tasks `#post` to the thread pool are enqueued until a thread becomes available.
# Should a thread crash for any reason the thread will immediately be removed
# from the pool and replaced.
#
# The API and behavior of this class are based on Java's `FixedThreadPool`
#
# @!macro thread_pool_options
class FixedThreadPool < ThreadPoolExecutor
# @!macro [attach] fixed_thread_pool_method_initialize
#
# Create a new thread pool.
#
# @param [Integer] num_threads the number of threads to allocate
# @param [Hash] opts the options defining pool behavior.
# @option opts [Symbol] :fallback_policy (`:abort`) the fallback policy
#
# @raise [ArgumentError] if `num_threads` is less than or equal to zero
# @raise [ArgumentError] if `fallback_policy` is not a known policy
#
# @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newFixedThreadPool-int-
def initialize(num_threads, opts = {})
raise ArgumentError.new('number of threads must be greater than zero') if num_threads.to_i < 1
defaults = { max_queue: DEFAULT_MAX_QUEUE_SIZE,
idletime: DEFAULT_THREAD_IDLETIMEOUT }
overrides = { min_threads: num_threads,
max_threads: num_threads }
super(defaults.merge(opts).merge(overrides))
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/timer_set.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/timer_set.rb | require 'concurrent/scheduled_task'
require 'concurrent/atomic/event'
require 'concurrent/collection/non_concurrent_priority_queue'
require 'concurrent/executor/executor_service'
require 'concurrent/executor/single_thread_executor'
require 'concurrent/options'
module Concurrent
# Executes a collection of tasks, each after a given delay. A master task
# monitors the set and schedules each task for execution at the appropriate
# time. Tasks are run on the global thread pool or on the supplied executor.
# Each task is represented as a `ScheduledTask`.
#
# @see Concurrent::ScheduledTask
#
# @!macro monotonic_clock_warning
class TimerSet < RubyExecutorService
# Create a new set of timed tasks.
#
# @!macro [attach] executor_options
#
# @param [Hash] opts the options used to specify the executor on which to perform actions
# @option opts [Executor] :executor when set use the given `Executor` instance.
# Three special values are also supported: `:task` returns the global task pool,
# `:operation` returns the global operation pool, and `:immediate` returns a new
# `ImmediateExecutor` object.
def initialize(opts = {})
super(opts)
end
# Post a task to be execute run after a given delay (in seconds). If the
# delay is less than 1/100th of a second the task will be immediately post
# to the executor.
#
# @param [Float] delay the number of seconds to wait for before executing the task.
# @param [Array<Object>] args the arguments passed to the task on execution.
#
# @yield the task to be performed.
#
# @return [Concurrent::ScheduledTask, false] IVar representing the task if the post
# is successful; false after shutdown.
#
# @raise [ArgumentError] if the intended execution time is not in the future.
# @raise [ArgumentError] if no block is given.
def post(delay, *args, &task)
raise ArgumentError.new('no block given') unless block_given?
return false unless running?
opts = {
executor: @task_executor,
args: args,
timer_set: self
}
task = ScheduledTask.execute(delay, opts, &task) # may raise exception
task.unscheduled? ? false : task
end
# Begin an immediate shutdown. In-progress tasks will be allowed to
# complete but enqueued tasks will be dismissed and no new tasks
# will be accepted. Has no additional effect if the thread pool is
# not running.
def kill
shutdown
end
private :<<
private
# Initialize the object.
#
# @param [Hash] opts the options to create the object with.
# @!visibility private
def ns_initialize(opts)
@queue = Collection::NonConcurrentPriorityQueue.new(order: :min)
@task_executor = Options.executor_from_options(opts) || Concurrent.global_io_executor
@timer_executor = SingleThreadExecutor.new
@condition = Event.new
@ruby_pid = $$ # detects if Ruby has forked
self.auto_terminate = opts.fetch(:auto_terminate, true)
end
# Post the task to the internal queue.
#
# @note This is intended as a callback method from ScheduledTask
# only. It is not intended to be used directly. Post a task
# by using the `SchedulesTask#execute` method.
#
# @!visibility private
def post_task(task)
synchronize{ ns_post_task(task) }
end
# @!visibility private
def ns_post_task(task)
return false unless ns_running?
ns_reset_if_forked
if (task.initial_delay) <= 0.01
task.executor.post{ task.process_task }
else
@queue.push(task)
# only post the process method when the queue is empty
@timer_executor.post(&method(:process_tasks)) if @queue.length == 1
@condition.set
end
true
end
# Remove the given task from the queue.
#
# @note This is intended as a callback method from `ScheduledTask`
# only. It is not intended to be used directly. Cancel a task
# by using the `ScheduledTask#cancel` method.
#
# @!visibility private
def remove_task(task)
synchronize{ @queue.delete(task) }
end
# `ExecutorService` callback called during shutdown.
#
# @!visibility private
def ns_shutdown_execution
ns_reset_if_forked
@queue.clear
@timer_executor.kill
stopped_event.set
end
def ns_reset_if_forked
if $$ != @ruby_pid
@queue.clear
@condition.reset
@ruby_pid = $$
end
end
# Run a loop and execute tasks in the scheduled order and at the approximate
# scheduled time. If no tasks remain the thread will exit gracefully so that
# garbage collection can occur. If there are no ready tasks it will sleep
# for up to 60 seconds waiting for the next scheduled task.
#
# @!visibility private
def process_tasks
loop do
task = synchronize { @condition.reset; @queue.peek }
break unless task
now = Concurrent.monotonic_time
diff = task.schedule_time - now
if diff <= 0
# We need to remove the task from the queue before passing
# it to the executor, to avoid race conditions where we pass
# the peek'ed task to the executor and then pop a different
# one that's been added in the meantime.
#
# Note that there's no race condition between the peek and
# this pop - this pop could retrieve a different task from
# the peek, but that task would be due to fire now anyway
# (because @queue is a priority queue, and this thread is
# the only reader, so whatever timer is at the head of the
# queue now must have the same pop time, or a closer one, as
# when we peeked).
task = synchronize { @queue.pop }
task.executor.post{ task.process_task }
else
@condition.wait([diff, 60].min)
end
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/indirect_immediate_executor.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/executor/indirect_immediate_executor.rb | require 'concurrent/executor/immediate_executor'
require 'concurrent/executor/simple_executor_service'
module Concurrent
# An executor service which runs all operations on a new thread, blocking
# until it completes. Operations are performed in the order they are received
# and no two operations can be performed simultaneously.
#
# This executor service exists mainly for testing an debugging. When used it
# immediately runs every `#post` operation on a new thread, blocking the
# current thread until the operation is complete. This is similar to how the
# ImmediateExecutor works, but the operation has the full stack of the new
# thread at its disposal. This can be helpful when the operations will spawn
# more operations on the same executor and so on - such a situation might
# overflow the single stack in case of an ImmediateExecutor, which is
# inconsistent with how it would behave for a threaded executor.
#
# @note Intended for use primarily in testing and debugging.
class IndirectImmediateExecutor < ImmediateExecutor
# Creates a new executor
def initialize
super
@internal_executor = SimpleExecutorService.new
end
# @!macro executor_service_method_post
def post(*args, &task)
raise ArgumentError.new("no block given") unless block_given?
return false unless running?
event = Concurrent::Event.new
@internal_executor.post do
begin
task.call(*args)
ensure
event.set
end
end
event.wait
true
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/jruby+truffle.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/jruby+truffle.rb | require 'atomic'
require 'concurrent/atomic_reference/rbx'
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/jruby.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/jruby.rb | require 'concurrent/synchronization'
if defined?(Concurrent::JavaAtomicReference)
require 'concurrent/atomic_reference/direct_update'
module Concurrent
# @!macro atomic_reference
#
# @!visibility private
# @!macro internal_implementation_note
class JavaAtomicReference
include Concurrent::AtomicDirectUpdate
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/concurrent_update_error.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/concurrent_update_error.rb | module Concurrent
# @!macro atomic_reference
class ConcurrentUpdateError < ThreadError
# frozen pre-allocated backtrace to speed ConcurrentUpdateError
CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/numeric_cas_wrapper.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/numeric_cas_wrapper.rb | module Concurrent
# Special "compare and set" handling of numeric values.
#
# @!visibility private
# @!macro internal_implementation_note
module AtomicNumericCompareAndSetWrapper
# @!macro atomic_reference_method_compare_and_set
def compare_and_set(old_value, new_value)
if old_value.kind_of? Numeric
while true
old = get
return false unless old.kind_of? Numeric
return false unless old == old_value
result = _compare_and_set(old, new_value)
return result if result
end
else
_compare_and_set(old_value, new_value)
end
end
alias_method :compare_and_swap, :compare_and_set
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/mutex_atomic.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/mutex_atomic.rb | require 'concurrent/synchronization'
require 'concurrent/atomic_reference/direct_update'
require 'concurrent/atomic_reference/numeric_cas_wrapper'
module Concurrent
# @!macro atomic_reference
#
# @!visibility private
# @!macro internal_implementation_note
class MutexAtomicReference < Synchronization::LockableObject
include Concurrent::AtomicDirectUpdate
include Concurrent::AtomicNumericCompareAndSetWrapper
# @!macro atomic_reference_method_initialize
def initialize(value = nil)
super()
synchronize { ns_initialize(value) }
end
# @!macro atomic_reference_method_get
def get
synchronize { @value }
end
alias_method :value, :get
# @!macro atomic_reference_method_set
def set(new_value)
synchronize { @value = new_value }
end
alias_method :value=, :set
# @!macro atomic_reference_method_get_and_set
def get_and_set(new_value)
synchronize do
old_value = @value
@value = new_value
old_value
end
end
alias_method :swap, :get_and_set
# @!macro atomic_reference_method_compare_and_set
def _compare_and_set(old_value, new_value)
synchronize do
if @value.equal? old_value
@value = new_value
true
else
false
end
end
end
protected
def ns_initialize(value)
@value = value
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/rbx.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/rbx.rb | require 'concurrent/atomic_reference/direct_update'
require 'concurrent/atomic_reference/numeric_cas_wrapper'
module Concurrent
# @!macro atomic_reference
#
# @note Extends `Rubinius::AtomicReference` version adding aliases
# and numeric logic.
#
# @!visibility private
# @!macro internal_implementation_note
class RbxAtomicReference < Rubinius::AtomicReference
alias _compare_and_set compare_and_set
include Concurrent::AtomicDirectUpdate
include Concurrent::AtomicNumericCompareAndSetWrapper
alias_method :value, :get
alias_method :value=, :set
alias_method :swap, :get_and_set
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/direct_update.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/direct_update.rb | require 'concurrent/atomic_reference/concurrent_update_error'
module Concurrent
# Define update methods that use direct paths
#
# @!visibility private
# @!macro internal_implementation_note
module AtomicDirectUpdate
# @!macro [attach] atomic_reference_method_update
#
# Pass the current value to the given block, replacing it
# with the block's result. May retry if the value changes
# during the block's execution.
#
# @yield [Object] Calculate a new value for the atomic reference using
# given (old) value
# @yieldparam [Object] old_value the starting value of the atomic reference
#
# @return [Object] the new value
def update
true until compare_and_set(old_value = get, new_value = yield(old_value))
new_value
end
# @!macro [attach] atomic_reference_method_try_update
#
# Pass the current value to the given block, replacing it
# with the block's result. Return nil if the update fails.
#
# @yield [Object] Calculate a new value for the atomic reference using
# given (old) value
# @yieldparam [Object] old_value the starting value of the atomic reference
#
# @note This method was altered to avoid raising an exception by default.
# Instead, this method now returns `nil` in case of failure. For more info,
# please see: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
#
# @return [Object] the new value, or nil if update failed
def try_update
old_value = get
new_value = yield old_value
return unless compare_and_set old_value, new_value
new_value
end
# @!macro [attach] atomic_reference_method_try_update!
#
# Pass the current value to the given block, replacing it
# with the block's result. Raise an exception if the update
# fails.
#
# @yield [Object] Calculate a new value for the atomic reference using
# given (old) value
# @yieldparam [Object] old_value the starting value of the atomic reference
#
# @note This behavior mimics the behavior of the original
# `AtomicReference#try_update` API. The reason this was changed was to
# avoid raising exceptions (which are inherently slow) by default. For more
# info: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
#
# @return [Object] the new value
#
# @raise [Concurrent::ConcurrentUpdateError] if the update fails
def try_update!
old_value = get
new_value = yield old_value
unless compare_and_set(old_value, new_value)
if $VERBOSE
raise ConcurrentUpdateError, "Update failed"
else
raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
end
end
new_value
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/ruby.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/atomic_reference/ruby.rb | if defined? Concurrent::CAtomicReference
require 'concurrent/synchronization'
require 'concurrent/atomic_reference/direct_update'
require 'concurrent/atomic_reference/numeric_cas_wrapper'
module Concurrent
# @!macro atomic_reference
#
# @!visibility private
# @!macro internal_implementation_note
class CAtomicReference
include Concurrent::AtomicDirectUpdate
include Concurrent::AtomicNumericCompareAndSetWrapper
# @!method initialize
# @!macro atomic_reference_method_initialize
# @!method get
# @!macro atomic_reference_method_get
# @!method set
# @!macro atomic_reference_method_set
# @!method get_and_set
# @!macro atomic_reference_method_get_and_set
# @!method _compare_and_set
# @!macro atomic_reference_method_compare_and_set
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/concern/deprecation.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/concern/deprecation.rb | require 'concurrent/concern/logging'
module Concurrent
module Concern
# @!visibility private
# @!macro internal_implementation_note
module Deprecation
# TODO require additional parameter: a version. Display when it'll be removed based on that. Error if not removed.
include Concern::Logging
def deprecated(message, strip = 2)
caller_line = caller(strip).first if strip > 0
klass = if Module === self
self
else
self.class
end
message = if strip > 0
format("[DEPRECATED] %s\ncalled on: %s", message, caller_line)
else
format('[DEPRECATED] %s', message)
end
log WARN, klass.to_s, message
end
def deprecated_method(old_name, new_name)
deprecated "`#{old_name}` is deprecated and it'll removed in next release, use `#{new_name}` instead", 3
end
extend self
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/concern/obligation.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/concern/obligation.rb | require 'thread'
require 'timeout'
require 'concurrent/atomic/event'
require 'concurrent/concern/dereferenceable'
module Concurrent
module Concern
module Obligation
include Concern::Dereferenceable
# NOTE: The Dereferenceable module is going away in 2.0. In the mean time
# we need it to place nicely with the synchronization layer. This means
# that the including class SHOULD be synchronized and it MUST implement a
# `#synchronize` method. Not doing so will lead to runtime errors.
# Has the obligation been fulfilled?
#
# @return [Boolean]
def fulfilled?
state == :fulfilled
end
alias_method :realized?, :fulfilled?
# Has the obligation been rejected?
#
# @return [Boolean]
def rejected?
state == :rejected
end
# Is obligation completion still pending?
#
# @return [Boolean]
def pending?
state == :pending
end
# Is the obligation still unscheduled?
#
# @return [Boolean]
def unscheduled?
state == :unscheduled
end
# Has the obligation completed processing?
#
# @return [Boolean]
def complete?
[:fulfilled, :rejected].include? state
end
# Is the obligation still awaiting completion of processing?
#
# @return [Boolean]
def incomplete?
! complete?
end
# The current value of the obligation. Will be `nil` while the state is
# pending or the operation has been rejected.
#
# @param [Numeric] timeout the maximum time in seconds to wait.
# @return [Object] see Dereferenceable#deref
def value(timeout = nil)
wait timeout
deref
end
# Wait until obligation is complete or the timeout has been reached.
#
# @param [Numeric] timeout the maximum time in seconds to wait.
# @return [Obligation] self
def wait(timeout = nil)
event.wait(timeout) if timeout != 0 && incomplete?
self
end
# Wait until obligation is complete or the timeout is reached. Will re-raise
# any exceptions raised during processing (but will not raise an exception
# on timeout).
#
# @param [Numeric] timeout the maximum time in seconds to wait.
# @return [Obligation] self
# @raise [Exception] raises the reason when rejected
def wait!(timeout = nil)
wait(timeout).tap { raise self if rejected? }
end
alias_method :no_error!, :wait!
# The current value of the obligation. Will be `nil` while the state is
# pending or the operation has been rejected. Will re-raise any exceptions
# raised during processing (but will not raise an exception on timeout).
#
# @param [Numeric] timeout the maximum time in seconds to wait.
# @return [Object] see Dereferenceable#deref
# @raise [Exception] raises the reason when rejected
def value!(timeout = nil)
wait(timeout)
if rejected?
raise self
else
deref
end
end
# The current state of the obligation.
#
# @return [Symbol] the current state
def state
synchronize { @state }
end
# If an exception was raised during processing this will return the
# exception object. Will return `nil` when the state is pending or if
# the obligation has been successfully fulfilled.
#
# @return [Exception] the exception raised during processing or `nil`
def reason
synchronize { @reason }
end
# @example allows Obligation to be risen
# rejected_ivar = Ivar.new.fail
# raise rejected_ivar
def exception(*args)
raise 'obligation is not rejected' unless rejected?
reason.exception(*args)
end
protected
# @!visibility private
def get_arguments_from(opts = {})
[*opts.fetch(:args, [])]
end
# @!visibility private
def init_obligation
@event = Event.new
@value = @reason = nil
end
# @!visibility private
def event
@event
end
# @!visibility private
def set_state(success, value, reason)
if success
@value = value
@state = :fulfilled
else
@reason = reason
@state = :rejected
end
end
# @!visibility private
def state=(value)
synchronize { ns_set_state(value) }
end
# Atomic compare and set operation
# State is set to `next_state` only if `current state == expected_current`.
#
# @param [Symbol] next_state
# @param [Symbol] expected_current
#
# @return [Boolean] true is state is changed, false otherwise
#
# @!visibility private
def compare_and_set_state(next_state, *expected_current)
synchronize do
if expected_current.include? @state
@state = next_state
true
else
false
end
end
end
# Executes the block within mutex if current state is included in expected_states
#
# @return block value if executed, false otherwise
#
# @!visibility private
def if_state(*expected_states)
synchronize do
raise ArgumentError.new('no block given') unless block_given?
if expected_states.include? @state
yield
else
false
end
end
end
protected
# Am I in the current state?
#
# @param [Symbol] expected The state to check against
# @return [Boolean] true if in the expected state else false
#
# @!visibility private
def ns_check_state?(expected)
@state == expected
end
# @!visibility private
def ns_set_state(value)
@state = value
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/concern/logging.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/concern/logging.rb | require 'logger'
module Concurrent
module Concern
# Include where logging is needed
#
# @!visibility private
module Logging
include Logger::Severity
# Logs through {Concurrent.global_logger}, it can be overridden by setting @logger
# @param [Integer] level one of Logger::Severity constants
# @param [String] progname e.g. a path of an Actor
# @param [String, nil] message when nil block is used to generate the message
# @yieldreturn [String] a message
def log(level, progname, message = nil, &block)
#NOTE: Cannot require 'concurrent/configuration' above due to circular references.
# Assume that the gem has been initialized if we've gotten this far.
(@logger || Concurrent.global_logger).call level, progname, message, &block
rescue => error
$stderr.puts "`Concurrent.configuration.logger` failed to log #{[level, progname, message, block]}\n" +
"#{error.message} (#{error.class})\n#{error.backtrace.join "\n"}"
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/concern/observable.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/concern/observable.rb | require 'concurrent/collection/copy_on_notify_observer_set'
require 'concurrent/collection/copy_on_write_observer_set'
module Concurrent
module Concern
# The [observer pattern](http://en.wikipedia.org/wiki/Observer_pattern) is one
# of the most useful design patterns.
#
# The workflow is very simple:
# - an `observer` can register itself to a `subject` via a callback
# - many `observers` can be registered to the same `subject`
# - the `subject` notifies all registered observers when its status changes
# - an `observer` can deregister itself when is no more interested to receive
# event notifications
#
# In a single threaded environment the whole pattern is very easy: the
# `subject` can use a simple data structure to manage all its subscribed
# `observer`s and every `observer` can react directly to every event without
# caring about synchronization.
#
# In a multi threaded environment things are more complex. The `subject` must
# synchronize the access to its data structure and to do so currently we're
# using two specialized ObserverSet: {Concurrent::Concern::CopyOnWriteObserverSet}
# and {Concurrent::Concern::CopyOnNotifyObserverSet}.
#
# When implementing and `observer` there's a very important rule to remember:
# **there are no guarantees about the thread that will execute the callback**
#
# Let's take this example
# ```
# class Observer
# def initialize
# @count = 0
# end
#
# def update
# @count += 1
# end
# end
#
# obs = Observer.new
# [obj1, obj2, obj3, obj4].each { |o| o.add_observer(obs) }
# # execute [obj1, obj2, obj3, obj4]
# ```
#
# `obs` is wrong because the variable `@count` can be accessed by different
# threads at the same time, so it should be synchronized (using either a Mutex
# or an AtomicFixum)
module Observable
# @!macro [attach] observable_add_observer
#
# Adds an observer to this set. If a block is passed, the observer will be
# created by this method and no other params should be passed.
#
# @param [Object] observer the observer to add
# @param [Symbol] func the function to call on the observer during notification.
# Default is :update
# @return [Object] the added observer
def add_observer(observer = nil, func = :update, &block)
observers.add_observer(observer, func, &block)
end
# As `#add_observer` but can be used for chaining.
#
# @param [Object] observer the observer to add
# @param [Symbol] func the function to call on the observer during notification.
# @return [Observable] self
def with_observer(observer = nil, func = :update, &block)
add_observer(observer, func, &block)
self
end
# @!macro [attach] observable_delete_observer
#
# Remove `observer` as an observer on this object so that it will no
# longer receive notifications.
#
# @param [Object] observer the observer to remove
# @return [Object] the deleted observer
def delete_observer(observer)
observers.delete_observer(observer)
end
# @!macro [attach] observable_delete_observers
#
# Remove all observers associated with this object.
#
# @return [Observable] self
def delete_observers
observers.delete_observers
self
end
# @!macro [attach] observable_count_observers
#
# Return the number of observers associated with this object.
#
# @return [Integer] the observers count
def count_observers
observers.count_observers
end
protected
attr_accessor :observers
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/concern/dereferenceable.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/concern/dereferenceable.rb | module Concurrent
module Concern
# Object references in Ruby are mutable. This can lead to serious problems when
# the `#value` of a concurrent object is a mutable reference. Which is always the
# case unless the value is a `Fixnum`, `Symbol`, or similar "primitive" data type.
# Most classes in this library that expose a `#value` getter method do so using the
# `Dereferenceable` mixin module.
#
# @!macro copy_options
module Dereferenceable
# NOTE: This module is going away in 2.0. In the mean time we need it to
# play nicely with the synchronization layer. This means that the
# including class SHOULD be synchronized and it MUST implement a
# `#synchronize` method. Not doing so will lead to runtime errors.
# Return the value this object represents after applying the options specified
# by the `#set_deref_options` method.
#
# @return [Object] the current value of the object
def value
synchronize { apply_deref_options(@value) }
end
alias_method :deref, :value
protected
# Set the internal value of this object
#
# @param [Object] value the new value
def value=(value)
synchronize{ @value = value }
end
# @!macro [attach] dereferenceable_set_deref_options
# Set the options which define the operations #value performs before
# returning data to the caller (dereferencing).
#
# @note Most classes that include this module will call `#set_deref_options`
# from within the constructor, thus allowing these options to be set at
# object creation.
#
# @param [Hash] opts the options defining dereference behavior.
# @option opts [String] :dup_on_deref (false) call `#dup` before returning the data
# @option opts [String] :freeze_on_deref (false) call `#freeze` before returning the data
# @option opts [String] :copy_on_deref (nil) call the given `Proc` passing
# the internal value and returning the value returned from the proc
def set_deref_options(opts = {})
synchronize{ ns_set_deref_options(opts) }
end
# @!macro dereferenceable_set_deref_options
# @!visibility private
def ns_set_deref_options(opts)
@dup_on_deref = opts[:dup_on_deref] || opts[:dup]
@freeze_on_deref = opts[:freeze_on_deref] || opts[:freeze]
@copy_on_deref = opts[:copy_on_deref] || opts[:copy]
@do_nothing_on_deref = !(@dup_on_deref || @freeze_on_deref || @copy_on_deref)
nil
end
# @!visibility private
def apply_deref_options(value)
return nil if value.nil?
return value if @do_nothing_on_deref
value = @copy_on_deref.call(value) if @copy_on_deref
value = value.dup if @dup_on_deref
value = value.freeze if @freeze_on_deref
value
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/at_exit.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/at_exit.rb | require 'logger'
require 'concurrent/synchronization'
module Concurrent
# Provides ability to add and remove handlers to be run at `Kernel#at_exit`, order is undefined.
# Each handler is executed at most once.
#
# @!visibility private
class AtExitImplementation < Synchronization::LockableObject
include Logger::Severity
def initialize(*args)
super()
synchronize { ns_initialize(*args) }
end
# Add a handler to be run at `Kernel#at_exit`
# @param [Object] handler_id optionally provide an id, if allready present, handler is replaced
# @yield the handler
# @return id of the handler
def add(handler_id = nil, &handler)
id = handler_id || handler.object_id
synchronize { @handlers[id] = handler }
id
end
# Delete a handler by handler_id
# @return [true, false]
def delete(handler_id)
!!synchronize { @handlers.delete handler_id }
end
# Is handler with handler_id rpesent?
# @return [true, false]
def handler?(handler_id)
synchronize { @handlers.key? handler_id }
end
# @return copy of the handlers
def handlers
synchronize { @handlers }.clone
end
# install `Kernel#at_exit` callback to execute added handlers
def install
synchronize do
@installed ||= begin
at_exit { runner }
true
end
self
end
end
# Will it run during `Kernel#at_exit`
def enabled?
synchronize { @enabled }
end
# Configure if it runs during `Kernel#at_exit`
def enabled=(value)
synchronize { @enabled = value }
end
# run the handlers manually
# @return ids of the handlers
def run
handlers, _ = synchronize { handlers, @handlers = @handlers, {} }
handlers.each do |_, handler|
begin
handler.call
rescue => error
Concurrent.global_logger.call(ERROR, error)
end
end
handlers.keys
end
private
def ns_initialize(enabled = true)
@handlers = {}
@enabled = enabled
end
def runner
run if synchronize { @enabled }
end
end
private_constant :AtExitImplementation
# @see AtExitImplementation
# @!visibility private
AtExit = AtExitImplementation.new.install
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/native_extension_loader.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/native_extension_loader.rb | require 'concurrent/utility/engine'
module Concurrent
module Utility
# @!visibility private
module NativeExtensionLoader
def allow_c_extensions?
Concurrent.on_cruby?
end
def c_extensions_loaded?
@c_extensions_loaded ||= false
end
def java_extensions_loaded?
@java_extensions_loaded ||= false
end
def set_c_extensions_loaded
@c_extensions_loaded = true
end
def set_java_extensions_loaded
@java_extensions_loaded = true
end
def load_native_extensions
unless defined? Synchronization::AbstractObject
raise 'native_extension_loader loaded before Synchronization::AbstractObject'
end
if Concurrent.on_cruby? && !c_extensions_loaded?
tries = [
lambda do
require 'concurrent/extension'
set_c_extensions_loaded
end,
lambda do
# may be a Windows cross-compiled native gem
require "concurrent/#{RUBY_VERSION[0..2]}/extension"
set_c_extensions_loaded
end]
tries.each do |try|
begin
try.call
break
rescue LoadError
next
end
end
end
if Concurrent.on_jruby? && !java_extensions_loaded?
begin
require 'concurrent_ruby_ext'
set_java_extensions_loaded
rescue LoadError
# move on with pure-Ruby implementations
raise 'On JRuby but Java extensions failed to load.'
end
end
end
end
end
# @!visibility private
extend Utility::NativeExtensionLoader
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/processor_counter.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/processor_counter.rb | require 'rbconfig'
require 'concurrent/delay'
module Concurrent
module Utility
# @!visibility private
class ProcessorCounter
def initialize
@processor_count = Delay.new { compute_processor_count }
@physical_processor_count = Delay.new { compute_physical_processor_count }
end
# Number of processors seen by the OS and used for process scheduling. For
# performance reasons the calculated value will be memoized on the first
# call.
#
# When running under JRuby the Java runtime call
# `java.lang.Runtime.getRuntime.availableProcessors` will be used. According
# to the Java documentation this "value may change during a particular
# invocation of the virtual machine... [applications] should therefore
# occasionally poll this property." Subsequently the result will NOT be
# memoized under JRuby.
#
# On Windows the Win32 API will be queried for the
# `NumberOfLogicalProcessors from Win32_Processor`. This will return the
# total number "logical processors for the current instance of the
# processor", which taked into account hyperthreading.
#
# * AIX: /usr/sbin/pmcycles (AIX 5+), /usr/sbin/lsdev
# * Alpha: /usr/bin/nproc (/proc/cpuinfo exists but cannot be used)
# * BSD: /sbin/sysctl
# * Cygwin: /proc/cpuinfo
# * Darwin: /usr/bin/hwprefs, /usr/sbin/sysctl
# * HP-UX: /usr/sbin/ioscan
# * IRIX: /usr/sbin/sysconf
# * Linux: /proc/cpuinfo
# * Minix 3+: /proc/cpuinfo
# * Solaris: /usr/sbin/psrinfo
# * Tru64 UNIX: /usr/sbin/psrinfo
# * UnixWare: /usr/sbin/psrinfo
#
# @return [Integer] number of processors seen by the OS or Java runtime
#
# @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
#
# @see http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#availableProcessors()
# @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
def processor_count
@processor_count.value
end
# Number of physical processor cores on the current system. For performance
# reasons the calculated value will be memoized on the first call.
#
# On Windows the Win32 API will be queried for the `NumberOfCores from
# Win32_Processor`. This will return the total number "of cores for the
# current instance of the processor." On Unix-like operating systems either
# the `hwprefs` or `sysctl` utility will be called in a subshell and the
# returned value will be used. In the rare case where none of these methods
# work or an exception is raised the function will simply return 1.
#
# @return [Integer] number physical processor cores on the current system
#
# @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
#
# @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
# @see http://www.unix.com/man-page/osx/1/HWPREFS/
# @see http://linux.die.net/man/8/sysctl
def physical_processor_count
@physical_processor_count.value
end
private
def compute_processor_count
if Concurrent.on_jruby?
java.lang.Runtime.getRuntime.availableProcessors
elsif Concurrent.on_truffle?
Truffle::Primitive.logical_processors
else
os_name = RbConfig::CONFIG["target_os"]
if os_name =~ /mingw|mswin/
require 'win32ole'
result = WIN32OLE.connect("winmgmts://").ExecQuery(
"select NumberOfLogicalProcessors from Win32_Processor")
result.to_enum.collect(&:NumberOfLogicalProcessors).reduce(:+)
elsif File.readable?("/proc/cpuinfo") && (cpuinfo_count = IO.read("/proc/cpuinfo").scan(/^processor/).size) > 0
cpuinfo_count
elsif File.executable?("/usr/bin/nproc")
IO.popen("/usr/bin/nproc --all", &:read).to_i
elsif File.executable?("/usr/bin/hwprefs")
IO.popen("/usr/bin/hwprefs thread_count", &:read).to_i
elsif File.executable?("/usr/sbin/psrinfo")
IO.popen("/usr/sbin/psrinfo", &:read).scan(/^.*on-*line/).size
elsif File.executable?("/usr/sbin/ioscan")
IO.popen("/usr/sbin/ioscan -kC processor", &:read).scan(/^.*processor/).size
elsif File.executable?("/usr/sbin/pmcycles")
IO.popen("/usr/sbin/pmcycles -m", &:read).count("\n")
elsif File.executable?("/usr/sbin/lsdev")
IO.popen("/usr/sbin/lsdev -Cc processor -S 1", &:read).count("\n")
elsif File.executable?("/usr/sbin/sysconf") and os_name =~ /irix/i
IO.popen("/usr/sbin/sysconf NPROC_ONLN", &:read).to_i
elsif File.executable?("/usr/sbin/sysctl")
IO.popen("/usr/sbin/sysctl -n hw.ncpu", &:read).to_i
elsif File.executable?("/sbin/sysctl")
IO.popen("/sbin/sysctl -n hw.ncpu", &:read).to_i
else
# TODO (pitr-ch 05-Nov-2016): warn about failures
1
end
end
rescue
return 1
end
def compute_physical_processor_count
ppc = case RbConfig::CONFIG["target_os"]
when /darwin1/
IO.popen("/usr/sbin/sysctl -n hw.physicalcpu", &:read).to_i
when /linux/
cores = {} # unique physical ID / core ID combinations
phy = 0
IO.read("/proc/cpuinfo").scan(/^physical id.*|^core id.*/) do |ln|
if ln.start_with?("physical")
phy = ln[/\d+/]
elsif ln.start_with?("core")
cid = phy + ":" + ln[/\d+/]
cores[cid] = true if not cores[cid]
end
end
cores.count
when /mswin|mingw/
require 'win32ole'
result_set = WIN32OLE.connect("winmgmts://").ExecQuery(
"select NumberOfCores from Win32_Processor")
result_set.to_enum.collect(&:NumberOfCores).reduce(:+)
else
processor_count
end
# fall back to logical count if physical info is invalid
ppc > 0 ? ppc : processor_count
rescue
return 1
end
end
end
# create the default ProcessorCounter on load
@processor_counter = Utility::ProcessorCounter.new
singleton_class.send :attr_reader, :processor_counter
def self.processor_count
processor_counter.processor_count
end
def self.physical_processor_count
processor_counter.physical_processor_count
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/native_integer.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/native_integer.rb | module Concurrent
module Utility
# @private
module NativeInteger
# http://stackoverflow.com/questions/535721/ruby-max-integer
MIN_VALUE = -(2**(0.size * 8 - 2))
MAX_VALUE = (2**(0.size * 8 - 2) - 1)
def ensure_upper_bound(value)
if value > MAX_VALUE
raise RangeError.new("#{value} is greater than the maximum value of #{MAX_VALUE}")
end
value
end
def ensure_lower_bound(value)
if value < MIN_VALUE
raise RangeError.new("#{value} is less than the maximum value of #{MIN_VALUE}")
end
value
end
def ensure_integer(value)
unless value.is_a?(Integer)
raise ArgumentError.new("#{value} is not an Integer")
end
value
end
def ensure_integer_and_bounds(value)
ensure_integer value
ensure_upper_bound value
ensure_lower_bound value
end
def ensure_positive(value)
if value < 0
raise ArgumentError.new("#{value} cannot be negative")
end
value
end
def ensure_positive_and_no_zero(value)
if value < 1
raise ArgumentError.new("#{value} cannot be negative or zero")
end
value
end
extend self
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/engine.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/engine.rb | module Concurrent
module Utility
# @!visibility private
module EngineDetector
def on_jruby?
ruby_engine == 'jruby'
end
def on_jruby_9000?
on_jruby? && ruby_version(:>=, 9, 0, 0, JRUBY_VERSION)
end
def on_cruby?
ruby_engine == 'ruby'
end
def on_rbx?
ruby_engine == 'rbx'
end
def on_truffle?
ruby_engine == 'jruby+truffle'
end
def on_windows?
!(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/).nil?
end
def on_osx?
!(RbConfig::CONFIG['host_os'] =~ /darwin|mac os/).nil?
end
def on_linux?
!(RbConfig::CONFIG['host_os'] =~ /linux/).nil?
end
def ruby_engine
defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
end
def ruby_version(comparison, major, minor, patch, version = RUBY_VERSION)
result = (version.split('.').map(&:to_i) <=> [major, minor, patch])
comparisons = { :== => [0],
:>= => [1, 0],
:<= => [-1, 0],
:> => [1],
:< => [-1] }
comparisons.fetch(comparison).include? result
end
end
end
# @!visibility private
extend Utility::EngineDetector
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/monotonic_time.rb | _vendor/ruby/2.6.0/gems/concurrent-ruby-1.0.5/lib/concurrent/utility/monotonic_time.rb | require 'concurrent/synchronization'
module Concurrent
class_definition = Class.new(Synchronization::LockableObject) do
def initialize
@last_time = Time.now.to_f
super()
end
if defined?(Process::CLOCK_MONOTONIC)
# @!visibility private
def get_time
Process.clock_gettime(Process::CLOCK_MONOTONIC)
end
elsif Concurrent.on_jruby?
# @!visibility private
def get_time
java.lang.System.nanoTime() / 1_000_000_000.0
end
else
# @!visibility private
def get_time
synchronize do
now = Time.now.to_f
if @last_time < now
@last_time = now
else # clock has moved back in time
@last_time += 0.000_001
end
end
end
end
end
# Clock that cannot be set and represents monotonic time since
# some unspecified starting point.
#
# @!visibility private
GLOBAL_MONOTONIC_CLOCK = class_definition.new
private_constant :GLOBAL_MONOTONIC_CLOCK
# @!macro [attach] monotonic_get_time
#
# Returns the current time a tracked by the application monotonic clock.
#
# @return [Float] The current monotonic time when `since` not given else
# the elapsed monotonic time between `since` and the current time
#
# @!macro monotonic_clock_warning
def monotonic_time
GLOBAL_MONOTONIC_CLOCK.get_time
end
module_function :monotonic_time
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/setup.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/setup.rb | #
# setup.rb
#
# Copyright (c) 2000-2005 Minero Aoki
#
# This program is free software.
# You can distribute/modify this program under the terms of
# the GNU LGPL, Lesser General Public License version 2.1.
#
unless Enumerable.method_defined?(:map) # Ruby 1.4.6
module Enumerable
alias map collect
end
end
unless File.respond_to?(:read) # Ruby 1.6
def File.read(fname)
open(fname) {|f|
return f.read
}
end
end
unless Errno.const_defined?(:ENOTEMPTY) # Windows?
module Errno
class ENOTEMPTY
# We do not raise this exception, implementation is not needed.
end
end
end
def File.binread(fname)
open(fname, 'rb') {|f|
return f.read
}
end
# for corrupted Windows' stat(2)
def File.dir?(path)
File.directory?((path[-1,1] == '/') ? path : path + '/')
end
class ConfigTable
include Enumerable
def initialize(rbconfig)
@rbconfig = rbconfig
@items = []
@table = {}
# options
@install_prefix = nil
@config_opt = nil
@verbose = true
@no_harm = false
end
attr_accessor :install_prefix
attr_accessor :config_opt
attr_writer :verbose
def verbose?
@verbose
end
attr_writer :no_harm
def no_harm?
@no_harm
end
def [](key)
lookup(key).resolve(self)
end
def []=(key, val)
lookup(key).set val
end
def names
@items.map {|i| i.name }
end
def each(&block)
@items.each(&block)
end
def key?(name)
@table.key?(name)
end
def lookup(name)
@table[name] or setup_rb_error "no such config item: #{name}"
end
def add(item)
@items.push item
@table[item.name] = item
end
def remove(name)
item = lookup(name)
@items.delete_if {|i| i.name == name }
@table.delete_if {|name, i| i.name == name }
item
end
def load_script(path, inst = nil)
if File.file?(path)
MetaConfigEnvironment.new(self, inst).instance_eval File.read(path), path
end
end
def savefile
'.config'
end
def load_savefile
begin
File.foreach(savefile()) do |line|
k, v = *line.split(/=/, 2)
self[k] = v.strip
end
rescue Errno::ENOENT
setup_rb_error $!.message + "\n#{File.basename($0)} config first"
end
end
def save
@items.each {|i| i.value }
File.open(savefile(), 'w') {|f|
@items.each do |i|
f.printf "%s=%s\n", i.name, i.value if i.value? and i.value
end
}
end
def load_standard_entries
standard_entries(@rbconfig).each do |ent|
add ent
end
end
def standard_entries(rbconfig)
c = rbconfig
rubypath = File.join(c['bindir'], c['ruby_install_name'] + c['EXEEXT'])
major = c['MAJOR'].to_i
minor = c['MINOR'].to_i
teeny = c['TEENY'].to_i
version = "#{major}.#{minor}"
# ruby ver. >= 1.4.4?
newpath_p = ((major >= 2) or
((major == 1) and
((minor >= 5) or
((minor == 4) and (teeny >= 4)))))
if c['rubylibdir']
# V > 1.6.3
libruby = "#{c['prefix']}/lib/ruby"
librubyver = c['rubylibdir']
librubyverarch = c['archdir']
siteruby = c['sitedir']
siterubyver = c['sitelibdir']
siterubyverarch = c['sitearchdir']
elsif newpath_p
# 1.4.4 <= V <= 1.6.3
libruby = "#{c['prefix']}/lib/ruby"
librubyver = "#{c['prefix']}/lib/ruby/#{version}"
librubyverarch = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}"
siteruby = c['sitedir']
siterubyver = "$siteruby/#{version}"
siterubyverarch = "$siterubyver/#{c['arch']}"
else
# V < 1.4.4
libruby = "#{c['prefix']}/lib/ruby"
librubyver = "#{c['prefix']}/lib/ruby/#{version}"
librubyverarch = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}"
siteruby = "#{c['prefix']}/lib/ruby/#{version}/site_ruby"
siterubyver = siteruby
siterubyverarch = "$siterubyver/#{c['arch']}"
end
parameterize = lambda {|path|
path.sub(/\A#{Regexp.quote(c['prefix'])}/, '$prefix')
}
if arg = c['configure_args'].split.detect {|arg| /--with-make-prog=/ =~ arg }
makeprog = arg.sub(/'/, '').split(/=/, 2)[1]
else
makeprog = 'make'
end
[
ExecItem.new('installdirs', 'std/site/home',
'std: install under libruby; site: install under site_ruby; home: install under $HOME')\
{|val, table|
case val
when 'std'
table['rbdir'] = '$librubyver'
table['sodir'] = '$librubyverarch'
when 'site'
table['rbdir'] = '$siterubyver'
table['sodir'] = '$siterubyverarch'
when 'home'
setup_rb_error '$HOME was not set' unless ENV['HOME']
table['prefix'] = ENV['HOME']
table['rbdir'] = '$libdir/ruby'
table['sodir'] = '$libdir/ruby'
end
},
PathItem.new('prefix', 'path', c['prefix'],
'path prefix of target environment'),
PathItem.new('bindir', 'path', parameterize.call(c['bindir']),
'the directory for commands'),
PathItem.new('libdir', 'path', parameterize.call(c['libdir']),
'the directory for libraries'),
PathItem.new('datadir', 'path', parameterize.call(c['datadir']),
'the directory for shared data'),
PathItem.new('mandir', 'path', parameterize.call(c['mandir']),
'the directory for man pages'),
PathItem.new('sysconfdir', 'path', parameterize.call(c['sysconfdir']),
'the directory for system configuration files'),
PathItem.new('localstatedir', 'path', parameterize.call(c['localstatedir']),
'the directory for local state data'),
PathItem.new('libruby', 'path', libruby,
'the directory for ruby libraries'),
PathItem.new('librubyver', 'path', librubyver,
'the directory for standard ruby libraries'),
PathItem.new('librubyverarch', 'path', librubyverarch,
'the directory for standard ruby extensions'),
PathItem.new('siteruby', 'path', siteruby,
'the directory for version-independent aux ruby libraries'),
PathItem.new('siterubyver', 'path', siterubyver,
'the directory for aux ruby libraries'),
PathItem.new('siterubyverarch', 'path', siterubyverarch,
'the directory for aux ruby binaries'),
PathItem.new('rbdir', 'path', '$siterubyver',
'the directory for ruby scripts'),
PathItem.new('sodir', 'path', '$siterubyverarch',
'the directory for ruby extentions'),
PathItem.new('rubypath', 'path', rubypath,
'the path to set to #! line'),
ProgramItem.new('rubyprog', 'name', rubypath,
'the ruby program using for installation'),
ProgramItem.new('makeprog', 'name', makeprog,
'the make program to compile ruby extentions'),
SelectItem.new('shebang', 'all/ruby/never', 'ruby',
'shebang line (#!) editing mode'),
BoolItem.new('without-ext', 'yes/no', 'no',
'does not compile/install ruby extentions')
]
end
private :standard_entries
def load_multipackage_entries
multipackage_entries().each do |ent|
add ent
end
end
def multipackage_entries
[
PackageSelectionItem.new('with', 'name,name...', '', 'ALL',
'package names that you want to install'),
PackageSelectionItem.new('without', 'name,name...', '', 'NONE',
'package names that you do not want to install')
]
end
private :multipackage_entries
ALIASES = {
'std-ruby' => 'librubyver',
'stdruby' => 'librubyver',
'rubylibdir' => 'librubyver',
'archdir' => 'librubyverarch',
'site-ruby-common' => 'siteruby', # For backward compatibility
'site-ruby' => 'siterubyver', # For backward compatibility
'bin-dir' => 'bindir',
'bin-dir' => 'bindir',
'rb-dir' => 'rbdir',
'so-dir' => 'sodir',
'data-dir' => 'datadir',
'ruby-path' => 'rubypath',
'ruby-prog' => 'rubyprog',
'ruby' => 'rubyprog',
'make-prog' => 'makeprog',
'make' => 'makeprog'
}
def fixup
ALIASES.each do |ali, name|
@table[ali] = @table[name]
end
@items.freeze
@table.freeze
@options_re = /\A--(#{@table.keys.join('|')})(?:=(.*))?\z/
end
def parse_opt(opt)
m = @options_re.match(opt) or setup_rb_error "config: unknown option #{opt}"
m.to_a[1,2]
end
def dllext
@rbconfig['DLEXT']
end
def value_config?(name)
lookup(name).value?
end
class Item
def initialize(name, template, default, desc)
@name = name.freeze
@template = template
@value = default
@default = default
@description = desc
end
attr_reader :name
attr_reader :description
attr_accessor :default
alias help_default default
def help_opt
"--#{@name}=#{@template}"
end
def value?
true
end
def value
@value
end
def resolve(table)
@value.gsub(%r<\$([^/]+)>) { table[$1] }
end
def set(val)
@value = check(val)
end
private
def check(val)
setup_rb_error "config: --#{name} requires argument" unless val
val
end
end
class BoolItem < Item
def config_type
'bool'
end
def help_opt
"--#{@name}"
end
private
def check(val)
return 'yes' unless val
case val
when /\Ay(es)?\z/i, /\At(rue)?\z/i then 'yes'
when /\An(o)?\z/i, /\Af(alse)\z/i then 'no'
else
setup_rb_error "config: --#{@name} accepts only yes/no for argument"
end
end
end
class PathItem < Item
def config_type
'path'
end
private
def check(path)
setup_rb_error "config: --#{@name} requires argument" unless path
path[0,1] == '$' ? path : File.expand_path(path)
end
end
class ProgramItem < Item
def config_type
'program'
end
end
class SelectItem < Item
def initialize(name, selection, default, desc)
super
@ok = selection.split('/')
end
def config_type
'select'
end
private
def check(val)
unless @ok.include?(val.strip)
setup_rb_error "config: use --#{@name}=#{@template} (#{val})"
end
val.strip
end
end
class ExecItem < Item
def initialize(name, selection, desc, &block)
super name, selection, nil, desc
@ok = selection.split('/')
@action = block
end
def config_type
'exec'
end
def value?
false
end
def resolve(table)
setup_rb_error "$#{name()} wrongly used as option value"
end
undef set
def evaluate(val, table)
v = val.strip.downcase
unless @ok.include?(v)
setup_rb_error "invalid option --#{@name}=#{val} (use #{@template})"
end
@action.call v, table
end
end
class PackageSelectionItem < Item
def initialize(name, template, default, help_default, desc)
super name, template, default, desc
@help_default = help_default
end
attr_reader :help_default
def config_type
'package'
end
private
def check(val)
unless File.dir?("packages/#{val}")
setup_rb_error "config: no such package: #{val}"
end
val
end
end
class MetaConfigEnvironment
def initialize(config, installer)
@config = config
@installer = installer
end
def config_names
@config.names
end
def config?(name)
@config.key?(name)
end
def bool_config?(name)
@config.lookup(name).config_type == 'bool'
end
def path_config?(name)
@config.lookup(name).config_type == 'path'
end
def value_config?(name)
@config.lookup(name).config_type != 'exec'
end
def add_config(item)
@config.add item
end
def add_bool_config(name, default, desc)
@config.add BoolItem.new(name, 'yes/no', default ? 'yes' : 'no', desc)
end
def add_path_config(name, default, desc)
@config.add PathItem.new(name, 'path', default, desc)
end
def set_config_default(name, default)
@config.lookup(name).default = default
end
def remove_config(name)
@config.remove(name)
end
# For only multipackage
def packages
raise '[setup.rb fatal] multi-package metaconfig API packages() called for single-package; contact application package vendor' unless @installer
@installer.packages
end
# For only multipackage
def declare_packages(list)
raise '[setup.rb fatal] multi-package metaconfig API declare_packages() called for single-package; contact application package vendor' unless @installer
@installer.packages = list
end
end
end # class ConfigTable
# This module requires: #verbose?, #no_harm?
module FileOperations
def mkdir_p(dirname, prefix = nil)
dirname = prefix + File.expand_path(dirname) if prefix
$stderr.puts "mkdir -p #{dirname}" if verbose?
return if no_harm?
# Does not check '/', it's too abnormal.
dirs = File.expand_path(dirname).split(%r<(?=/)>)
if /\A[a-z]:\z/i =~ dirs[0]
disk = dirs.shift
dirs[0] = disk + dirs[0]
end
dirs.each_index do |idx|
path = dirs[0..idx].join('')
Dir.mkdir path unless File.dir?(path)
end
end
def rm_f(path)
$stderr.puts "rm -f #{path}" if verbose?
return if no_harm?
force_remove_file path
end
def rm_rf(path)
$stderr.puts "rm -rf #{path}" if verbose?
return if no_harm?
remove_tree path
end
def remove_tree(path)
if File.symlink?(path)
remove_file path
elsif File.dir?(path)
remove_tree0 path
else
force_remove_file path
end
end
def remove_tree0(path)
Dir.foreach(path) do |ent|
next if ent == '.'
next if ent == '..'
entpath = "#{path}/#{ent}"
if File.symlink?(entpath)
remove_file entpath
elsif File.dir?(entpath)
remove_tree0 entpath
else
force_remove_file entpath
end
end
begin
Dir.rmdir path
rescue Errno::ENOTEMPTY
# directory may not be empty
end
end
def move_file(src, dest)
force_remove_file dest
begin
File.rename src, dest
rescue
File.open(dest, 'wb') {|f|
f.write File.binread(src)
}
File.chmod File.stat(src).mode, dest
File.unlink src
end
end
def force_remove_file(path)
begin
remove_file path
rescue
end
end
def remove_file(path)
File.chmod 0777, path
File.unlink path
end
def install(from, dest, mode, prefix = nil)
$stderr.puts "install #{from} #{dest}" if verbose?
return if no_harm?
realdest = prefix ? prefix + File.expand_path(dest) : dest
realdest = File.join(realdest, File.basename(from)) if File.dir?(realdest)
str = File.binread(from)
if diff?(str, realdest)
verbose_off {
rm_f realdest if File.exist?(realdest)
}
File.open(realdest, 'wb') {|f|
f.write str
}
File.chmod mode, realdest
File.open("#{objdir_root()}/InstalledFiles", 'a') {|f|
if prefix
f.puts realdest.sub(prefix, '')
else
f.puts realdest
end
}
end
end
def diff?(new_content, path)
return true unless File.exist?(path)
new_content != File.binread(path)
end
def command(*args)
$stderr.puts args.join(' ') if verbose?
system(*args) or raise RuntimeError,
"system(#{args.map{|a| a.inspect }.join(' ')}) failed"
end
def ruby(*args)
command config('rubyprog'), *args
end
def make(task = nil)
command(*[config('makeprog'), task].compact)
end
def extdir?(dir)
File.exist?("#{dir}/MANIFEST") or File.exist?("#{dir}/extconf.rb")
end
def files_of(dir)
Dir.open(dir) {|d|
return d.select {|ent| File.file?("#{dir}/#{ent}") }
}
end
DIR_REJECT = %w( . .. CVS SCCS RCS CVS.adm .svn )
def directories_of(dir)
Dir.open(dir) {|d|
return d.select {|ent| File.dir?("#{dir}/#{ent}") } - DIR_REJECT
}
end
end
# This module requires: #srcdir_root, #objdir_root, #relpath
module HookScriptAPI
def get_config(key)
@config[key]
end
alias config get_config
# obsolete: use metaconfig to change configuration
def set_config(key, val)
@config[key] = val
end
#
# srcdir/objdir (works only in the package directory)
#
def curr_srcdir
"#{srcdir_root()}/#{relpath()}"
end
def curr_objdir
"#{objdir_root()}/#{relpath()}"
end
def srcfile(path)
"#{curr_srcdir()}/#{path}"
end
def srcexist?(path)
File.exist?(srcfile(path))
end
def srcdirectory?(path)
File.dir?(srcfile(path))
end
def srcfile?(path)
File.file?(srcfile(path))
end
def srcentries(path = '.')
Dir.open("#{curr_srcdir()}/#{path}") {|d|
return d.to_a - %w(. ..)
}
end
def srcfiles(path = '.')
srcentries(path).select {|fname|
File.file?(File.join(curr_srcdir(), path, fname))
}
end
def srcdirectories(path = '.')
srcentries(path).select {|fname|
File.dir?(File.join(curr_srcdir(), path, fname))
}
end
end
class ToplevelInstaller
Version = '3.4.1'
Copyright = 'Copyright (c) 2000-2005 Minero Aoki'
TASKS = [
[ 'all', 'do config, setup, then install' ],
[ 'config', 'saves your configurations' ],
[ 'show', 'shows current configuration' ],
[ 'setup', 'compiles ruby extentions and others' ],
[ 'install', 'installs files' ],
[ 'test', 'run all tests in test/' ],
[ 'clean', "does `make clean' for each extention" ],
[ 'distclean',"does `make distclean' for each extention" ]
]
def ToplevelInstaller.invoke
config = ConfigTable.new(load_rbconfig())
config.load_standard_entries
config.load_multipackage_entries if multipackage?
config.fixup
klass = (multipackage?() ? ToplevelInstallerMulti : ToplevelInstaller)
klass.new(File.dirname($0), config).invoke
end
def ToplevelInstaller.multipackage?
File.dir?(File.dirname($0) + '/packages')
end
def ToplevelInstaller.load_rbconfig
if arg = ARGV.detect {|arg| /\A--rbconfig=/ =~ arg }
ARGV.delete(arg)
load File.expand_path(arg.split(/=/, 2)[1])
$".push 'rbconfig.rb'
else
require 'rbconfig'
end
::RbConfig::CONFIG
end
def initialize(ardir_root, config)
@ardir = File.expand_path(ardir_root)
@config = config
# cache
@valid_task_re = nil
end
def config(key)
@config[key]
end
def inspect
"#<#{self.class} #{__id__()}>"
end
def invoke
run_metaconfigs
case task = parsearg_global()
when nil, 'all'
parsearg_config
init_installers
exec_config
exec_setup
exec_install
else
case task
when 'config', 'test'
;
when 'clean', 'distclean'
@config.load_savefile if File.exist?(@config.savefile)
else
@config.load_savefile
end
__send__ "parsearg_#{task}"
init_installers
__send__ "exec_#{task}"
end
end
def run_metaconfigs
@config.load_script "#{@ardir}/metaconfig"
end
def init_installers
@installer = Installer.new(@config, @ardir, File.expand_path('.'))
end
#
# Hook Script API bases
#
def srcdir_root
@ardir
end
def objdir_root
'.'
end
def relpath
'.'
end
#
# Option Parsing
#
def parsearg_global
while arg = ARGV.shift
case arg
when /\A\w+\z/
setup_rb_error "invalid task: #{arg}" unless valid_task?(arg)
return arg
when '-q', '--quiet'
@config.verbose = false
when '--verbose'
@config.verbose = true
when '--help'
print_usage $stdout
exit 0
when '--version'
puts "#{File.basename($0)} version #{Version}"
exit 0
when '--copyright'
puts Copyright
exit 0
else
setup_rb_error "unknown global option '#{arg}'"
end
end
nil
end
def valid_task?(t)
valid_task_re() =~ t
end
def valid_task_re
@valid_task_re ||= /\A(?:#{TASKS.map {|task,desc| task }.join('|')})\z/
end
def parsearg_no_options
unless ARGV.empty?
task = caller(0).first.slice(%r<`parsearg_(\w+)'>, 1)
setup_rb_error "#{task}: unknown options: #{ARGV.join(' ')}"
end
end
alias parsearg_show parsearg_no_options
alias parsearg_setup parsearg_no_options
alias parsearg_test parsearg_no_options
alias parsearg_clean parsearg_no_options
alias parsearg_distclean parsearg_no_options
def parsearg_config
evalopt = []
set = []
@config.config_opt = []
while i = ARGV.shift
if /\A--?\z/ =~ i
@config.config_opt = ARGV.dup
break
end
name, value = *@config.parse_opt(i)
if @config.value_config?(name)
@config[name] = value
else
evalopt.push [name, value]
end
set.push name
end
evalopt.each do |name, value|
@config.lookup(name).evaluate value, @config
end
# Check if configuration is valid
set.each do |n|
@config[n] if @config.value_config?(n)
end
end
def parsearg_install
@config.no_harm = false
@config.install_prefix = ''
while a = ARGV.shift
case a
when '--no-harm'
@config.no_harm = true
when /\A--prefix=/
path = a.split(/=/, 2)[1]
path = File.expand_path(path) unless path[0,1] == '/'
@config.install_prefix = path
else
setup_rb_error "install: unknown option #{a}"
end
end
end
def print_usage(out)
out.puts 'Typical Installation Procedure:'
out.puts " $ ruby #{File.basename $0} config"
out.puts " $ ruby #{File.basename $0} setup"
out.puts " # ruby #{File.basename $0} install (may require root privilege)"
out.puts
out.puts 'Detailed Usage:'
out.puts " ruby #{File.basename $0} <global option>"
out.puts " ruby #{File.basename $0} [<global options>] <task> [<task options>]"
fmt = " %-24s %s\n"
out.puts
out.puts 'Global options:'
out.printf fmt, '-q,--quiet', 'suppress message outputs'
out.printf fmt, ' --verbose', 'output messages verbosely'
out.printf fmt, ' --help', 'print this message'
out.printf fmt, ' --version', 'print version and quit'
out.printf fmt, ' --copyright', 'print copyright and quit'
out.puts
out.puts 'Tasks:'
TASKS.each do |name, desc|
out.printf fmt, name, desc
end
fmt = " %-24s %s [%s]\n"
out.puts
out.puts 'Options for CONFIG or ALL:'
@config.each do |item|
out.printf fmt, item.help_opt, item.description, item.help_default
end
out.printf fmt, '--rbconfig=path', 'rbconfig.rb to load',"running ruby's"
out.puts
out.puts 'Options for INSTALL:'
out.printf fmt, '--no-harm', 'only display what to do if given', 'off'
out.printf fmt, '--prefix=path', 'install path prefix', ''
out.puts
end
#
# Task Handlers
#
def exec_config
@installer.exec_config
@config.save # must be final
end
def exec_setup
@installer.exec_setup
end
def exec_install
@installer.exec_install
end
def exec_test
@installer.exec_test
end
def exec_show
@config.each do |i|
printf "%-20s %s\n", i.name, i.value if i.value?
end
end
def exec_clean
@installer.exec_clean
end
def exec_distclean
@installer.exec_distclean
end
end # class ToplevelInstaller
class ToplevelInstallerMulti < ToplevelInstaller
include FileOperations
def initialize(ardir_root, config)
super
@packages = directories_of("#{@ardir}/packages")
raise 'no package exists' if @packages.empty?
@root_installer = Installer.new(@config, @ardir, File.expand_path('.'))
end
def run_metaconfigs
@config.load_script "#{@ardir}/metaconfig", self
@packages.each do |name|
@config.load_script "#{@ardir}/packages/#{name}/metaconfig"
end
end
attr_reader :packages
def packages=(list)
raise 'package list is empty' if list.empty?
list.each do |name|
raise "directory packages/#{name} does not exist"\
unless File.dir?("#{@ardir}/packages/#{name}")
end
@packages = list
end
def init_installers
@installers = {}
@packages.each do |pack|
@installers[pack] = Installer.new(@config,
"#{@ardir}/packages/#{pack}",
"packages/#{pack}")
end
with = extract_selection(config('with'))
without = extract_selection(config('without'))
@selected = @installers.keys.select {|name|
(with.empty? or with.include?(name)) \
and not without.include?(name)
}
end
def extract_selection(list)
a = list.split(/,/)
a.each do |name|
setup_rb_error "no such package: #{name}" unless @installers.key?(name)
end
a
end
def print_usage(f)
super
f.puts 'Inluded packages:'
f.puts ' ' + @packages.sort.join(' ')
f.puts
end
#
# Task Handlers
#
def exec_config
run_hook 'pre-config'
each_selected_installers {|inst| inst.exec_config }
run_hook 'post-config'
@config.save # must be final
end
def exec_setup
run_hook 'pre-setup'
each_selected_installers {|inst| inst.exec_setup }
run_hook 'post-setup'
end
def exec_install
run_hook 'pre-install'
each_selected_installers {|inst| inst.exec_install }
run_hook 'post-install'
end
def exec_test
run_hook 'pre-test'
each_selected_installers {|inst| inst.exec_test }
run_hook 'post-test'
end
def exec_clean
rm_f @config.savefile
run_hook 'pre-clean'
each_selected_installers {|inst| inst.exec_clean }
run_hook 'post-clean'
end
def exec_distclean
rm_f @config.savefile
run_hook 'pre-distclean'
each_selected_installers {|inst| inst.exec_distclean }
run_hook 'post-distclean'
end
#
# lib
#
def each_selected_installers
Dir.mkdir 'packages' unless File.dir?('packages')
@selected.each do |pack|
$stderr.puts "Processing the package `#{pack}' ..." if verbose?
Dir.mkdir "packages/#{pack}" unless File.dir?("packages/#{pack}")
Dir.chdir "packages/#{pack}"
yield @installers[pack]
Dir.chdir '../..'
end
end
def run_hook(id)
@root_installer.run_hook id
end
# module FileOperations requires this
def verbose?
@config.verbose?
end
# module FileOperations requires this
def no_harm?
@config.no_harm?
end
end # class ToplevelInstallerMulti
class Installer
FILETYPES = %w( bin lib ext data conf man )
include FileOperations
include HookScriptAPI
def initialize(config, srcroot, objroot)
@config = config
@srcdir = File.expand_path(srcroot)
@objdir = File.expand_path(objroot)
@currdir = '.'
end
def inspect
"#<#{self.class} #{File.basename(@srcdir)}>"
end
def noop(rel)
end
#
# Hook Script API base methods
#
def srcdir_root
@srcdir
end
def objdir_root
@objdir
end
def relpath
@currdir
end
#
# Config Access
#
# module FileOperations requires this
def verbose?
@config.verbose?
end
# module FileOperations requires this
def no_harm?
@config.no_harm?
end
def verbose_off
begin
save, @config.verbose = @config.verbose?, false
yield
ensure
@config.verbose = save
end
end
#
# TASK config
#
def exec_config
exec_task_traverse 'config'
end
alias config_dir_bin noop
alias config_dir_lib noop
def config_dir_ext(rel)
extconf if extdir?(curr_srcdir())
end
alias config_dir_data noop
alias config_dir_conf noop
alias config_dir_man noop
def extconf
ruby "#{curr_srcdir()}/extconf.rb", *@config.config_opt
end
#
# TASK setup
#
def exec_setup
exec_task_traverse 'setup'
end
def setup_dir_bin(rel)
files_of(curr_srcdir()).each do |fname|
update_shebang_line "#{curr_srcdir()}/#{fname}"
end
end
alias setup_dir_lib noop
def setup_dir_ext(rel)
make if extdir?(curr_srcdir())
end
alias setup_dir_data noop
alias setup_dir_conf noop
alias setup_dir_man noop
def update_shebang_line(path)
return if no_harm?
return if config('shebang') == 'never'
old = Shebang.load(path)
if old
$stderr.puts "warning: #{path}: Shebang line includes too many args. It is not portable and your program may not work." if old.args.size > 1
new = new_shebang(old)
return if new.to_s == old.to_s
else
return unless config('shebang') == 'all'
new = Shebang.new(config('rubypath'))
end
$stderr.puts "updating shebang: #{File.basename(path)}" if verbose?
open_atomic_writer(path) {|output|
File.open(path, 'rb') {|f|
f.gets if old # discard
output.puts new.to_s
output.print f.read
}
}
end
def new_shebang(old)
if /\Aruby/ =~ File.basename(old.cmd)
Shebang.new(config('rubypath'), old.args)
elsif File.basename(old.cmd) == 'env' and old.args.first == 'ruby'
Shebang.new(config('rubypath'), old.args[1..-1])
else
return old unless config('shebang') == 'all'
Shebang.new(config('rubypath'))
end
end
def open_atomic_writer(path, &block)
tmpfile = File.basename(path) + '.tmp'
begin
File.open(tmpfile, 'wb', &block)
File.rename tmpfile, File.basename(path)
ensure
File.unlink tmpfile if File.exist?(tmpfile)
end
end
class Shebang
def Shebang.load(path)
line = nil
File.open(path) {|f|
line = f.gets
}
return nil unless /\A#!/ =~ line
parse(line)
end
def Shebang.parse(line)
cmd, *args = *line.strip.sub(/\A\#!/, '').split(' ')
new(cmd, args)
end
def initialize(cmd, args = [])
@cmd = cmd
@args = args
end
attr_reader :cmd
attr_reader :args
def to_s
"#! #{@cmd}" + (@args.empty? ? '' : " #{@args.join(' ')}")
end
end
#
# TASK install
#
def exec_install
rm_f 'InstalledFiles'
exec_task_traverse 'install'
end
def install_dir_bin(rel)
install_files targetfiles(), "#{config('bindir')}/#{rel}", 0755
end
def install_dir_lib(rel)
install_files libfiles(), "#{config('rbdir')}/#{rel}", 0644
end
def install_dir_ext(rel)
return unless extdir?(curr_srcdir())
install_files rubyextentions('.'),
"#{config('sodir')}/#{File.dirname(rel)}",
0555
end
def install_dir_data(rel)
install_files targetfiles(), "#{config('datadir')}/#{rel}", 0644
end
def install_dir_conf(rel)
# FIXME: should not remove current config files
# (rename previous file to .old/.org)
install_files targetfiles(), "#{config('sysconfdir')}/#{rel}", 0644
end
def install_dir_man(rel)
install_files targetfiles(), "#{config('mandir')}/#{rel}", 0644
end
def install_files(list, dest, mode)
mkdir_p dest, @config.install_prefix
list.each do |fname|
install fname, dest, mode, @config.install_prefix
end
end
def libfiles
glob_reject(%w(*.y *.output), targetfiles())
end
def rubyextentions(dir)
ents = glob_select("*.#{@config.dllext}", targetfiles())
if ents.empty?
setup_rb_error "no ruby extention exists: 'ruby #{$0} setup' first"
end
ents
end
def targetfiles
mapdir(existfiles() - hookfiles())
end
def mapdir(ents)
ents.map {|ent|
if File.exist?(ent)
then ent # objdir
else "#{curr_srcdir()}/#{ent}" # srcdir
end
}
end
# picked up many entries from cvs-1.11.1/src/ignore.c
JUNK_FILES = %w(
core RCSLOG tags TAGS .make.state
.nse_depinfo #* .#* cvslog.* ,* .del-* *.olb
*~ *.old *.bak *.BAK *.orig *.rej _$* *$
*.org *.in .*
)
def existfiles
glob_reject(JUNK_FILES, (files_of(curr_srcdir()) | files_of('.')))
end
def hookfiles
%w( pre-%s post-%s pre-%s.rb post-%s.rb ).map {|fmt|
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | true |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/benchmark/benchmark.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/benchmark/benchmark.rb | require 'benchmark'
require 'stringio'
require 'kramdown'
require 'bluecloth'
require 'maruku'
require 'maruku/version'
require 'rdiscount'
require 'bluefeather'
require 'redcarpet'
module MaRuKu::Errors
def tell_user(s)
end
end
RUNS=20
FILES=['mdsyntax.text', 'mdbasics.text']
puts "Running tests on #{Time.now.strftime("%Y-%m-%d")} under #{RUBY_DESCRIPTION}"
FILES.each do |file|
data = File.read(File.join(File.dirname(__FILE__), file))
puts
puts "Test using file #{file} and #{RUNS} runs"
results = Benchmark.bmbm do |b|
b.report("kramdown #{Kramdown::VERSION}") { RUNS.times { Kramdown::Document.new(data).to_html } }
b.report("Maruku #{MaRuKu::Version}") { RUNS.times { Maruku.new(data, :on_error => :ignore).to_html } }
b.report("BlueFeather #{BlueFeather::VERSION}") { RUNS.times { BlueFeather.parse(data) } }
b.report("BlueCloth #{BlueCloth::VERSION}") { RUNS.times { BlueCloth.new(data).to_html } }
b.report("RDiscount #{RDiscount::VERSION}") { RUNS.times { RDiscount.new(data).to_html } }
b.report("redcarpet #{Redcarpet::VERSION}") { RUNS.times { Redcarpet::Markdown.new(Redcarpet::Render::HTML).render(data) } }
end
puts
puts "Real time of X divided by real time of kramdown"
kd = results.shift.real
%w[Maruku BlueFeather BlueCloth RDiscount redcarpet].each do |name|
puts name.ljust(19) << (results.shift.real/kd).round(4).to_s
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/benchmark/generate_data.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/benchmark/generate_data.rb | require 'benchmark'
require 'optparse'
require 'fileutils'
require 'kramdown'
options = {:others => false, :average => 1}
OptionParser.new do |opts|
opts.on("-a AVG", "--average AVG", Integer, "Average times over the specified number of runs") {|v| options[:average] = v }
opts.on("-o", "--[no-]others", "Generate data for other parsers") {|v| options[:others] = v}
opts.on("-g", "--[no-]graph", "Generate graph") {|v| options[:graph] = v}
opts.on("-k VERSION", "--kramdown VERSION", String, "Add benchmark data for kramdown version VERSION") {|v| options[:kramdown] = v}
end.parse!
THISRUBY = (self.class.const_defined?(:RUBY_DESCRIPTION) ? RUBY_DESCRIPTION.scan(/^.*?(?=\s*\()/).first.sub(/\s/, '-') : "ruby-#{RUBY_VERSION}") + '-' + RUBY_PATCHLEVEL.to_s
Dir.chdir(File.dirname(__FILE__))
BMDATA = File.read('mdbasics.text')
MULTIPLIER = (0..5).map {|i| 2**i}
if options[:others]
require 'maruku'
require 'maruku/version'
begin
require 'rdiscount'
rescue LoadError
end
#require 'bluefeather'
module MaRuKu::Errors
def tell_user(s)
end
end
bmdata = {}
labels = []
MULTIPLIER.each do |i|
$stderr.puts "Generating benchmark data for other parsers, multiplier #{i}"
mddata = BMDATA*i
labels = []
bmdata[i] = Benchmark::bmbm do |x|
labels << "Maruku #{MaRuKu::Version}"
x.report { Maruku.new(mddata, :on_error => :ignore).to_html }
if self.class.const_defined?(:BlueFeather)
labels << "BlueFeather #{BlueFeather::VERSION}"
x.report { BlueFeather.parse(mddata) }
end
if self.class.const_defined?(:RDiscount)
labels << "RDiscount #{RDiscount::VERSION}"
x.report { RDiscount.new(mddata).to_html }
end
end
end
File.open("static-#{THISRUBY}.dat", 'w+') do |f|
f.puts "# " + labels.join(" || ")
format_str = "%5d" + " %10.5f"*bmdata[MULTIPLIER.first].size
bmdata.sort.each do |m,v|
f.puts format_str % [m, *v.map {|tms| tms.real}]
end
end
end
if options[:kramdown]
kramdown = "kramdown-#{THISRUBY}.dat"
data = if File.exist?(kramdown)
lines = File.readlines(kramdown).map {|l| l.chomp}
lines.first << " || "
lines
else
["# ", *MULTIPLIER.map {|m| "%3d" % m}]
end
data.first << "#{options[:kramdown]}".rjust(10)
times = []
options[:average].times do
MULTIPLIER.each_with_index do |m, i|
$stderr.puts "Generating benchmark data for kramdown version #{options[:kramdown]}, multiplier #{m}"
mddata = BMDATA*m
begin
(times[i] ||= []) << Benchmark::bmbm {|x| x.report { Kramdown::Document.new(mddata).to_html } }.first.real
rescue
$stderr.puts $!.message
(times[i] ||= []) << 0
end
end
end
times.each_with_index {|t,i| data[i+1] << "%14.5f" % (t.inject(0) {|sum,v| sum+v}/3.0)}
File.open(kramdown, 'w+') do |f|
data.each {|l| f.puts l}
end
end
if options[:graph]
Dir['kramdown-*.dat'].each do |kramdown_name|
theruby = kramdown_name.sub(/^kramdown-/, '').sub(/\.dat$/, '')
graph_name = "graph-#{theruby}.png"
static_name = "static-#{theruby}.dat"
kramdown_names = File.readlines(kramdown_name).first.chomp[1..-1].split(/\s*\|\|\s*/)
static_names = (File.exist?(static_name) ? File.readlines(static_name).first.chomp[1..-1].split(/\s*\|\|\s*/) : [])
File.open("gnuplot.dat", "w+") do |f|
f.puts <<EOF
set title "Execution Time Performance for #{theruby}"
set xlabel "File Multiplier (i.e. n times mdbasic.text)"
set ylabel "Execution Time in secondes"
set key left top
set grid
set terminal png
set output "#{graph_name}"
EOF
f.print "plot "
i, j = 1, 1
f.puts((kramdown_names.map {|n| i += 1; "\"#{kramdown_name}\" using 1:#{i} with lp title \"#{n}\""} +
static_names.map {|n| j += 1; n =~ /bluefeather/i ? nil : "\"#{static_name}\" using 1:#{j} with lp title \"#{n}\""}.compact
).join(", "))
end
`gnuplot gnuplot.dat`
FileUtils.rm("gnuplot.dat")
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/test/run_tests.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/test/run_tests.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
$:.unshift File.dirname(__FILE__) + '/../lib'
require 'kramdown'
require 'test/unit/assertions'
require 'yaml'
include Test::Unit::Assertions
arg = ARGV[0] || File.join(File.dirname(__FILE__), 'testcases')
arg = if File.directory?(arg)
File.join(arg, '**/*.text')
else
arg + '.text'
end
width = ((size = %x{stty size 2>/dev/null}).length > 0 ? size.split.last.to_i : 72) rescue 72
width -= 8
fwidth = 0
Dir[arg].each {|f| fwidth = [fwidth, f.length + 10].max }.each do |file|
print(('Testing ' + file + ' ').ljust([fwidth, width].min))
$stdout.flush
html_file = file.sub('.text', '.html')
opts_file = file.sub('.text', '.options')
opts_file = File.join(File.dirname(file), 'options') if !File.exist?(opts_file)
options = File.exist?(opts_file) ? YAML::load(File.read(opts_file)) : {:auto_ids => false, :footnote_nr => 1}
doc = Kramdown::Document.new(File.read(file), options)
begin
assert_equal(File.read(html_file), doc.to_html)
puts 'PASSED'
rescue Exception => e
puts ' FAILED'
puts $!.message if $VERBOSE
puts $!.backtrace if $DEBUG
end
puts "Warnings:\n" + doc.warnings.join("\n") if !doc.warnings.empty? && $VERBOSE
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/test/test_files.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/test/test_files.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'minitest/autorun'
require 'kramdown'
require 'yaml'
require 'tmpdir'
begin
require 'kramdown/converter/syntax_highlighter/rouge'
Kramdown::Converter::SyntaxHighlighter::Rouge.formatter_class.send(:define_method, :format) do |tokens, &b|
super(tokens, &b).sub(/<\/code><\/pre>\n?/, "</code></pre>\n")
end
# custom formatter for tests
class RougeHTMLFormatters < Kramdown::Converter::SyntaxHighlighter::Rouge.formatter_class
tag 'rouge_html_formatters'
def stream(tokens, &b)
yield %(<div class="custom-class">)
super
yield %(</div>)
end
end
rescue LoadError, SyntaxError, NameError
end
Encoding.default_external = 'utf-8' if RUBY_VERSION >= '1.9'
class TestFiles < Minitest::Test
MATHJAX_NODE_AVAILABLE = begin
require 'kramdown/converter/math_engine/mathjaxnode'
Kramdown::Converter::MathEngine::MathjaxNode::AVAILABLE or
warn("Skipping MathjaxNode tests as MathjaxNode is not available")
end
SSKATEX_AVAILABLE = begin
/ class="katex"/ === Kramdown::Document.
new('$$a$$', {:math_engine => :sskatex}).to_html or
warn("Skipping SsKaTeX tests as SsKaTeX is not available.")
rescue
warn("Skipping SsKaTeX tests as default SsKaTeX config does not work.")
end or warn("Run \"rake dev:test_sskatex_deps\" to see why.")
KATEX_AVAILABLE = RUBY_VERSION >= '2.3'
EXCLUDE_KD_FILES = [('test/testcases/block/04_header/with_auto_ids.text' if RUBY_VERSION <= '1.8.6'), # bc of dep stringex not working
('test/testcases/span/03_codespan/rouge/' if RUBY_VERSION < '2.0'), #bc of rouge
('test/testcases/block/06_codeblock/rouge/' if RUBY_VERSION < '2.0'), #bc of rouge
('test/testcases/block/15_math/itex2mml.text' if RUBY_PLATFORM == 'java'), # bc of itextomml
('test/testcases/span/math/itex2mml.text' if RUBY_PLATFORM == 'java'), # bc of itextomml
('test/testcases/block/15_math/mathjaxnode.text' unless MATHJAX_NODE_AVAILABLE),
('test/testcases/block/15_math/mathjaxnode_notexhints.text' unless MATHJAX_NODE_AVAILABLE),
('test/testcases/block/15_math/mathjaxnode_semantics.text' unless MATHJAX_NODE_AVAILABLE),
('test/testcases/span/math/mathjaxnode.text' unless MATHJAX_NODE_AVAILABLE),
('test/testcases/block/15_math/sskatex.text' unless SSKATEX_AVAILABLE),
('test/testcases/span/math/sskatex.text' unless SSKATEX_AVAILABLE),
('test/testcases/block/15_math/katex.text' unless KATEX_AVAILABLE),
('test/testcases/span/math/katex.text' unless KATEX_AVAILABLE),
].compact
# Generate test methods for kramdown-to-xxx conversion
Dir[File.dirname(__FILE__) + '/testcases/**/*.text'].each do |text_file|
next if EXCLUDE_KD_FILES.any? {|f| text_file =~ /#{f}/}
basename = text_file.sub(/\.text$/, '')
opts_file = text_file.sub(/\.text$/, '.options')
(Dir[basename + ".*"] - [text_file, opts_file]).each do |output_file|
next if (RUBY_VERSION >= '1.9' && File.exist?(output_file + '.19')) ||
(RUBY_VERSION < '1.9' && output_file =~ /\.19$/)
output_format = File.extname(output_file.sub(/\.19$/, ''))[1..-1]
next if !Kramdown::Converter.const_defined?(output_format[0..0].upcase + output_format[1..-1])
define_method('test_' + text_file.tr('.', '_') + "_to_#{output_format}") do
opts_file = File.join(File.dirname(text_file), 'options') if !File.exist?(opts_file)
options = File.exist?(opts_file) ? YAML::load(File.read(opts_file)) : {:auto_ids => false, :footnote_nr => 1}
doc = Kramdown::Document.new(File.read(text_file), options)
assert_equal(File.read(output_file), doc.send("to_#{output_format}"))
end
end
end
# Generate test methods for html-to-{html,kramdown} conversion
`tidy -v 2>&1`
if $?.exitstatus != 0
warn("Skipping html-to-{html,kramdown} tests because tidy executable is missing")
else
EXCLUDE_HTML_FILES = ['test/testcases/block/06_codeblock/whitespace.html', # bc of span inside pre
'test/testcases/block/09_html/simple.html', # bc of xml elements
'test/testcases/span/03_codespan/highlighting.html', # bc of span elements inside code element
'test/testcases/block/04_header/with_auto_ids.html', # bc of auto_ids=true option
'test/testcases/block/04_header/header_type_offset.html', # bc of header_offset option
'test/testcases/block/06_codeblock/rouge/simple.html', # bc of double surrounding <div>
'test/testcases/block/06_codeblock/rouge/multiple.html', # bc of double surrounding <div>
('test/testcases/span/03_codespan/rouge/simple.html' if RUBY_VERSION < '2.0'),
('test/testcases/span/03_codespan/rouge/disabled.html' if RUBY_VERSION < '2.0'),
'test/testcases/block/14_table/empty_tag_in_cell.html', # bc of tidy
'test/testcases/block/15_math/ritex.html', # bc of tidy
'test/testcases/span/math/ritex.html', # bc of tidy
'test/testcases/block/15_math/itex2mml.html', # bc of tidy
'test/testcases/span/math/itex2mml.html', # bc of tidy
'test/testcases/block/15_math/mathjaxnode.html', # bc of tidy
'test/testcases/block/15_math/mathjaxnode_notexhints.html', # bc of tidy
'test/testcases/block/15_math/mathjaxnode_semantics.html', # bc of tidy
'test/testcases/span/math/mathjaxnode.html', # bc of tidy
'test/testcases/block/15_math/mathjax_preview.html', # bc of mathjax preview
'test/testcases/block/15_math/mathjax_preview_simple.html', # bc of mathjax preview
'test/testcases/block/15_math/mathjax_preview_as_code.html', # bc of mathjax preview
'test/testcases/span/math/sskatex.html', # bc of tidy
'test/testcases/block/15_math/sskatex.html', # bc of tidy
'test/testcases/span/math/katex.html', # bc of tidy
'test/testcases/block/15_math/katex.html', # bc of tidy
'test/testcases/span/05_html/mark_element.html', # bc of tidy
'test/testcases/block/09_html/xml.html', # bc of tidy
'test/testcases/span/05_html/xml.html', # bc of tidy
].compact
EXCLUDE_HTML_TEXT_FILES = ['test/testcases/block/09_html/parse_as_span.htmlinput',
'test/testcases/block/09_html/parse_as_raw.htmlinput',
].compact
Dir[File.dirname(__FILE__) + '/testcases/**/*.{html,html.19,htmlinput,htmlinput.19}'].each do |html_file|
next if EXCLUDE_HTML_FILES.any? {|f| html_file =~ /#{f}(\.19)?$/}
next if (RUBY_VERSION >= '1.9' && File.exist?(html_file + '.19')) ||
(RUBY_VERSION < '1.9' && html_file =~ /\.19$/)
out_files = []
out_files << [(html_file =~ /\.htmlinput(\.19)?$/ ? html_file.sub(/input(\.19)?$/, '') : html_file), :to_html]
if html_file =~ /\.htmlinput(\.19)?$/ && !EXCLUDE_HTML_TEXT_FILES.any? {|f| html_file =~ /#{f}/}
out_files << [html_file.sub(/htmlinput(\.19)?$/, 'text'), :to_kramdown]
end
out_files.select {|f, _| File.exist?(f)}.each do |out_file, out_method|
define_method('test_' + html_file.tr('.', '_') + "_to_#{File.extname(out_file)}") do
opts_file = html_file.sub(/\.html(input)?(\.19)?$/, '.options')
opts_file = File.join(File.dirname(html_file), 'options') if !File.exist?(opts_file)
options = File.exist?(opts_file) ? YAML::load(File.read(opts_file)) : {:auto_ids => false, :footnote_nr => 1}
doc = Kramdown::Document.new(File.read(html_file), options.merge(:input => 'html'))
if out_method == :to_html
assert_equal(tidy_output(File.read(out_file)), tidy_output(doc.send(out_method)))
else
assert_equal(File.read(out_file), doc.send(out_method))
end
end
end
end
end
def tidy_output(out)
cmd = "tidy -q --doctype omit #{RUBY_VERSION >= '1.9' ? '-utf8' : '-raw'} 2>/dev/null"
result = IO.popen(cmd, 'r+') do |io|
io.write(out)
io.close_write
io.read
end
if $?.exitstatus == 2
raise "Problem using tidy"
end
result
end
# Generate test methods for text-to-latex conversion and compilation
`latex -v 2>&1`
if $?.exitstatus != 0
warn("Skipping latex compilation tests because latex executable is missing")
else
EXCLUDE_LATEX_FILES = ['test/testcases/span/01_link/image_in_a.text', # bc of image link
'test/testcases/span/01_link/imagelinks.text', # bc of image links
'test/testcases/span/01_link/empty_title.text',
'test/testcases/span/04_footnote/markers.text', # bc of footnote in header
'test/testcases/block/06_codeblock/with_lang_in_fenced_block_name_with_dash.text',
'test/testcases/block/06_codeblock/with_lang_in_fenced_block_any_char.text',
].compact
Dir[File.dirname(__FILE__) + '/testcases/**/*.text'].each do |text_file|
next if EXCLUDE_LATEX_FILES.any? {|f| text_file =~ /#{f}$/}
define_method('test_' + text_file.tr('.', '_') + "_to_latex_compilation") do
latex = Kramdown::Document.new(File.read(text_file),
:auto_ids => false, :footnote_nr => 1,
:template => 'document').to_latex
Dir.mktmpdir do |tmpdir|
result = IO.popen("latex -output-directory='#{tmpdir}' 2>/dev/null", 'r+') do |io|
io.write(latex)
io.close_write
io.read
end
assert($?.exitstatus == 0, result.scan(/^!(.*\n.*)/).join("\n"))
end
end
end
end
# Generate test methods for text->kramdown->html conversion
`tidy -v 2>&1`
if $?.exitstatus != 0
warn("Skipping text->kramdown->html tests because tidy executable is missing")
else
EXCLUDE_TEXT_FILES = ['test/testcases/span/05_html/markdown_attr.text', # bc of markdown attr
'test/testcases/block/09_html/markdown_attr.text', # bc of markdown attr
'test/testcases/span/extension/options.text', # bc of parse_span_html option
'test/testcases/block/12_extension/options.text', # bc of options option
'test/testcases/block/12_extension/options3.text', # bc of options option
'test/testcases/block/09_html/content_model/tables.text', # bc of parse_block_html option
'test/testcases/block/09_html/html_to_native/header.text', # bc of auto_ids option that interferes
'test/testcases/block/09_html/html_to_native/table_simple.text', # bc of tr style attr getting removed
'test/testcases/block/09_html/simple.text', # bc of webgen:block elements
'test/testcases/block/11_ial/simple.text', # bc of change of ordering of attributes in header
'test/testcases/span/extension/comment.text', # bc of comment text modifications (can this be avoided?)
'test/testcases/block/04_header/header_type_offset.text', # bc of header_offset being applied twice
('test/testcases/block/04_header/with_auto_ids.text' if RUBY_VERSION <= '1.8.6'), # bc of dep stringex not working
('test/testcases/span/03_codespan/rouge/simple.text' if RUBY_VERSION < '2.0'), #bc of rouge
('test/testcases/span/03_codespan/rouge/disabled.text' if RUBY_VERSION < '2.0'), #bc of rouge
'test/testcases/block/06_codeblock/rouge/simple.text',
'test/testcases/block/06_codeblock/rouge/multiple.text', # check, what document contain more, than one code block
'test/testcases/block/14_table/empty_tag_in_cell.text', # bc of tidy
'test/testcases/block/15_math/ritex.text', # bc of tidy
'test/testcases/span/math/ritex.text', # bc of tidy
'test/testcases/block/15_math/itex2mml.text', # bc of tidy
'test/testcases/span/math/itex2mml.text', # bc of tidy
'test/testcases/block/15_math/mathjaxnode.text', # bc of tidy
'test/testcases/block/15_math/mathjaxnode_notexhints.text', # bc of tidy
'test/testcases/block/15_math/mathjaxnode_semantics.text', # bc of tidy
'test/testcases/span/math/mathjaxnode.text', # bc of tidy
'test/testcases/block/15_math/sskatex.text', # bc of tidy
'test/testcases/span/math/sskatex.text', # bc of tidy
'test/testcases/block/15_math/katex.text', # bc of tidy
'test/testcases/span/math/katex.text', # bc of tidy
'test/testcases/span/01_link/link_defs_with_ial.text', # bc of attribute ordering
'test/testcases/span/05_html/mark_element.text', # bc of tidy
'test/testcases/block/09_html/xml.text', # bc of tidy
'test/testcases/span/05_html/xml.text', # bc of tidy
].compact
Dir[File.dirname(__FILE__) + '/testcases/**/*.text'].each do |text_file|
next if EXCLUDE_TEXT_FILES.any? {|f| text_file =~ /#{f}$/}
html_file = text_file.sub(/\.text$/, '.html')
html_file += '.19' if RUBY_VERSION >= '1.9' && File.exist?(html_file + '.19')
next unless File.exist?(html_file)
define_method('test_' + text_file.tr('.', '_') + "_to_kramdown_to_html") do
opts_file = text_file.sub(/\.text$/, '.options')
opts_file = File.join(File.dirname(text_file), 'options') if !File.exist?(opts_file)
options = File.exist?(opts_file) ? YAML::load(File.read(opts_file)) : {:auto_ids => false, :footnote_nr => 1}
kdtext = Kramdown::Document.new(File.read(text_file), options).to_kramdown
html = Kramdown::Document.new(kdtext, options).to_html
assert_equal(tidy_output(File.read(html_file)), tidy_output(html))
end
end
end
# Generate test methods for html-to-kramdown-to-html conversion
`tidy -v 2>&1`
if $?.exitstatus != 0
warn("Skipping html-to-kramdown-to-html tests because tidy executable is missing")
else
EXCLUDE_HTML_KD_FILES = ['test/testcases/span/extension/options.html', # bc of parse_span_html option
'test/testcases/span/05_html/normal.html', # bc of br tag before closing p tag
'test/testcases/block/12_extension/nomarkdown.html', # bc of nomarkdown extension
'test/testcases/block/09_html/simple.html', # bc of webgen:block elements
'test/testcases/block/09_html/markdown_attr.html', # bc of markdown attr
'test/testcases/block/09_html/html_to_native/table_simple.html', # bc of invalidly converted simple table
'test/testcases/block/06_codeblock/whitespace.html', # bc of entity to char conversion
'test/testcases/block/06_codeblock/rouge/simple.html', # bc of double surrounding <div>
'test/testcases/block/06_codeblock/rouge/multiple.html', # bc of double surrounding <div>
'test/testcases/block/11_ial/simple.html', # bc of change of ordering of attributes in header
'test/testcases/span/03_codespan/highlighting.html', # bc of span elements inside code element
'test/testcases/block/04_header/with_auto_ids.html', # bc of auto_ids=true option
'test/testcases/block/04_header/header_type_offset.html', # bc of header_offset option
'test/testcases/block/16_toc/toc_exclude.html', # bc of different attribute ordering
'test/testcases/span/autolinks/url_links.html', # bc of quot entity being converted to char
('test/testcases/span/03_codespan/rouge/simple.html' if RUBY_VERSION < '2.0'),
('test/testcases/span/03_codespan/rouge/disabled.html' if RUBY_VERSION < '2.0'),
'test/testcases/block/14_table/empty_tag_in_cell.html', # bc of tidy
'test/testcases/block/15_math/ritex.html', # bc of tidy
'test/testcases/span/math/ritex.html', # bc of tidy
'test/testcases/block/15_math/itex2mml.html', # bc of tidy
'test/testcases/span/math/itex2mml.html', # bc of tidy
'test/testcases/block/15_math/mathjaxnode.html', # bc of tidy
'test/testcases/block/15_math/mathjaxnode_notexhints.html', # bc of tidy
'test/testcases/block/15_math/mathjaxnode_semantics.html', # bc of tidy
'test/testcases/span/math/mathjaxnode.html', # bc of tidy
'test/testcases/block/15_math/sskatex.html', # bc of tidy
'test/testcases/span/math/sskatex.html', # bc of tidy
'test/testcases/block/15_math/katex.html', # bc of tidy
'test/testcases/span/math/katex.html', # bc of tidy
'test/testcases/block/15_math/mathjax_preview.html', # bc of mathjax preview
'test/testcases/block/15_math/mathjax_preview_simple.html', # bc of mathjax preview
'test/testcases/block/15_math/mathjax_preview_as_code.html', # bc of mathjax preview
'test/testcases/span/01_link/link_defs_with_ial.html', # bc of attribute ordering
'test/testcases/span/05_html/mark_element.html', # bc of tidy
'test/testcases/block/09_html/xml.html', # bc of tidy
'test/testcases/span/05_html/xml.html', # bc of tidy
].compact
Dir[File.dirname(__FILE__) + '/testcases/**/*.{html,html.19}'].each do |html_file|
next if EXCLUDE_HTML_KD_FILES.any? {|f| html_file =~ /#{f}(\.19)?$/}
next if (RUBY_VERSION >= '1.9' && File.exist?(html_file + '.19')) ||
(RUBY_VERSION < '1.9' && html_file =~ /\.19$/)
define_method('test_' + html_file.tr('.', '_') + "_to_kramdown_to_html") do
kd = Kramdown::Document.new(File.read(html_file), :input => 'html', :auto_ids => false, :footnote_nr => 1).to_kramdown
opts_file = html_file.sub(/\.html(\.19)?$/, '.options')
opts_file = File.join(File.dirname(html_file), 'options') if !File.exist?(opts_file)
options = File.exist?(opts_file) ? YAML::load(File.read(opts_file)) : {:auto_ids => false, :footnote_nr => 1}
doc = Kramdown::Document.new(kd, options)
assert_equal(tidy_output(File.read(html_file)), tidy_output(doc.to_html))
end
end
end
# Generate test methods for text-manpage conversion
Dir[File.dirname(__FILE__) + '/testcases/man/**/*.text'].each do |text_file|
define_method('test_' + text_file.tr('.', '_') + "_to_man") do
man_file = text_file.sub(/\.text$/, '.man')
doc = Kramdown::Document.new(File.read(text_file))
assert_equal(File.read(man_file), doc.to_man)
end
end
EXCLUDE_GFM_FILES = [
'test/testcases/block/03_paragraph/no_newline_at_end.text',
'test/testcases/block/03_paragraph/indented.text',
'test/testcases/block/03_paragraph/two_para.text',
'test/testcases/block/03_paragraph/line_break_last_line.text',
'test/testcases/block/04_header/atx_header.text',
'test/testcases/block/04_header/setext_header.text',
'test/testcases/block/04_header/with_auto_ids.text', # bc of ID generation difference
'test/testcases/block/04_header/with_auto_id_prefix.text', # bc of ID generation difference
'test/testcases/block/05_blockquote/indented.text',
'test/testcases/block/05_blockquote/lazy.text',
'test/testcases/block/05_blockquote/nested.text',
'test/testcases/block/05_blockquote/no_newline_at_end.text',
'test/testcases/block/06_codeblock/error.text',
'test/testcases/block/07_horizontal_rule/error.text',
'test/testcases/block/08_list/escaping.text',
'test/testcases/block/08_list/item_ial.text',
'test/testcases/block/08_list/lazy.text',
'test/testcases/block/08_list/list_and_others.text',
'test/testcases/block/08_list/other_first_element.text',
'test/testcases/block/08_list/simple_ul.text',
'test/testcases/block/08_list/special_cases.text',
'test/testcases/block/08_list/lazy_and_nested.text', # bc of change in lazy line handling
'test/testcases/block/09_html/comment.text',
'test/testcases/block/09_html/html_to_native/code.text',
'test/testcases/block/09_html/html_to_native/emphasis.text',
'test/testcases/block/09_html/html_to_native/typography.text',
'test/testcases/block/09_html/parse_as_raw.text',
'test/testcases/block/09_html/simple.text',
'test/testcases/block/12_extension/comment.text',
'test/testcases/block/12_extension/ignored.text',
'test/testcases/block/12_extension/nomarkdown.text',
'test/testcases/block/13_definition_list/item_ial.text',
'test/testcases/block/13_definition_list/multiple_terms.text',
'test/testcases/block/13_definition_list/no_def_list.text',
'test/testcases/block/13_definition_list/simple.text',
'test/testcases/block/13_definition_list/with_blocks.text',
'test/testcases/block/14_table/errors.text',
'test/testcases/block/14_table/escaping.text',
'test/testcases/block/14_table/simple.text',
'test/testcases/block/15_math/normal.text',
'test/testcases/block/16_toc/toc_with_footnotes.text', # bc of ID generation difference
'test/testcases/encoding.text',
'test/testcases/span/01_link/inline.text',
'test/testcases/span/01_link/link_defs.text',
'test/testcases/span/01_link/reference.text',
'test/testcases/span/02_emphasis/normal.text',
'test/testcases/span/03_codespan/normal.text',
'test/testcases/span/04_footnote/definitions.text',
'test/testcases/span/04_footnote/markers.text',
'test/testcases/span/05_html/across_lines.text',
'test/testcases/span/05_html/markdown_attr.text',
'test/testcases/span/05_html/normal.text',
'test/testcases/span/05_html/raw_span_elements.text',
'test/testcases/span/autolinks/url_links.text',
'test/testcases/span/extension/comment.text',
'test/testcases/span/ial/simple.text',
'test/testcases/span/line_breaks/normal.text',
'test/testcases/span/math/normal.text',
'test/testcases/span/text_substitutions/entities_as_char.text',
'test/testcases/span/text_substitutions/entities.text',
'test/testcases/span/text_substitutions/typography.text',
('test/testcases/span/03_codespan/rouge/simple.text' if RUBY_VERSION < '2.0'),
('test/testcases/span/03_codespan/rouge/disabled.text' if RUBY_VERSION < '2.0'),
('test/testcases/block/06_codeblock/rouge/simple.text' if RUBY_VERSION < '2.0'), #bc of rouge
('test/testcases/block/06_codeblock/rouge/disabled.text' if RUBY_VERSION < '2.0'), #bc of rouge
('test/testcases/block/06_codeblock/rouge/multiple.text' if RUBY_VERSION < '2.0'), #bc of rouge
('test/testcases/block/15_math/itex2mml.text' if RUBY_PLATFORM == 'java'), # bc of itextomml
('test/testcases/span/math/itex2mml.text' if RUBY_PLATFORM == 'java'), # bc of itextomml
('test/testcases/block/15_math/mathjaxnode.text' unless MATHJAX_NODE_AVAILABLE),
('test/testcases/block/15_math/mathjaxnode_notexhints.text' unless MATHJAX_NODE_AVAILABLE),
('test/testcases/block/15_math/mathjaxnode_semantics.text' unless MATHJAX_NODE_AVAILABLE),
('test/testcases/span/math/mathjaxnode.text' unless MATHJAX_NODE_AVAILABLE),
('test/testcases/block/15_math/sskatex.text' unless SSKATEX_AVAILABLE),
('test/testcases/span/math/sskatex.text' unless SSKATEX_AVAILABLE),
('test/testcases/block/15_math/katex.text' unless KATEX_AVAILABLE),
('test/testcases/span/math/katex.text' unless KATEX_AVAILABLE),
].compact
# Generate test methods for gfm-to-html conversion
Dir[File.dirname(__FILE__) + '/{testcases,testcases_gfm}/**/*.text'].each do |text_file|
next if EXCLUDE_GFM_FILES.any? {|f| text_file =~ /#{f}$/}
basename = text_file.sub(/\.text$/, '')
html_file = [(".html.19" if RUBY_VERSION >= '1.9'), ".html"].compact.
map {|ext| basename + ext }.
detect {|file| File.exist?(file) }
next unless html_file
define_method('test_gfm_' + text_file.tr('.', '_') + "_to_html") do
opts_file = basename + '.options'
opts_file = File.join(File.dirname(html_file), 'options') if !File.exist?(opts_file)
options = File.exist?(opts_file) ? YAML::load(File.read(opts_file)) : {:auto_ids => false, :footnote_nr => 1}
doc = Kramdown::Document.new(File.read(text_file), options.merge(:input => 'GFM'))
assert_equal(File.read(html_file), doc.to_html)
end
end
EXCLUDE_PDF_MODIFY = ['test/testcases/span/text_substitutions/entities.text',
'test/testcases/span/text_substitutions/entities_numeric.text',
'test/testcases/span/text_substitutions/entities_as_char.text',
'test/testcases/span/text_substitutions/entities_as_input.text',
'test/testcases/span/text_substitutions/entities_symbolic.text',
'test/testcases/block/04_header/with_auto_ids.text',
].compact
EXCLUDE_MODIFY = ['test/testcases/block/06_codeblock/rouge/multiple.text', # bc of HTMLFormater in options
('test/testcases/block/15_math/sskatex.text' unless SSKATEX_AVAILABLE),
('test/testcases/span/math/sskatex.text' unless SSKATEX_AVAILABLE),
('test/testcases/block/15_math/katex.text' unless KATEX_AVAILABLE),
('test/testcases/span/math/katex.text' unless KATEX_AVAILABLE),
].compact
# Generate test methods for asserting that converters don't modify the document tree.
Dir[File.dirname(__FILE__) + '/testcases/**/*.text'].each do |text_file|
opts_file = text_file.sub(/\.text$/, '.options')
options = File.exist?(opts_file) ? YAML::load(File.read(opts_file)) : {:auto_ids => false, :footnote_nr => 1}
(Kramdown::Converter.constants.map {|c| c.to_sym} - [:Base, :RemoveHtmlTags, :MathEngine, :SyntaxHighlighter]).each do |conv_class|
next if EXCLUDE_MODIFY.any? {|f| text_file =~ /#{f}$/}
next if conv_class == :Pdf && (RUBY_VERSION < '2.0' || EXCLUDE_PDF_MODIFY.any? {|f| text_file =~ /#{f}$/})
define_method("test_whether_#{conv_class}_modifies_tree_with_file_#{text_file.tr('.', '_')}") do
doc = Kramdown::Document.new(File.read(text_file), options)
options_before = Marshal.load(Marshal.dump(doc.options))
tree_before = Marshal.load(Marshal.dump(doc.root))
Kramdown::Converter.const_get(conv_class).convert(doc.root, doc.options)
assert_equal(options_before, doc.options)
assert_tree_not_changed(tree_before, doc.root)
end
end
end
def assert_tree_not_changed(old, new)
assert_equal(old.type, new.type, "type mismatch")
if old.value.kind_of?(Kramdown::Element)
assert_tree_not_changed(old.value, new.value)
else
assert(old.value == new.value, "value mismatch")
end
assert_equal(old.attr, new.attr, "attr mismatch")
assert_equal(old.options, new.options, "options mismatch")
assert_equal(old.children.length, new.children.length, "children count mismatch")
old.children.each_with_index do |child, index|
assert_tree_not_changed(child, new.children[index])
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/test/test_string_scanner_kramdown.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/test/test_string_scanner_kramdown.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'minitest/autorun'
require 'kramdown/utils/string_scanner'
describe Kramdown::Utils::StringScanner do
[
["...........X............", [/X/], 1],
["1\n2\n3\n4\n5\n6X", [/X/], 6],
["1\n2\n3\n4\n5\n6X\n7\n8X", [/X/,/X/], 8],
[(".\n" * 1000) + 'X', [/X/], 1001]
].each_with_index do |test_data, i|
test_string, scan_regexes, expect = test_data
it "computes the correct current_line_number for example ##{i+1}" do
str_sc = Kramdown::Utils::StringScanner.new(test_string)
scan_regexes.each { |scan_re| str_sc.scan_until(scan_re) }
str_sc.current_line_number.must_equal expect
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/test/test_location.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/test/test_location.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'minitest/autorun'
require 'kramdown'
Encoding.default_external = 'utf-8' if RUBY_VERSION >= '1.9'
describe 'location' do
# checks that +element+'s :location option corresponds to the location stored
# in the element.attr['class']
def check_element_for_location(element)
if (match = /^line-(\d+)/.match(element.attr['class'] || ''))
expected_line = match[1].to_i
element.options[:location].must_equal(expected_line)
end
element.children.each do |child|
check_element_for_location(child)
end
end
# Test cases consist of a kramdown string that uses IALs to specify the expected
# line numbers for a given element.
test_cases = {
'autolink' => %(testing autolinks\n\n<http://kramdown.org>{:.line-3}),
'blockquote' => %(
> block quote1
>
> * {:.line-3} list item in block quote
> * {:.line-4} list item in block quote
> {:.line-3}
{:.line-1}
> block quote2
{:.line-8}
),
'codeblock' => %(\na para\n\n~~~~\ntest code 1\n~~~~\n{:.line-3}\n\n test code 2\n{:.line-8}\n),
'codespan' => %(a para\n\nanother para `<code>`{:.line-3} with code\n),
'emphasis' => %(
para *span*{:.line-1}
{:.line-1}
## header *span*{:.line-4}
{:.line-4}
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
cillum *short span on single line*{:.line-11}
dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
*long span over multiple lines - proident, sunt in culpa qui officia deserunt
mollit anim id est laborum.*{:.line-13}
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
`code span`{:.line-18}
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
{:.line-7}
),
'header' => %(
# header1
{:.line-1}
## header2
{:.line-4}
## header3
{:.line-7}
header4
=======
{:.line-10}
^
header5
-------
{:.line-16}
),
'horizontal_rule' => %(\na para\n\n----\n{:.line-3}\n),
'html_entity' => "a para\n\nanother para with &{:.line-3} html entity.\n",
'link' => %(
a para
This is [a link](http://rubyforge.org){:.line-3} to a page.
Here comes a {:.line-5}
),
'list' => %(
* {:.line-1} list item
* {:.line-2} list item
* {:.line-3} list item
{:.line-1}
{:.line-7}
1. {:.line-7} list item
2. {:.line-8} list item
3. {:.line-9} list item
{:.line-12}
definition term 1
: {:.line-13} definition definition 1
definition term 2
: {:.line-15} definition definition 2
),
'math_block' => %(\na para\n\n$$5+5$$\n{:.line-3}\n),
'math_inline' => %(\na para\n\nanother para with inline math $$5+5$${:.line-3}\n),
'paragraph' => %(
para1
{:.line-1}
para2
{:.line-4}
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
{:.line-7}
{:.line-14}
para with leading IAL
),
'table' => %(
a para
|first|second|third|
|-----|------|-----|
|a |b |c |
{:.line-3}
),
'typographic_symbol' => %(
a para
another para ---{:.line-3}
another para ...{:.line-5}
),
'gh issue 129' => %(
`|`
{:.line-1}
),
'gh issue 131' => %(
* {:.line-1} test
line 2
* {:.line-3} second
* {:.line-4} third
* {:.line-5} * {:.line-5} one
* {:.line-6} two
),
'gh issue 158' => %(
😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁😁
{:.line-1}
- {:.line-4} T
{:.line-4}
# T
{:.line-7}
),
'gh issue 243 - HTML raw elements' => %(
<ul class="line-1">
<li class="line-2">Test</li>
</ul>
),
}
test_cases.each do |name, test_string|
it "Handles #{ name }" do
doc = Kramdown::Document.new(test_string.gsub(/^ /, '').strip)
check_element_for_location(doc.root)
end
end
it 'adds location info to duplicate abbreviation definition warnings' do
test_string = %(This snippet contains a duplicate abbreviation definition
*[duplicate]: The first definition
*[duplicate]: The second definition
)
doc = Kramdown::Document.new(test_string.strip)
doc.warnings.must_equal ["Duplicate abbreviation ID 'duplicate' on line 4 - overwriting"]
end
it 'handles abbreviations' do
str = "This *is* ABC and\n**and** ABC second\nanother ABC\nas ABC as\nABC at the end.\n\n*[ABC]: ABC"
doc = Kramdown::Document.new(str)
doc.root.children.first.children.select {|e| e.type == :abbreviation}.each_with_index do |e, i|
assert_equal(i + 1, e.options[:location])
end
end
it 'handles line breaks' do
str = "First \nsecond\\\\\nthird \n"
doc = Kramdown::Document.new(str)
doc.root.children.first.children.select {|e| e.type == :br}.each_with_index do |e, i|
assert_equal(i + 1, e.options[:location])
end
end
it 'handles smart quotes' do
str = "This is 'first'\nand 'second' and\n'third'"
doc = Kramdown::Document.new(str)
doc.root.children.first.children.select {|e| e.type == :smart_quote}.each_with_index do |e, i|
assert_equal(((i + 1) /2.0).ceil, e.options[:location])
end
end
it 'handles hard wrapped paragraphs with the GFM parser' do
str = "A*b*C\nA*b*C\nA*b*C"
doc = Kramdown::Document.new(str, :input => 'GFM', :hard_wrap => true)
para = doc.root.children.first
1.upto(3) do |line|
0.upto(line == 3 ? 2 : 3) do |element|
assert_equal(line, para.children[4*(line - 1) + element].options[:location])
end
end
end
it 'marks fenced code block as fenced with the GFM parser' do
str = %(```\nfenced code\n```\n\n indented code\n)
doc = Kramdown::Document.new(str, :input => 'GFM')
fenced_cb = doc.root.children.first
indented_cb = doc.root.children.last
assert fenced_cb.options[:fenced]
refute indented_cb.options[:fenced]
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/document'
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/element.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/element.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
# Represents all elements in the element tree.
#
# kramdown only uses this one class for representing all available elements in an element tree
# (paragraphs, headers, emphasis, ...). The type of element can be set via the #type accessor.
#
# Following is a description of all supported element types.
#
# Note that the option :location may contain the start line number of an element in the source
# document.
#
# == Structural Elements
#
# === :root
#
# [Category] None
# [Usage context] As the root element of a document
# [Content model] Block-level elements
#
# Represents the root of a kramdown document.
#
# The root element contains the following option keys:
#
# :encoding:: When running on Ruby 1.9 this key has to be set to the encoding used for the text
# parts of the kramdown document.
#
# :abbrev_defs:: This key may be used to store the mapping of abbreviation to abbreviation
# definition.
#
# :abbrev_attr:: This key may be used to store the mapping of abbreviation to abbreviation
# attributes.
#
# :options:: This key may be used to store options that were set during parsing of the document.
#
#
# === :blank
#
# [Category] Block-level element
# [Usage context] Where block-level elements are expected
# [Content model] Empty
#
# Represents one or more blank lines. It is not allowed to have two or more consecutive blank
# elements.
#
# The +value+ field may contain the original content of the blank lines.
#
#
# === :p
#
# [Category] Block-level element
# [Usage context] Where block-level elements are expected
# [Content model] Span-level elements
#
# Represents a paragraph.
#
# If the option :transparent is +true+, this element just represents a block of text. I.e. this
# element just functions as a container for span-level elements.
#
#
# === :header
#
# [Category] Block-level element
# [Usage context] Where block-level elements are expected
# [Content model] Span-level elements
#
# Represents a header.
#
# The option :level specifies the header level and has to contain a number between 1 and \6. The
# option :raw_text has to contain the raw header text.
#
#
# === :blockquote
#
# [Category] Block-level element
# [Usage context] Where block-level elements are expected
# [Content model] Block-level elements
#
# Represents a blockquote.
#
#
# === :codeblock
#
# [Category] Block-level element
# [Usage context] Where block-level elements are expected
# [Content model] Empty
#
# Represents a code block, i.e. a block of text that should be used as-is.
#
# The +value+ field has to contain the content of the code block.
#
# The option :lang specifies a highlighting language with possible HTML style options (e.g.
# php?start_inline=1) and should be used instead of a possibly also available language embedded in
# a class name of the form 'language-LANG'.
#
#
# === :ul
#
# [Category] Block-level element
# [Usage context] Where block-level elements are expected
# [Content model] One or more :li elements
#
# Represents an unordered list.
#
#
# === :ol
#
# [Category] Block-level element
# [Usage context] Where block-level elements are expected
# [Content model] One or more :li elements
#
# Represents an ordered list.
#
#
# === :li
#
# [Category] Block-level element
# [Usage context] Inside :ol and :ul elements
# [Content model] Block-level elements
#
# Represents a list item of an ordered or unordered list.
#
# Note that the first child of a list item must not be a :blank element!
#
#
# === :dl
#
# [Category] Block-level element
# [Usage context] Where block-level elements are expected
# [Content model] One or more groups each consisting of one or more :dt elements followed by one
# or more :dd elements.
#
# Represents a definition list which contains groups consisting of terms and definitions for them.
#
#
# === :dt
#
# [Category] Block-level element
# [Usage context] Before :dt or :dd elements inside a :dl elment
# [Content model] Span-level elements
#
# Represents the term part of a term-definition group in a definition list.
#
#
# === :dd
#
# [Category] Block-level element
# [Usage context] After :dt or :dd elements inside a :dl elment
# [Content model] Block-level elements
#
# Represents the definition part of a term-definition group in a definition list.
#
#
# === :hr
#
# [Category] Block-level element
# [Usage context] Where block-level elements are expected
# [Content model] None
#
# Represents a horizontal line.
#
#
# === :table
#
# [Category] Block-level element
# [Usage context] Where block-level elements are expected
# [Content model] Zero or one :thead elements, one or more :tbody elements, zero or one :tfoot
# elements
#
# Represents a table. Each table row (i.e. :tr element) of the table has to contain the same
# number of :td elements.
#
# The option :alignment has to be an array containing the alignment values, exactly one for each
# column of the table. The possible alignment values are :left, :center, :right and :default.
#
#
# === :thead
#
# [Category] None
# [Usage context] As first element inside a :table element
# [Content model] One or more :tr elements
#
# Represents the table header.
#
#
# === :tbody
#
# [Category] None
# [Usage context] After a :thead element but before a :tfoot element inside a :table element
# [Content model] One or more :tr elements
#
# Represents a table body.
#
#
# === :tfoot
#
# [Category] None
# [Usage context] As last element inside a :table element
# [Content model] One or more :tr elements
#
# Represents the table footer.
#
#
# === :tr
#
# [Category] None
# [Usage context] Inside :thead, :tbody and :tfoot elements
# [Content model] One or more :td elements
#
# Represents a table row.
#
#
# === :td
#
# [Category] Block-level element
# [Usage context] Inside :tr elements
# [Content model] As child of :thead/:tr span-level elements, as child of :tbody/:tr and
# :tfoot/:tr block-level elements
#
# Represents a table cell.
#
#
# === :math
#
# [Category] Block/span-level element
# [Usage context] Where block/span-level elements are expected
# [Content model] None
#
# Represents mathematical text that is written in LaTeX.
#
# The +value+ field has to contain the actual mathematical text.
#
# The option :category has to be set to either :span or :block depending on the context where the
# element is used.
#
#
# == Text Markup Elements
#
# === :text
#
# [Category] Span-level element
# [Usage context] Where span-level elements are expected
# [Content model] None
#
# Represents text.
#
# The +value+ field has to contain the text itself.
#
#
# === :br
#
# [Category] Span-level element
# [Usage context] Where span-level elements are expected
# [Content model] None
#
# Represents a hard line break.
#
#
# === :a
#
# [Category] Span-level element
# [Usage context] Where span-level elements are expected
# [Content model] Span-level elements
#
# Represents a link to an URL.
#
# The attribute +href+ has to be set to the URL to which the link points. The attribute +title+
# optionally contains the title of the link.
#
#
# === :img
#
# [Category] Span-level element
# [Usage context] Where span-level elements are expected
# [Content model] None
#
# Represents an image.
#
# The attribute +src+ has to be set to the URL of the image. The attribute +alt+ has to contain a
# text description of the image. The attribute +title+ optionally contains the title of the image.
#
#
# === :codespan
#
# [Category] Span-level element
# [Usage context] Where span-level elements are expected
# [Content model] None
#
# Represents verbatim text.
#
# The +value+ field has to contain the content of the code span.
#
#
# === :footnote
#
# [Category] Span-level element
# [Usage context] Where span-level elements are expected
# [Content model] None
#
# Represents a footnote marker.
#
# The +value+ field has to contain an element whose children are the content of the footnote. The
# option :name has to contain a valid and unique footnote name. A valid footnote name consists of
# a word character or a digit and then optionally followed by other word characters, digits or
# dashes.
#
#
# === :em
#
# [Category] Span-level element
# [Usage context] Where span-level elements are expected
# [Content model] Span-level elements
#
# Represents emphasis of its contents.
#
#
# === :strong
#
# [Category] Span-level element
# [Usage context] Where span-level elements are expected
# [Content model] Span-level elements
#
# Represents strong importance for its contents.
#
#
# === :entity
#
# [Category] Span-level element
# [Usage context] Where span-level elements are expected
# [Content model] None
#
# Represents an HTML entity.
#
# The +value+ field has to contain an instance of Kramdown::Utils::Entities::Entity. The option
# :original can be used to store the original representation of the entity.
#
#
# === :typographic_sym
#
# [Category] Span-level element
# [Usage context] Where span-level elements are expected
# [Content model] None
#
# Represents a typographic symbol.
#
# The +value+ field needs to contain a Symbol representing the specific typographic symbol from
# the following list:
#
# :mdash:: An mdash character (---)
# :ndash:: An ndash character (--)
# :hellip:: An ellipsis (...)
# :laquo:: A left guillemet (<<)
# :raquo:: A right guillemet (>>)
# :laquo_space:: A left guillemet with a space (<< )
# :raquo_space:: A right guillemet with a space ( >>)
#
#
# === :smart_quote
#
# [Category] Span-level element
# [Usage context] Where span-level elements are expected
# [Content model] None
#
# Represents a quotation character.
#
# The +value+ field needs to contain a Symbol representing the specific quotation character:
#
# :lsquo:: Left single quote
# :rsquo:: Right single quote
# :ldquo:: Left double quote
# :rdquo:: Right double quote
#
#
# === :abbreviation
#
# [Category] Span-level element
# [Usage context] Where span-level elements are expected
# [Content model] None
#
# Represents a text part that is an abbreviation.
#
# The +value+ field has to contain the text part that is the abbreviation. The definition of the
# abbreviation is stored in the :root element of the document.
#
#
# == Other Elements
#
# === :html_element
#
# [Category] Block/span-level element
# [Usage context] Where block/span-level elements or raw HTML elements are expected
# [Content model] Depends on the element
#
# Represents an HTML element.
#
# The +value+ field has to contain the name of the HTML element the element is representing.
#
# The option :category has to be set to either :span or :block depending on the whether the
# element is a block-level or a span-level element. The option :content_model has to be set to the
# content model for the element (either :block if it contains block-level elements, :span if it
# contains span-level elements or :raw if it contains raw content).
#
#
# === :xml_comment
#
# [Category] Block/span-level element
# [Usage context] Where block/span-level elements are expected or in raw HTML elements
# [Content model] None
#
# Represents an XML/HTML comment.
#
# The +value+ field has to contain the whole XML/HTML comment including the delimiters.
#
# The option :category has to be set to either :span or :block depending on the context where the
# element is used.
#
#
# === :xml_pi
#
# [Category] Block/span-level element
# [Usage context] Where block/span-level elements are expected or in raw HTML elements
# [Content model] None
#
# Represents an XML/HTML processing instruction.
#
# The +value+ field has to contain the whole XML/HTML processing instruction including the
# delimiters.
#
# The option :category has to be set to either :span or :block depending on the context where the
# element is used.
#
#
# === :comment
#
# [Category] Block/span-level element
# [Usage context] Where block/span-level elements are expected
# [Content model] None
#
# Represents a comment.
#
# The +value+ field has to contain the comment.
#
# The option :category has to be set to either :span or :block depending on the context where the
# element is used. If it is set to :span, then no blank lines are allowed in the comment.
#
#
# === :raw
#
# [Category] Block/span-level element
# [Usage context] Where block/span-level elements are expected
# [Content model] None
#
# Represents a raw string that should not be modified. For example, the element could contain some
# HTML code that should be output as-is without modification and escaping.
#
# The +value+ field has to contain the actual raw text.
#
# The option :category has to be set to either :span or :block depending on the context where the
# element is used. If it is set to :span, then no blank lines are allowed in the raw text.
#
# The option :type can be set to an array of strings to define for which converters the raw string
# is valid.
#
class Element
# A symbol representing the element type. For example, :p or :blockquote.
attr_accessor :type
# The value of the element. The interpretation of this field depends on the type of the element.
# Many elements don't use this field.
attr_accessor :value
# The child elements of this element.
attr_accessor :children
# Create a new Element object of type +type+. The optional parameters +value+, +attr+ and
# +options+ can also be set in this constructor for convenience.
def initialize(type, value = nil, attr = nil, options = nil)
@type, @value, @attr, @options = type, value, (Utils::OrderedHash.new.merge!(attr) if attr), options
@children = []
end
# The attributes of the element. Uses an Utils::OrderedHash to retain the insertion order.
def attr
@attr ||= Utils::OrderedHash.new
end
# The options hash for the element. It is used for storing arbitray options.
def options
@options ||= {}
end
def inspect #:nodoc:
"<kd:#{@type}#{@value.nil? ? '' : ' ' + @value.inspect} #{@attr.inspect}#{options.empty? ? '' : ' ' + @options.inspect}#{@children.empty? ? '' : ' ' + @children.inspect}>"
end
CATEGORY = {} # :nodoc:
[:blank, :p, :header, :blockquote, :codeblock, :ul, :ol, :li, :dl, :dt, :dd, :table, :td, :hr].each {|b| CATEGORY[b] = :block}
[:text, :a, :br, :img, :codespan, :footnote, :em, :strong, :entity, :typographic_sym,
:smart_quote, :abbreviation].each {|b| CATEGORY[b] = :span}
# Return the category of +el+ which can be :block, :span or +nil+.
#
# Most elements have a fixed category, however, some elements can either appear in a block-level
# or a span-level context. These elements need to have the option :category correctly set.
def self.category(el)
CATEGORY[el.type] || el.options[:category]
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/version.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/version.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
# The kramdown version.
VERSION = '1.17.0'
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/utils'
module Kramdown
# This module contains all available converters, i.e. classes that take a root Element and convert
# it to a specific output format. The result is normally a string. For example, the
# Converter::Html module converts an element tree into valid HTML.
#
# Converters use the Base class for common functionality (like applying a template to the output)
# \- see its API documentation for how to create a custom converter class.
module Converter
autoload :Base, 'kramdown/converter/base'
autoload :Html, 'kramdown/converter/html'
autoload :Latex, 'kramdown/converter/latex'
autoload :Kramdown, 'kramdown/converter/kramdown'
autoload :Toc, 'kramdown/converter/toc'
autoload :RemoveHtmlTags, 'kramdown/converter/remove_html_tags'
autoload :Pdf, 'kramdown/converter/pdf'
autoload :HashAST, 'kramdown/converter/hash_ast'
autoload :HashAst, 'kramdown/converter/hash_ast'
autoload :Man, 'kramdown/converter/man'
extend ::Kramdown::Utils::Configurable
configurable(:syntax_highlighter)
['Minted', "Coderay", "Rouge"].each do |klass_name|
kn_down = klass_name.downcase.intern
add_syntax_highlighter(kn_down) do |converter, text, lang, type, opts|
require "kramdown/converter/syntax_highlighter/#{kn_down}"
klass = ::Kramdown::Utils.deep_const_get("::Kramdown::Converter::SyntaxHighlighter::#{klass_name}")
if !klass.const_defined?(:AVAILABLE) || klass::AVAILABLE
add_syntax_highlighter(kn_down, klass)
else
add_syntax_highlighter(kn_down) {|*args| nil}
end
syntax_highlighter(kn_down).call(converter, text, lang, type, opts)
end
end
configurable(:math_engine)
["Mathjax", "MathjaxNode", "Katex", "SsKaTeX", "Ritex", "Itex2MML"].each do |klass_name|
kn_down = klass_name.downcase.intern
add_math_engine(kn_down) do |converter, el, opts|
require "kramdown/converter/math_engine/#{kn_down}"
klass = ::Kramdown::Utils.deep_const_get("::Kramdown::Converter::MathEngine::#{klass_name}")
if !klass.const_defined?(:AVAILABLE) || klass::AVAILABLE
add_math_engine(kn_down, klass)
else
add_math_engine(kn_down) {|*args| nil}
end
math_engine(kn_down).call(converter, el, opts)
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/options.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/options.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'yaml'
module Kramdown
# This module defines all options that are used by parsers and/or converters as well as providing
# methods to deal with the options.
module Options
# Helper class introducing a boolean type for specifying boolean values (+true+ and +false+) as
# option types.
class Boolean
# Return +true+ if +other+ is either +true+ or +false+
def self.===(other)
FalseClass === other || TrueClass === other
end
end
# ----------------------------
# :section: Option definitions
#
# This sections describes the methods that can be used on the Options module.
# ----------------------------
# Struct class for storing the definition of an option.
Definition = Struct.new(:name, :type, :default, :desc, :validator)
# Allowed option types.
ALLOWED_TYPES = [String, Integer, Float, Symbol, Boolean, Object]
@options = {}
# Define a new option called +name+ (a Symbol) with the given +type+ (String, Integer, Float,
# Symbol, Boolean, Object), default value +default+ and the description +desc+. If a block is
# specified, it should validate the value and either raise an error or return a valid value.
#
# The type 'Object' should only be used for complex types for which none of the other types
# suffices. A block needs to be specified when using type 'Object' and it has to cope with
# a value given as string and as the opaque type.
def self.define(name, type, default, desc, &block)
name = name.to_sym
raise ArgumentError, "Option name #{name} is already used" if @options.has_key?(name)
raise ArgumentError, "Invalid option type #{type} specified" if !ALLOWED_TYPES.include?(type)
raise ArgumentError, "Invalid type for default value" if !(type === default) && !default.nil?
raise ArgumentError, "Missing validator block" if type == Object && block.nil?
@options[name] = Definition.new(name, type, default, desc, block)
end
# Return all option definitions.
def self.definitions
@options
end
# Return +true+ if an option called +name+ is defined.
def self.defined?(name)
@options.has_key?(name.to_sym)
end
# Return a Hash with the default values for all options.
def self.defaults
temp = {}
@options.each {|n, o| temp[o.name] = o.default}
temp
end
# Merge the #defaults Hash with the *parsed* options from the given Hash, i.e. only valid option
# names are considered and their value is run through the #parse method.
def self.merge(hash)
temp = defaults
hash.each do |k,v|
k = k.to_sym
@options.has_key?(k) ? temp[k] = parse(k, v) : temp[k] = v
end
temp
end
# Parse the given value +data+ as if it was a value for the option +name+ and return the parsed
# value with the correct type.
#
# If +data+ already has the correct type, it is just returned. Otherwise it is converted to a
# String and then to the correct type.
def self.parse(name, data)
name = name.to_sym
raise ArgumentError, "No option named #{name} defined" if !@options.has_key?(name)
if !(@options[name].type === data)
data = data.to_s
data = if @options[name].type == String
data
elsif @options[name].type == Integer
Integer(data) rescue raise Kramdown::Error, "Invalid integer value for option '#{name}': '#{data}'"
elsif @options[name].type == Float
Float(data) rescue raise Kramdown::Error, "Invalid float value for option '#{name}': '#{data}'"
elsif @options[name].type == Symbol
str_to_sym(data)
elsif @options[name].type == Boolean
data.downcase.strip != 'false' && !data.empty?
end
end
data = @options[name].validator[data] if @options[name].validator
data
end
# Converts the given String +data+ into a Symbol or +nil+ with the
# following provisions:
#
# - A leading colon is stripped from the string.
# - An empty value or a value equal to "nil" results in +nil+.
def self.str_to_sym(data)
data = data.strip
data = data[1..-1] if data[0] == ?:
(data.empty? || data == 'nil' ? nil : data.to_sym)
end
# ----------------------------
# :section: Option Validators
#
# This sections contains all pre-defined option validators.
# ----------------------------
# Ensures that the option value +val+ for the option called +name+ is a valid array. The
# parameter +val+ can be
#
# - a comma separated string which is split into an array of values
# - or an array.
#
# Optionally, the array is checked for the correct size.
def self.simple_array_validator(val, name, size = nil)
if String === val
val = val.split(/,/)
elsif !(Array === val)
raise Kramdown::Error, "Invalid type #{val.class} for option #{name}"
end
if size && val.size != size
raise Kramdown::Error, "Option #{name} needs exactly #{size} values"
end
val
end
# Ensures that the option value +val+ for the option called +name+ is a valid hash. The
# parameter +val+ can be
#
# - a hash in YAML format
# - or a Ruby Hash object.
def self.simple_hash_validator(val, name)
if String === val
begin
val = YAML.load(val)
rescue RuntimeError, ArgumentError, SyntaxError
raise Kramdown::Error, "Invalid YAML value for option #{name}"
end
end
raise Kramdown::Error, "Invalid type #{val.class} for option #{name}" if !(Hash === val)
val
end
# ----------------------------
# :section: Option Definitions
#
# This sections contains all option definitions that are used by the included
# parsers/converters.
# ----------------------------
define(:template, String, '', <<EOF)
The name of an ERB template file that should be used to wrap the output
or the ERB template itself.
This is used to wrap the output in an environment so that the output can
be used as a stand-alone document. For example, an HTML template would
provide the needed header and body tags so that the whole output is a
valid HTML file. If no template is specified, the output will be just
the converted text.
When resolving the template file, the given template name is used first.
If such a file is not found, the converter extension (the same as the
converter name) is appended. If the file still cannot be found, the
templates name is interpreted as a template name that is provided by
kramdown (without the converter extension). If the file is still not
found, the template name is checked if it starts with 'string://' and if
it does, this prefix is removed and the rest is used as template
content.
kramdown provides a default template named 'document' for each converter.
Default: ''
Used by: all converters
EOF
define(:auto_ids, Boolean, true, <<EOF)
Use automatic header ID generation
If this option is `true`, ID values for all headers are automatically
generated if no ID is explicitly specified.
Default: true
Used by: HTML/Latex converter
EOF
define(:auto_id_stripping, Boolean, false, <<EOF)
Strip all formatting from header text for automatic ID generation
If this option is `true`, only the text elements of a header are used
for generating the ID later (in contrast to just using the raw header
text line).
This option will be removed in version 2.0 because this will be the
default then.
Default: false
Used by: kramdown parser
EOF
define(:auto_id_prefix, String, '', <<EOF)
Prefix used for automatically generated header IDs
This option can be used to set a prefix for the automatically generated
header IDs so that there is no conflict when rendering multiple kramdown
documents into one output file separately. The prefix should only
contain characters that are valid in an ID!
Default: ''
Used by: HTML/Latex converter
EOF
define(:transliterated_header_ids, Boolean, false, <<EOF)
Transliterate the header text before generating the ID
Only ASCII characters are used in headers IDs. This is not good for
languages with many non-ASCII characters. By enabling this option
the header text is transliterated to ASCII as good as possible so that
the resulting header ID is more useful.
The stringex library needs to be installed for this feature to work!
Default: false
Used by: HTML/Latex converter
EOF
define(:parse_block_html, Boolean, false, <<EOF)
Process kramdown syntax in block HTML tags
If this option is `true`, the kramdown parser processes the content of
block HTML tags as text containing block-level elements. Since this is
not wanted normally, the default is `false`. It is normally better to
selectively enable kramdown processing via the markdown attribute.
Default: false
Used by: kramdown parser
EOF
define(:parse_span_html, Boolean, true, <<EOF)
Process kramdown syntax in span HTML tags
If this option is `true`, the kramdown parser processes the content of
span HTML tags as text containing span-level elements.
Default: true
Used by: kramdown parser
EOF
define(:html_to_native, Boolean, false, <<EOF)
Convert HTML elements to native elements
If this option is `true`, the parser converts HTML elements to native
elements. For example, when parsing `<em>hallo</em>` the emphasis tag
would normally be converted to an `:html` element with tag type `:em`.
If `html_to_native` is `true`, then the emphasis would be converted to a
native `:em` element.
This is useful for converters that cannot deal with HTML elements.
Default: false
Used by: kramdown parser
EOF
define(:link_defs, Object, {}, <<EOF) do |val|
Pre-defines link definitions
This option can be used to pre-define link definitions. The value needs
to be a Hash where the keys are the link identifiers and the values are
two element Arrays with the link URL and the link title.
If the value is a String, it has to contain a valid YAML hash and the
hash has to follow the above guidelines.
Default: {}
Used by: kramdown parser
EOF
val = simple_hash_validator(val, :link_defs)
val.each do |k,v|
if !(Array === v) || v.size > 2 || v.size < 1
raise Kramdown::Error, "Invalid structure for hash value of option #{name}"
end
v << nil if v.size == 1
end
val
end
define(:footnote_nr, Integer, 1, <<EOF)
The number of the first footnote
This option can be used to specify the number that is used for the first
footnote.
Default: 1
Used by: HTML converter
EOF
define(:enable_coderay, Boolean, true, <<EOF)
Use coderay for syntax highlighting
If this option is `true`, coderay is used by the HTML converter for
syntax highlighting the content of code spans and code blocks.
Default: true
Used by: HTML converter
EOF
define(:coderay_wrap, Symbol, :div, <<EOF)
Defines how the highlighted code should be wrapped
The possible values are :span, :div or nil.
Default: :div
Used by: HTML converter
EOF
define(:coderay_line_numbers, Symbol, :inline, <<EOF)
Defines how and if line numbers should be shown
The possible values are :table, :inline or nil. If this option is
nil, no line numbers are shown.
Default: :inline
Used by: HTML converter
EOF
define(:coderay_line_number_start, Integer, 1, <<EOF)
The start value for the line numbers
Default: 1
Used by: HTML converter
EOF
define(:coderay_tab_width, Integer, 8, <<EOF)
The tab width used in highlighted code
Used by: HTML converter
EOF
define(:coderay_bold_every, Object, 10, <<EOF) do |val|
Defines how often a line number should be made bold
Can either be an integer or false (to turn off bold line numbers
completely).
Default: 10
Used by: HTML converter
EOF
if val == false || val.to_s == 'false'
false
else
Integer(val.to_s) rescue raise Kramdown::Error, "Invalid value for option 'coderay_bold_every'"
end
end
define(:coderay_css, Symbol, :style, <<EOF)
Defines how the highlighted code gets styled
Possible values are :class (CSS classes are applied to the code
elements, one must supply the needed CSS file) or :style (default CSS
styles are directly applied to the code elements).
Default: style
Used by: HTML converter
EOF
define(:coderay_default_lang, Symbol, nil, <<EOF)
Sets the default language for highlighting code blocks
If no language is set for a code block, the default language is used
instead. The value has to be one of the languages supported by coderay
or nil if no default language should be used.
Default: nil
Used by: HTML converter
EOF
define(:entity_output, Symbol, :as_char, <<EOF)
Defines how entities are output
The possible values are :as_input (entities are output in the same
form as found in the input), :numeric (entities are output in numeric
form), :symbolic (entities are output in symbolic form if possible) or
:as_char (entities are output as characters if possible, only available
on Ruby 1.9).
Default: :as_char
Used by: HTML converter, kramdown converter
EOF
define(:toc_levels, Object, (1..6).to_a, <<EOF) do |val|
Defines the levels that are used for the table of contents
The individual levels can be specified by separating them with commas
(e.g. 1,2,3) or by using the range syntax (e.g. 1..3). Only the
specified levels are used for the table of contents.
Default: 1..6
Used by: HTML/Latex converter
EOF
case val
when String
if val =~ /^(\d)\.\.(\d)$/
val = Range.new($1.to_i, $2.to_i).to_a
elsif val =~ /^\d(?:,\d)*$/
val = val.split(/,/).map {|s| s.to_i}.uniq
else
raise Kramdown::Error, "Invalid syntax for option toc_levels"
end
when Array, Range
val = val.map {|s| s.to_i}.uniq
else
raise Kramdown::Error, "Invalid type #{val.class} for option toc_levels"
end
if val.any? {|i| !(1..6).include?(i)}
raise Kramdown::Error, "Level numbers for option toc_levels have to be integers from 1 to 6"
end
val
end
define(:line_width, Integer, 72, <<EOF)
Defines the line width to be used when outputting a document
Default: 72
Used by: kramdown converter
EOF
define(:latex_headers, Object, %w{section subsection subsubsection paragraph subparagraph subparagraph}, <<EOF) do |val|
Defines the LaTeX commands for different header levels
The commands for the header levels one to six can be specified by
separating them with commas.
Default: section,subsection,subsubsection,paragraph,subparagraph,subparagraph
Used by: Latex converter
EOF
simple_array_validator(val, :latex_headers, 6)
end
define(:smart_quotes, Object, %w{lsquo rsquo ldquo rdquo}, <<EOF) do |val|
Defines the HTML entity names or code points for smart quote output
The entities identified by entity name or code point that should be
used for, in order, a left single quote, a right single quote, a left
double and a right double quote are specified by separating them with
commas.
Default: lsquo,rsquo,ldquo,rdquo
Used by: HTML/Latex converter
EOF
val = simple_array_validator(val, :smart_quotes, 4)
val.map! {|v| Integer(v) rescue v}
val
end
define(:typographic_symbols, Object, {}, <<EOF) do |val|
Defines a mapping from typographical symbol to output characters
Typographical symbols are normally output using their equivalent Unicode
codepoint. However, sometimes one wants to change the output, mostly to
fallback to a sequence of ASCII characters.
This option allows this by specifying a mapping from typographical
symbol to its output string. For example, the mapping {hellip: ...} would
output the standard ASCII representation of an ellipsis.
The available typographical symbol names are:
* hellip: ellipsis
* mdash: em-dash
* ndash: en-dash
* laquo: left guillemet
* raquo: right guillemet
* laquo_space: left guillemet followed by a space
* raquo_space: right guillemet preceeded by a space
Default: {}
Used by: HTML/Latex converter
EOF
val = simple_hash_validator(val, :typographic_symbols)
val.keys.each do |k|
val[k.kind_of?(String) ? str_to_sym(k) : k] = val.delete(k).to_s
end
val
end
define(:remove_block_html_tags, Boolean, true, <<EOF)
Remove block HTML tags
If this option is `true`, the RemoveHtmlTags converter removes
block HTML tags.
Default: true
Used by: RemoveHtmlTags converter
EOF
define(:remove_span_html_tags, Boolean, false, <<EOF)
Remove span HTML tags
If this option is `true`, the RemoveHtmlTags converter removes
span HTML tags.
Default: false
Used by: RemoveHtmlTags converter
EOF
define(:header_offset, Integer, 0, <<EOF)
Sets the output offset for headers
If this option is c (may also be negative) then a header with level n
will be output as a header with level c+n. If c+n is lower than 1,
level 1 will be used. If c+n is greater than 6, level 6 will be used.
Default: 0
Used by: HTML converter, Kramdown converter, Latex converter
EOF
define(:hard_wrap, Boolean, true, <<EOF)
Interprets line breaks literally
Insert HTML `<br />` tags inside paragraphs where the original Markdown
document had newlines (by default, Markdown ignores these newlines).
Default: true
Used by: GFM parser
EOF
define(:syntax_highlighter, Symbol, :coderay, <<EOF)
Set the syntax highlighter
Specifies the syntax highlighter that should be used for highlighting
code blocks and spans. If this option is set to +nil+, no syntax
highlighting is done.
Options for the syntax highlighter can be set with the
syntax_highlighter_opts configuration option.
Default: coderay
Used by: HTML/Latex converter
EOF
define(:syntax_highlighter_opts, Object, {}, <<EOF) do |val|
Set the syntax highlighter options
Specifies options for the syntax highlighter set via the
syntax_highlighter configuration option.
The value needs to be a hash with key-value pairs that are understood by
the used syntax highlighter.
Default: {}
Used by: HTML/Latex converter
EOF
val = simple_hash_validator(val, :syntax_highlighter_opts)
val.keys.each do |k|
val[k.kind_of?(String) ? str_to_sym(k) : k] = val.delete(k)
end
val
end
define(:math_engine, Symbol, :mathjax, <<EOF)
Set the math engine
Specifies the math engine that should be used for converting math
blocks/spans. If this option is set to +nil+, no math engine is used and
the math blocks/spans are output as is.
Options for the selected math engine can be set with the
math_engine_opts configuration option.
Default: mathjax
Used by: HTML converter
EOF
define(:math_engine_opts, Object, {}, <<EOF) do |val|
Set the math engine options
Specifies options for the math engine set via the math_engine
configuration option.
The value needs to be a hash with key-value pairs that are understood by
the used math engine.
Default: {}
Used by: HTML converter
EOF
val = simple_hash_validator(val, :math_engine_opts)
val.keys.each do |k|
val[k.kind_of?(String) ? str_to_sym(k) : k] = val.delete(k)
end
val
end
define(:footnote_backlink, String, '↩', <<EOF)
Defines the text that should be used for the footnote backlinks
The footnote backlink is just text, so any special HTML characters will
be escaped.
If the footnote backlint text is an empty string, no footnote backlinks
will be generated.
Default: '&8617;'
Used by: HTML converter
EOF
define(:footnote_backlink_inline, Boolean, false, <<EOF)
Specifies whether the footnote backlink should always be inline
With the default of false the footnote backlink is placed at the end of
the last paragraph if there is one, or an extra paragraph with only the
footnote backlink is created.
Setting this option to true tries to place the footnote backlink in the
last, possibly nested paragraph or header. If this fails (e.g. in the
case of a table), an extra paragraph with only the footnote backlink is
created.
Default: false
Used by: HTML converter
EOF
define(:gfm_quirks, Object, [:paragraph_end], <<EOF) do |val|
Enables a set of GFM specific quirks
The way how GFM is transformed on Github often differs from the way
kramdown does things. Many of these differences are negligible but
others are not.
This option allows one to enable/disable certain GFM quirks, i.e. ways
in which GFM parsing differs from kramdown parsing.
The value has to be a list of quirk names that should be enabled,
separated by commas. Possible names are:
* paragraph_end
Disables the kramdown restriction that at least one blank line has to
be used after a paragraph before a new block element can be started.
Note that if this quirk is used, lazy line wrapping does not fully
work anymore!
* no_auto_typographic
Disables automatic conversion of some characters into their
corresponding typographic symbols (like `--` to em-dash etc).
This helps to achieve results closer to what GitHub Flavored
Markdown produces.
Default: paragraph_end
Used by: GFM parser
EOF
val = simple_array_validator(val, :gfm_quirks)
val.map! {|v| str_to_sym(v.to_s)}
val
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
# == \Utils Module
#
# This module contains utility class/modules/methods that can be used by both parsers and
# converters.
module Utils
autoload :Entities, 'kramdown/utils/entities'
autoload :Html, 'kramdown/utils/html'
autoload :OrderedHash, 'kramdown/utils/ordered_hash'
autoload :Unidecoder, 'kramdown/utils/unidecoder'
autoload :StringScanner, 'kramdown/utils/string_scanner'
autoload :Configurable, 'kramdown/utils/configurable'
autoload :LRUCache, 'kramdown/utils/lru_cache'
# Treat +name+ as if it were snake cased (e.g. snake_case) and camelize it (e.g. SnakeCase).
def self.camelize(name)
name.split('_').inject('') {|s,x| s << x[0..0].upcase << x[1..-1] }
end
# Treat +name+ as if it were camelized (e.g. CamelizedName) and snake-case it (e.g. camelized_name).
def self.snake_case(name)
name = name.dup
name.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
name.gsub!(/([a-z])([A-Z])/,'\1_\2')
name.downcase!
name
end
def self.deep_const_get(str)
::Object.const_get(str)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
# This module contains all available parsers. A parser takes an input string and converts the
# string to an element tree.
#
# New parsers should be derived from the Base class which provides common functionality - see its
# API documentation for how to create a custom converter class.
module Parser
autoload :Base, 'kramdown/parser/base'
autoload :Kramdown, 'kramdown/parser/kramdown'
autoload :Html, 'kramdown/parser/html'
autoload :Markdown, 'kramdown/parser/markdown'
autoload :GFM, 'kramdown/parser/gfm'
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/error.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/error.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
# This error is raised when an error condition is encountered.
#
# *Note* that this error is only raised by the support framework for the parsers and converters.
class Error < RuntimeError; end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/document.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/document.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
# = kramdown
#
# kramdown is fast, pure Ruby Markdown superset converter, using a strict syntax definition and
# supporting several common extensions.
#
# The kramdown library is mainly written to support the kramdown-to-HTML conversion chain. However,
# due to its flexibility it supports other input and output formats as well. Here is a list of the
# supported formats:
#
# * input formats: kramdown (a Markdown superset), Markdown, GFM, HTML
# * output formats: HTML, kramdown, LaTeX (and therefore PDF), PDF via Prawn
#
# All the documentation on the available input and output formats is available at
# http://kramdown.gettalong.org.
#
# == Usage
#
# kramdown has a simple API, so using kramdown is as easy as
#
# require 'kramdown'
#
# Kramdown::Document.new(text).to_html
#
# For detailed information have a look at the *\Kramdown::Document* class.
#
# == License
#
# MIT - see the COPYING file.
require 'kramdown/version'
require 'kramdown/element'
require 'kramdown/error'
require 'kramdown/parser'
require 'kramdown/converter'
require 'kramdown/options'
require 'kramdown/utils'
module Kramdown
# Return the data directory for kramdown.
def self.data_dir
unless defined?(@@data_dir)
require 'rbconfig'
@@data_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'data', 'kramdown'))
@@data_dir = File.expand_path(File.join(RbConfig::CONFIG["datadir"], "kramdown")) if !File.exist?(@@data_dir)
raise "kramdown data directory not found! This is a bug, please report it!" unless File.directory?(@@data_dir)
end
@@data_dir
end
# The main interface to kramdown.
#
# This class provides a one-stop-shop for using kramdown to convert text into various output
# formats. Use it like this:
#
# require 'kramdown'
# doc = Kramdown::Document.new('This *is* some kramdown text')
# puts doc.to_html
#
# The #to_html method is a shortcut for using the Converter::Html class. See #method_missing for
# more information.
#
# The second argument to the ::new method is an options hash for customizing the behaviour of the
# used parser and the converter. See ::new for more information!
class Document
# The root Element of the element tree. It is immediately available after the ::new method has
# been called.
attr_accessor :root
# The options hash which holds the options for parsing/converting the Kramdown document.
attr_reader :options
# An array of warning messages. It is filled with warnings during the parsing phase (i.e. in
# ::new) and the conversion phase.
attr_reader :warnings
# Create a new Kramdown document from the string +source+ and use the provided +options+. The
# options that can be used are defined in the Options module.
#
# The special options key :input can be used to select the parser that should parse the
# +source+. It has to be the name of a class in the Kramdown::Parser module. For example, to
# select the kramdown parser, one would set the :input key to +Kramdown+. If this key is not
# set, it defaults to +Kramdown+.
#
# The +source+ is immediately parsed by the selected parser so that the root element is
# immediately available and the output can be generated.
def initialize(source, options = {})
@options = Options.merge(options).freeze
parser = (@options[:input] || 'kramdown').to_s
parser = parser[0..0].upcase + parser[1..-1]
try_require('parser', parser)
if Parser.const_defined?(parser)
@root, @warnings = Parser.const_get(parser).parse(source, @options)
else
raise Kramdown::Error.new("kramdown has no parser to handle the specified input format: #{@options[:input]}")
end
end
# Check if a method is invoked that begins with +to_+ and if so, try to instantiate a converter
# class (i.e. a class in the Kramdown::Converter module) and use it for converting the document.
#
# For example, +to_html+ would instantiate the Kramdown::Converter::Html class.
def method_missing(id, *attr, &block)
if id.to_s =~ /^to_(\w+)$/ && (name = Utils.camelize($1)) &&
try_require('converter', name) && Converter.const_defined?(name)
output, warnings = Converter.const_get(name).convert(@root, @options)
@warnings.concat(warnings)
output
else
super
end
end
def inspect #:nodoc:
"<KD:Document: options=#{@options.inspect} root=#{@root.inspect} warnings=#{@warnings.inspect}>"
end
# Try requiring a parser or converter class and don't raise an error if the file is not found.
def try_require(type, name)
require("kramdown/#{type}/#{Utils.snake_case(name)}")
true
rescue LoadError
true
end
protected :try_require
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/ordered_hash.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/ordered_hash.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Utils
OrderedHash = Hash
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/unidecoder.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/unidecoder.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
# This file is based on code originally from the Stringex library and needs the data files from
# Stringex to work correctly.
module Kramdown
module Utils
# Provides the ability to tranliterate Unicode strings into plain ASCII ones.
module Unidecoder
gem 'stringex' if defined?(Gem)
path = $:.find {|dir| File.directory?(File.join(File.expand_path(dir), "stringex", "unidecoder_data"))}
if !path
def self.decode(string)
string
end
else
CODEPOINTS = Hash.new do |h, k|
h[k] = YAML.load_file(File.join(path, "stringex", "unidecoder_data", "#{k}.yml"))
end
# Transliterate string from Unicode into ASCII.
def self.decode(string)
string.gsub(/[^\x00-\x7f]/u) do |codepoint|
begin
unpacked = codepoint.unpack("U")[0]
CODEPOINTS["x%02x" % (unpacked >> 8)][unpacked & 255]
rescue
"?"
end
end
end
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/lru_cache.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/lru_cache.rb | # -*- encoding: utf-8 -*-
#
#--
# Copyright (C) 2014-2017 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
module Kramdown
module Utils
# A simple least recently used (LRU) cache.
#
# The cache relies on the fact that Ruby's Hash class maintains insertion order. So deleting
# and re-inserting a key-value pair on access moves the key to the last position. When an
# entry is added and the cache is full, the first entry is removed.
class LRUCache
# Creates a new LRUCache that can hold +size+ entries.
def initialize(size)
@size = size
@cache = {}
end
# Returns the stored value for +key+ or +nil+ if no value was stored under the key.
def [](key)
(val = @cache.delete(key)).nil? ? nil : @cache[key] = val
end
# Stores the +value+ under the +key+.
def []=(key, value)
@cache.delete(key)
@cache[key] = value
@cache.shift if @cache.length > @size
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/entities.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/entities.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Utils
# Provides convenience methods for handling named and numeric entities.
module Entities
# Represents an entity that has a +code_point+ and +name+.
class Entity < Struct.new(:code_point, :name)
# Return the UTF8 representation of the entity.
def char
[code_point].pack('U*') rescue nil
end
end
# Array of arrays. Each sub-array specifies a code point and the associated name.
#
# This table is not used directly -- Entity objects are automatically created from it and put
# into a Hash map when this file is loaded.
ENTITY_TABLE = [
[913, 'Alpha'],
[914, 'Beta'],
[915, 'Gamma'],
[916, 'Delta'],
[917, 'Epsilon'],
[918, 'Zeta'],
[919, 'Eta'],
[920, 'Theta'],
[921, 'Iota'],
[922, 'Kappa'],
[923, 'Lambda'],
[924, 'Mu'],
[925, 'Nu'],
[926, 'Xi'],
[927, 'Omicron'],
[928, 'Pi'],
[929, 'Rho'],
[931, 'Sigma'],
[932, 'Tau'],
[933, 'Upsilon'],
[934, 'Phi'],
[935, 'Chi'],
[936, 'Psi'],
[937, 'Omega'],
[945, 'alpha'],
[946, 'beta'],
[947, 'gamma'],
[948, 'delta'],
[949, 'epsilon'],
[950, 'zeta'],
[951, 'eta'],
[952, 'theta'],
[953, 'iota'],
[954, 'kappa'],
[955, 'lambda'],
[956, 'mu'],
[957, 'nu'],
[958, 'xi'],
[959, 'omicron'],
[960, 'pi'],
[961, 'rho'],
[963, 'sigma'],
[964, 'tau'],
[965, 'upsilon'],
[966, 'phi'],
[967, 'chi'],
[968, 'psi'],
[969, 'omega'],
[962, 'sigmaf'],
[977, 'thetasym'],
[978, 'upsih'],
[982, 'piv'],
[8204, 'zwnj'],
[8205, 'zwj'],
[8206, 'lrm'],
[8207, 'rlm'],
[8230, 'hellip'],
[8242, 'prime'],
[8243, 'Prime'],
[8254, 'oline'],
[8260, 'frasl'],
[8472, 'weierp'],
[8465, 'image'],
[8476, 'real'],
[8501, 'alefsym'],
[8226, 'bull'],
[8482, 'trade'],
[8592, 'larr'],
[8594, 'rarr'],
[8593, 'uarr'],
[8595, 'darr'],
[8596, 'harr'],
[8629, 'crarr'],
[8657, 'uArr'],
[8659, 'dArr'],
[8656, 'lArr'],
[8658, 'rArr'],
[8660, 'hArr'],
[8704, 'forall'],
[8706, 'part'],
[8707, 'exist'],
[8709, 'empty'],
[8711, 'nabla'],
[8712, 'isin'],
[8715, 'ni'],
[8713, 'notin'],
[8721, 'sum'],
[8719, 'prod'],
[8722, 'minus'],
[8727, 'lowast'],
[8730, 'radic'],
[8733, 'prop'],
[8734, 'infin'],
[8736, 'ang'],
[8743, 'and'],
[8744, 'or'],
[8745, 'cap'],
[8746, 'cup'],
[8747, 'int'],
[8756, 'there4'],
[8764, 'sim'],
[8776, 'asymp'],
[8773, 'cong'],
[8800, 'ne'],
[8801, 'equiv'],
[8804, 'le'],
[8805, 'ge'],
[8834, 'sub'],
[8835, 'sup'],
[8838, 'sube'],
[8839, 'supe'],
[8836, 'nsub'],
[8853, 'oplus'],
[8855, 'otimes'],
[8869, 'perp'],
[8901, 'sdot'],
[8942, 'vellip'],
[8968, 'rceil'],
[8969, 'lceil'],
[8970, 'lfloor'],
[8971, 'rfloor'],
[9001, 'rang'],
[9002, 'lang'],
[9674, 'loz'],
[9824, 'spades'],
[9827, 'clubs'],
[9829, 'hearts'],
[9830, 'diams'],
[38, 'amp'],
[34, 'quot'],
[39, 'apos'],
[169, 'copy'],
[60, 'lt'],
[62, 'gt'],
[338, 'OElig'],
[339, 'oelig'],
[352, 'Scaron'],
[353, 'scaron'],
[376, 'Yuml'],
[710, 'circ'],
[732, 'tilde'],
[8211, 'ndash'],
[8212, 'mdash'],
[8216, 'lsquo'],
[8217, 'rsquo'],
[8220, 'ldquo'],
[8221, 'rdquo'],
[8224, 'dagger'],
[8225, 'Dagger'],
[8240, 'permil'],
[8364, 'euro'],
[8249, 'lsaquo'],
[8250, 'rsaquo'],
[160, 'nbsp'],
[161, 'iexcl'],
[163, 'pound'],
[164, 'curren'],
[165, 'yen'],
[166, 'brvbar'],
[167, 'sect'],
[168, 'uml'],
[171, 'laquo'],
[187, 'raquo'],
[174, 'reg'],
[170, 'ordf'],
[172, 'not'],
[173, 'shy'],
[175, 'macr'],
[176, 'deg'],
[177, 'plusmn'],
[180, 'acute'],
[181, 'micro'],
[182, 'para'],
[183, 'middot'],
[184, 'cedil'],
[186, 'ordm'],
[162, 'cent'],
[185, 'sup1'],
[178, 'sup2'],
[179, 'sup3'],
[189, 'frac12'],
[188, 'frac14'],
[190, 'frac34'],
[191, 'iquest'],
[192, 'Agrave'],
[193, 'Aacute'],
[194, 'Acirc'],
[195, 'Atilde'],
[196, 'Auml'],
[197, 'Aring'],
[198, 'AElig'],
[199, 'Ccedil'],
[200, 'Egrave'],
[201, 'Eacute'],
[202, 'Ecirc'],
[203, 'Euml'],
[204, 'Igrave'],
[205, 'Iacute'],
[206, 'Icirc'],
[207, 'Iuml'],
[208, 'ETH'],
[209, 'Ntilde'],
[210, 'Ograve'],
[211, 'Oacute'],
[212, 'Ocirc'],
[213, 'Otilde'],
[214, 'Ouml'],
[215, 'times'],
[216, 'Oslash'],
[217, 'Ugrave'],
[218, 'Uacute'],
[219, 'Ucirc'],
[220, 'Uuml'],
[221, 'Yacute'],
[222, 'THORN'],
[223, 'szlig'],
[224, 'agrave'],
[225, 'aacute'],
[226, 'acirc'],
[227, 'atilde'],
[228, 'auml'],
[229, 'aring'],
[230, 'aelig'],
[231, 'ccedil'],
[232, 'egrave'],
[233, 'eacute'],
[234, 'ecirc'],
[235, 'euml'],
[236, 'igrave'],
[237, 'iacute'],
[238, 'icirc'],
[239, 'iuml'],
[240, 'eth'],
[241, 'ntilde'],
[242, 'ograve'],
[243, 'oacute'],
[244, 'ocirc'],
[245, 'otilde'],
[246, 'ouml'],
[247, 'divide'],
[248, 'oslash'],
[249, 'ugrave'],
[250, 'uacute'],
[251, 'ucirc'],
[252, 'uuml'],
[253, 'yacute'],
[254, 'thorn'],
[255, 'yuml'],
[8218, 'sbquo'],
[402, 'fnof'],
[8222, 'bdquo'],
[128, 8364],
[130, 8218],
[131, 402],
[132, 8222],
[133, 8230],
[134, 8224],
[135, 8225],
[136, 710],
[137, 8240],
[138, 352],
[139, 8249],
[140, 338],
[142, 381],
[145, 8216],
[146, 8217],
[147, 8220],
[148, 8221],
[149, 8226],
[150, 8211],
[151, 8212],
[152, 732],
[153, 8482],
[154, 353],
[155, 8250],
[156, 339],
[158, 382],
[159, 376],
[8194, 'ensp'],
[8195, 'emsp'],
[8201, 'thinsp'],
]
# Contains the mapping of code point (or name) to the actual Entity object.
ENTITY_MAP = Hash.new do |h,k|
if k.kind_of?(Integer)
h[k] = Entity.new(k, nil)
else
raise Kramdown::Error, "Can't handle generic non-integer character reference '#{k}'"
end
end
ENTITY_TABLE.each do |code_point, data|
if data.kind_of?(String)
ENTITY_MAP[code_point] = ENTITY_MAP[data] = Entity.new(code_point, data)
else
ENTITY_MAP[code_point] = ENTITY_MAP[data]
end
end
# Return the entity for the given code point or name +point_or_name+.
def entity(point_or_name)
ENTITY_MAP[point_or_name]
end
module_function :entity
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/configurable.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/configurable.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Utils
# Methods for registering configurable extensions.
module Configurable
# Create a new configurable extension called +name+.
#
# Three methods will be defined on the calling object which allow to use this configurable
# extension:
#
# configurables:: Returns a hash of hashes that is used to store all configurables of the
# object.
#
# <name>(ext_name):: Return the configured extension +ext_name+.
#
# add_<name>(ext_name, data=nil, &block):: Define an extension +ext_name+ by specifying either
# the data as argument or by using a block.
def configurable(name)
singleton_class = (class << self; self; end)
singleton_class.send(:define_method, :configurables) do
@_configurables ||= Hash.new {|h, k| h[k] = {}}
end unless respond_to?(:configurables)
singleton_class.send(:define_method, name) do |data|
configurables[name][data]
end
singleton_class.send(:define_method, "add_#{name}".intern) do |data, *args, &block|
configurables[name][data] = args.first || block
end
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/string_scanner.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/string_scanner.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'strscan'
module Kramdown
module Utils
# This patched StringScanner adds line number information for current scan position and a
# start_line_number override for nested StringScanners.
class StringScanner < ::StringScanner
# The start line number. Used for nested StringScanners that scan a sub-string of the source
# document. The kramdown parser uses this, e.g., for span level parsers.
attr_reader :start_line_number
# Takes the start line number as optional second argument.
#
# Note: The original second argument is no longer used so this should be safe.
def initialize(string, start_line_number = 1)
super(string)
@start_line_number = start_line_number || 1
@previous_pos = 0
@previous_line_number = @start_line_number
end
# Sets the byte position of the scan pointer.
#
# Note: This also resets some internal variables, so always use pos= when setting the position
# and don't use any other method for that!
def pos=(pos)
if self.pos > pos
@previous_line_number = @start_line_number
@previous_pos = 0
end
super
end
# Return information needed to revert the byte position of the string scanner in a performant
# way.
#
# The returned data can be fed to #revert_pos to revert the position to the saved one.
#
# Note: Just saving #pos won't be enough.
def save_pos
[pos, @previous_pos, @previous_line_number]
end
# Revert the position to one saved by #save_pos.
def revert_pos(data)
self.pos = data[0]
@previous_pos, @previous_line_number = data[1], data[2]
end
# Returns the line number for current charpos.
#
# NOTE: Requires that all line endings are normalized to '\n'
#
# NOTE: Normally we'd have to add one to the count of newlines to get the correct line number.
# However we add the one indirectly by using a one-based start_line_number.
def current_line_number
# Not using string[@previous_pos..best_pos].count('\n') because it is slower
strscan = ::StringScanner.new(string)
strscan.pos = @previous_pos
old_pos = pos + 1
@previous_line_number += 1 while strscan.skip_until(/\n/) && strscan.pos <= old_pos
@previous_pos = (eos? ? pos : pos + 1)
@previous_line_number
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/html.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/utils/html.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'rexml/parsers/baseparser'
module Kramdown
module Utils
# Provides convenience methods for HTML related tasks.
#
# *Note* that this module has to be mixed into a class that has a @root (containing an element
# of type :root) and an @options (containing an options hash) instance variable so that some of
# the methods can work correctly.
module Html
# Convert the entity +e+ to a string. The optional parameter +original+ may contain the
# original representation of the entity.
#
# This method uses the option +entity_output+ to determine the output form for the entity.
def entity_to_str(e, original = nil)
entity_output = @options[:entity_output]
if entity_output == :as_char &&
(c = e.char.encode(@root.options[:encoding]) rescue nil) &&
((c = e.char) == '"' || !ESCAPE_MAP.has_key?(c))
c
elsif (entity_output == :as_input || entity_output == :as_char) && original
original
elsif (entity_output == :symbolic || ESCAPE_MAP.has_key?(e.char)) && !e.name.nil?
"&#{e.name};"
else # default to :numeric
"&##{e.code_point};"
end
end
# Return the HTML representation of the attributes +attr+.
def html_attributes(attr)
attr.map {|k,v| v.nil? || (k == 'id' && v.strip.empty?) ? '' : " #{k}=\"#{escape_html(v.to_s, :attribute)}\"" }.join('')
end
# :stopdoc:
ESCAPE_MAP = {
'<' => '<',
'>' => '>',
'&' => '&',
'"' => '"'
}
ESCAPE_ALL_RE = /<|>|&/
ESCAPE_TEXT_RE = Regexp.union(REXML::Parsers::BaseParser::REFERENCE_RE, /<|>|&/)
ESCAPE_ATTRIBUTE_RE = Regexp.union(REXML::Parsers::BaseParser::REFERENCE_RE, /<|>|&|"/)
ESCAPE_RE_FROM_TYPE = {
:all => ESCAPE_ALL_RE,
:text => ESCAPE_TEXT_RE,
:attribute => ESCAPE_ATTRIBUTE_RE
}
# :startdoc:
# Escape the special HTML characters in the string +str+. The parameter +type+ specifies what
# is escaped: :all - all special HTML characters except the quotation mark as well as
# entities, :text - all special HTML characters except the quotation mark but no entities and
# :attribute - all special HTML characters including the quotation mark but no entities.
def escape_html(str, type = :all)
str.gsub(ESCAPE_RE_FROM_TYPE[type]) {|m| ESCAPE_MAP[m] || m}
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/latex.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/latex.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'set'
require 'kramdown/converter'
module Kramdown
module Converter
# Converts an element tree to LaTeX.
#
# This converter uses ideas from other Markdown-to-LaTeX converters like Pandoc and Maruku.
#
# You can customize this converter by sub-classing it and overriding the +convert_NAME+ methods.
# Each such method takes the following parameters:
#
# [+el+] The element of type +NAME+ to be converted.
#
# [+opts+] A hash containing processing options that are passed down from parent elements. The
# key :parent is always set and contains the parent element as value.
#
# The return value of such a method has to be a string containing the element +el+ formatted
# correctly as LaTeX markup.
class Latex < Base
# Initialize the LaTeX converter with the +root+ element and the conversion +options+.
def initialize(root, options)
super
@data[:packages] = Set.new
end
# Dispatch the conversion of the element +el+ to a +convert_TYPE+ method using the +type+ of
# the element.
def convert(el, opts = {})
send("convert_#{el.type}", el, opts)
end
# Return the converted content of the children of +el+ as a string.
def inner(el, opts)
result = ''
options = opts.dup.merge(:parent => el)
el.children.each_with_index do |inner_el, index|
options[:index] = index
options[:result] = result
result << send("convert_#{inner_el.type}", inner_el, options)
end
result
end
def convert_root(el, opts)
inner(el, opts)
end
def convert_blank(el, opts)
opts[:result] =~ /\n\n\Z|\A\Z/ ? "" : "\n"
end
def convert_text(el, opts)
escape(el.value)
end
def convert_p(el, opts)
if el.children.size == 1 && el.children.first.type == :img && !(img = convert_img(el.children.first, opts)).empty?
convert_standalone_image(el, opts, img)
else
"#{latex_link_target(el)}#{inner(el, opts)}\n\n"
end
end
# Helper method used by +convert_p+ to convert a paragraph that only contains a single :img
# element.
def convert_standalone_image(el, opts, img)
attrs = attribute_list(el)
"\\begin{figure}#{attrs}\n\\begin{center}\n#{img}\n\\end{center}\n\\caption{#{escape(el.children.first.attr['alt'])}}\n#{latex_link_target(el, true)}\n\\end{figure}#{attrs}\n"
end
def convert_codeblock(el, opts)
show_whitespace = el.attr['class'].to_s =~ /\bshow-whitespaces\b/
lang = extract_code_language(el.attr)
if @options[:syntax_highlighter] == :minted &&
(highlighted_code = highlight_code(el.value, lang, :block))
@data[:packages] << 'minted'
"#{latex_link_target(el)}#{highlighted_code}\n"
elsif show_whitespace || lang
options = []
options << "showspaces=%s,showtabs=%s" % (show_whitespace ? ['true', 'true'] : ['false', 'false'])
options << "language=#{lang}" if lang
options << "basicstyle=\\ttfamily\\footnotesize,columns=fixed,frame=tlbr"
id = el.attr['id']
options << "label=#{id}" if id
attrs = attribute_list(el)
"#{latex_link_target(el)}\\begin{lstlisting}[#{options.join(',')}]\n#{el.value}\n\\end{lstlisting}#{attrs}\n"
else
"#{latex_link_target(el)}\\begin{verbatim}#{el.value}\\end{verbatim}\n"
end
end
def convert_blockquote(el, opts)
latex_environment(el.children.size > 1 ? 'quotation' : 'quote', el, inner(el, opts))
end
def convert_header(el, opts)
type = @options[:latex_headers][output_header_level(el.options[:level]) - 1]
if ((id = el.attr['id']) ||
(@options[:auto_ids] && (id = generate_id(el.options[:raw_text])))) && in_toc?(el)
"\\#{type}{#{inner(el, opts)}}\\hypertarget{#{id}}{}\\label{#{id}}\n\n"
else
"\\#{type}*{#{inner(el, opts)}}\n\n"
end
end
def convert_hr(el, opts)
attrs = attribute_list(el)
"#{latex_link_target(el)}\\begin{center}#{attrs}\n\\rule{3in}{0.4pt}\n\\end{center}#{attrs}\n"
end
def convert_ul(el, opts)
if !@data[:has_toc] && (el.options[:ial][:refs].include?('toc') rescue nil)
@data[:has_toc] = true
'\tableofcontents'
else
latex_environment(el.type == :ul ? 'itemize' : 'enumerate', el, inner(el, opts))
end
end
alias :convert_ol :convert_ul
def convert_dl(el, opts)
latex_environment('description', el, inner(el, opts))
end
def convert_li(el, opts)
"\\item{} #{latex_link_target(el, true)}#{inner(el, opts).sub(/\n+\Z/, '')}\n"
end
def convert_dt(el, opts)
"\\item[#{inner(el, opts)}] "
end
def convert_dd(el, opts)
"#{latex_link_target(el)}#{inner(el, opts)}\n\n"
end
def convert_html_element(el, opts)
if el.value == 'i' || el.value == 'em'
"\\emph{#{inner(el, opts)}}"
elsif el.value == 'b' || el.value == 'strong'
"\\textbf{#{inner(el, opts)}}"
else
warning("Can't convert HTML element")
''
end
end
def convert_xml_comment(el, opts)
el.value.split(/\n/).map {|l| "% #{l}"}.join("\n") + "\n"
end
def convert_xml_pi(el, opts)
warning("Can't convert XML PI")
''
end
TABLE_ALIGNMENT_CHAR = {:default => 'l', :left => 'l', :center => 'c', :right => 'r'} # :nodoc:
def convert_table(el, opts)
@data[:packages] << 'longtable'
align = el.options[:alignment].map {|a| TABLE_ALIGNMENT_CHAR[a]}.join('|')
attrs = attribute_list(el)
"#{latex_link_target(el)}\\begin{longtable}{|#{align}|}#{attrs}\n\\hline\n#{inner(el, opts)}\\hline\n\\end{longtable}#{attrs}\n\n"
end
def convert_thead(el, opts)
"#{inner(el, opts)}\\hline\n"
end
def convert_tbody(el, opts)
inner(el, opts)
end
def convert_tfoot(el, opts)
"\\hline \\hline \n#{inner(el, opts)}"
end
def convert_tr(el, opts)
el.children.map {|c| send("convert_#{c.type}", c, opts)}.join(' & ') << "\\\\\n"
end
def convert_td(el, opts)
inner(el, opts)
end
def convert_comment(el, opts)
el.value.split(/\n/).map {|l| "% #{l}"}.join("\n") << "\n"
end
def convert_br(el, opts)
res = "\\newline"
res << "\n" if (c = opts[:parent].children[opts[:index]+1]) && (c.type != :text || c.value !~ /^\s*\n/)
res
end
def convert_a(el, opts)
url = el.attr['href']
if url.start_with?('#')
"\\hyperlink{#{url[1..-1].gsub('%', "\\%")}}{#{inner(el, opts)}}"
else
"\\href{#{url.gsub('%', "\\%")}}{#{inner(el, opts)}}"
end
end
def convert_img(el, opts)
line = el.options[:location]
if el.attr['src'] =~ /^(https?|ftps?):\/\//
warning("Cannot include non-local image#{line ? " (line #{line})" : ''}")
''
elsif !el.attr['src'].empty?
@data[:packages] << 'graphicx'
"#{latex_link_target(el)}\\includegraphics{#{el.attr['src']}}"
else
warning("Cannot include image with empty path#{line ? " (line #{line})" : ''}")
''
end
end
def convert_codespan(el, opts)
lang = extract_code_language(el.attr)
if @options[:syntax_highlighter] == :minted &&
(highlighted_code = highlight_code(el.value, lang, :span))
@data[:packages] << 'minted'
"#{latex_link_target(el)}#{highlighted_code}"
else
"\\texttt{#{latex_link_target(el)}#{escape(el.value)}}"
end
end
def convert_footnote(el, opts)
@data[:packages] << 'fancyvrb'
"\\footnote{#{inner(el.value, opts).rstrip}}"
end
def convert_raw(el, opts)
if !el.options[:type] || el.options[:type].empty? || el.options[:type].include?('latex')
el.value + (el.options[:category] == :block ? "\n" : '')
else
''
end
end
def convert_em(el, opts)
"\\emph{#{latex_link_target(el)}#{inner(el, opts)}}"
end
def convert_strong(el, opts)
"\\textbf{#{latex_link_target(el)}#{inner(el, opts)}}"
end
# Inspired by Maruku: entity conversion table based on the one from htmltolatex
# (http://sourceforge.net/projects/htmltolatex/), with some small adjustments/additions
ENTITY_CONV_TABLE = {
913 => ['$A$'],
914 => ['$B$'],
915 => ['$\Gamma$'],
916 => ['$\Delta$'],
917 => ['$E$'],
918 => ['$Z$'],
919 => ['$H$'],
920 => ['$\Theta$'],
921 => ['$I$'],
922 => ['$K$'],
923 => ['$\Lambda$'],
924 => ['$M$'],
925 => ['$N$'],
926 => ['$\Xi$'],
927 => ['$O$'],
928 => ['$\Pi$'],
929 => ['$P$'],
931 => ['$\Sigma$'],
932 => ['$T$'],
933 => ['$Y$'],
934 => ['$\Phi$'],
935 => ['$X$'],
936 => ['$\Psi$'],
937 => ['$\Omega$'],
945 => ['$\alpha$'],
946 => ['$\beta$'],
947 => ['$\gamma$'],
948 => ['$\delta$'],
949 => ['$\epsilon$'],
950 => ['$\zeta$'],
951 => ['$\eta$'],
952 => ['$\theta$'],
953 => ['$\iota$'],
954 => ['$\kappa$'],
955 => ['$\lambda$'],
956 => ['$\mu$'],
957 => ['$\nu$'],
958 => ['$\xi$'],
959 => ['$o$'],
960 => ['$\pi$'],
961 => ['$\rho$'],
963 => ['$\sigma$'],
964 => ['$\tau$'],
965 => ['$\upsilon$'],
966 => ['$\phi$'],
967 => ['$\chi$'],
968 => ['$\psi$'],
969 => ['$\omega$'],
962 => ['$\varsigma$'],
977 => ['$\vartheta$'],
982 => ['$\varpi$'],
8230 => ['\ldots'],
8242 => ['$\prime$'],
8254 => ['-'],
8260 => ['/'],
8472 => ['$\wp$'],
8465 => ['$\Im$'],
8476 => ['$\Re$'],
8501 => ['$\aleph$'],
8226 => ['$\bullet$'],
8482 => ['$^{\rm TM}$'],
8592 => ['$\leftarrow$'],
8594 => ['$\rightarrow$'],
8593 => ['$\uparrow$'],
8595 => ['$\downarrow$'],
8596 => ['$\leftrightarrow$'],
8629 => ['$\hookleftarrow$'],
8657 => ['$\Uparrow$'],
8659 => ['$\Downarrow$'],
8656 => ['$\Leftarrow$'],
8658 => ['$\Rightarrow$'],
8660 => ['$\Leftrightarrow$'],
8704 => ['$\forall$'],
8706 => ['$\partial$'],
8707 => ['$\exists$'],
8709 => ['$\emptyset$'],
8711 => ['$\nabla$'],
8712 => ['$\in$'],
8715 => ['$\ni$'],
8713 => ['$\notin$'],
8721 => ['$\sum$'],
8719 => ['$\prod$'],
8722 => ['$-$'],
8727 => ['$\ast$'],
8730 => ['$\surd$'],
8733 => ['$\propto$'],
8734 => ['$\infty$'],
8736 => ['$\angle$'],
8743 => ['$\wedge$'],
8744 => ['$\vee$'],
8745 => ['$\cap$'],
8746 => ['$\cup$'],
8747 => ['$\int$'],
8756 => ['$\therefore$', 'amssymb'],
8764 => ['$\sim$'],
8776 => ['$\approx$'],
8773 => ['$\cong$'],
8800 => ['$\neq$'],
8801 => ['$\equiv$'],
8804 => ['$\leq$'],
8805 => ['$\geq$'],
8834 => ['$\subset$'],
8835 => ['$\supset$'],
8838 => ['$\subseteq$'],
8839 => ['$\supseteq$'],
8836 => ['$\nsubset$', 'amssymb'],
8853 => ['$\oplus$'],
8855 => ['$\otimes$'],
8869 => ['$\perp$'],
8901 => ['$\cdot$'],
8968 => ['$\rceil$'],
8969 => ['$\lceil$'],
8970 => ['$\lfloor$'],
8971 => ['$\rfloor$'],
9001 => ['$\rangle$'],
9002 => ['$\langle$'],
9674 => ['$\lozenge$', 'amssymb'],
9824 => ['$\spadesuit$'],
9827 => ['$\clubsuit$'],
9829 => ['$\heartsuit$'],
9830 => ['$\diamondsuit$'],
38 => ['\&'],
34 => ['"'],
39 => ['\''],
169 => ['\copyright'],
60 => ['\textless'],
62 => ['\textgreater'],
338 => ['\OE'],
339 => ['\oe'],
352 => ['\v{S}'],
353 => ['\v{s}'],
376 => ['\"Y'],
710 => ['\textasciicircum'],
732 => ['\textasciitilde'],
8211 => ['--'],
8212 => ['---'],
8216 => ['`'],
8217 => ['\''],
8220 => ['``'],
8221 => ['\'\''],
8224 => ['\dag'],
8225 => ['\ddag'],
8240 => ['\permil', 'wasysym'],
8364 => ['\euro', 'eurosym'],
8249 => ['\guilsinglleft'],
8250 => ['\guilsinglright'],
8218 => ['\quotesinglbase', 'mathcomp'],
8222 => ['\quotedblbase', 'mathcomp'],
402 => ['\textflorin', 'mathcomp'],
381 => ['\v{Z}'],
382 => ['\v{z}'],
160 => ['~'],
161 => ['\textexclamdown'],
163 => ['\pounds'],
164 => ['\currency', 'wasysym'],
165 => ['\textyen', 'textcomp'],
166 => ['\brokenvert', 'wasysym'],
167 => ['\S'],
171 => ['\guillemotleft'],
187 => ['\guillemotright'],
174 => ['\textregistered'],
170 => ['\textordfeminine'],
172 => ['$\neg$'],
173 => ['\-'],
176 => ['$\degree$', 'mathabx'],
177 => ['$\pm$'],
180 => ['\''],
181 => ['$\mu$'],
182 => ['\P'],
183 => ['$\cdot$'],
186 => ['\textordmasculine'],
162 => ['\cent', 'wasysym'],
185 => ['$^1$'],
178 => ['$^2$'],
179 => ['$^3$'],
189 => ['$\frac{1}{2}$'],
188 => ['$\frac{1}{4}$'],
190 => ['$\frac{3}{4}'],
192 => ['\`A'],
193 => ['\\\'A'],
194 => ['\^A'],
195 => ['\~A'],
196 => ['\"A'],
197 => ['\AA'],
198 => ['\AE'],
199 => ['\cC'],
200 => ['\`E'],
201 => ['\\\'E'],
202 => ['\^E'],
203 => ['\"E'],
204 => ['\`I'],
205 => ['\\\'I'],
206 => ['\^I'],
207 => ['\"I'],
208 => ['$\eth$', 'amssymb'],
209 => ['\~N'],
210 => ['\`O'],
211 => ['\\\'O'],
212 => ['\^O'],
213 => ['\~O'],
214 => ['\"O'],
215 => ['$\times$'],
216 => ['\O'],
217 => ['\`U'],
218 => ['\\\'U'],
219 => ['\^U'],
220 => ['\"U'],
221 => ['\\\'Y'],
222 => ['\Thorn', 'wasysym'],
223 => ['\ss'],
224 => ['\`a'],
225 => ['\\\'a'],
226 => ['\^a'],
227 => ['\~a'],
228 => ['\"a'],
229 => ['\aa'],
230 => ['\ae'],
231 => ['\cc'],
232 => ['\`e'],
233 => ['\\\'e'],
234 => ['\^e'],
235 => ['\"e'],
236 => ['\`i'],
237 => ['\\\'i'],
238 => ['\^i'],
239 => ['\"i'],
240 => ['$\eth$'],
241 => ['\~n'],
242 => ['\`o'],
243 => ['\\\'o'],
244 => ['\^o'],
245 => ['\~o'],
246 => ['\"o'],
247 => ['$\divide$'],
248 => ['\o'],
249 => ['\`u'],
250 => ['\\\'u'],
251 => ['\^u'],
252 => ['\"u'],
253 => ['\\\'y'],
254 => ['\thorn', 'wasysym'],
255 => ['\"y'],
8201 => ['\thinspace'],
8194 => ['\hskip .5em\relax'],
8195 => ['\quad'],
} # :nodoc:
ENTITY_CONV_TABLE.each {|k,v| ENTITY_CONV_TABLE[k][0].insert(-1, '{}')}
def entity_to_latex(entity)
text, package = ENTITY_CONV_TABLE[entity.code_point]
if text
@data[:packages] << package if package
text
else
warning("Couldn't find entity with code #{entity.code_point} in substitution table!")
''
end
end
def convert_entity(el, opts)
entity_to_latex(el.value)
end
TYPOGRAPHIC_SYMS = {
:mdash => '---', :ndash => '--', :hellip => '\ldots{}',
:laquo_space => '\guillemotleft{}~', :raquo_space => '~\guillemotright{}',
:laquo => '\guillemotleft{}', :raquo => '\guillemotright{}'
} # :nodoc:
def convert_typographic_sym(el, opts)
if (result = @options[:typographic_symbols][el.value])
escape(result)
else
TYPOGRAPHIC_SYMS[el.value]
end
end
def convert_smart_quote(el, opts)
res = entity_to_latex(smart_quote_entity(el)).chomp('{}')
res << "{}" if ((nel = opts[:parent].children[opts[:index]+1]) && nel.type == :smart_quote) || res =~ /\w$/
res
end
def convert_math(el, opts)
@data[:packages] += %w[amssymb amsmath amsthm amsfonts]
if el.options[:category] == :block
if el.value =~ /\A\s*\\begin\{/
el.value
else
latex_environment('displaymath', el, el.value)
end
else
"$#{el.value}$"
end
end
def convert_abbreviation(el, opts)
@data[:packages] += %w[acronym]
"\\ac{#{normalize_abbreviation_key(el.value)}}"
end
# Normalize the abbreviation key so that it only contains allowed ASCII character
def normalize_abbreviation_key(key)
key.gsub(/\W/) {|m| m.unpack('H*').first}
end
# Wrap the +text+ inside a LaTeX environment of type +type+. The element +el+ is passed on to
# the method #attribute_list -- the resulting string is appended to both the \\begin and the
# \\end lines of the LaTeX environment for easier post-processing of LaTeX environments.
def latex_environment(type, el, text)
attrs = attribute_list(el)
"\\begin{#{type}}#{latex_link_target(el)}#{attrs}\n#{text.rstrip}\n\\end{#{type}}#{attrs}\n"
end
# Return a string containing a valid \hypertarget command if the element has an ID defined, or
# +nil+ otherwise. If the parameter +add_label+ is +true+, a \label command will also be used
# additionally to the \hypertarget command.
def latex_link_target(el, add_label = false)
if (id = el.attr['id'])
"\\hypertarget{#{id}}{}" << (add_label ? "\\label{#{id}}" : '')
else
nil
end
end
# Return a LaTeX comment containing all attributes as 'key="value"' pairs.
def attribute_list(el)
attrs = el.attr.map {|k,v| v.nil? ? '' : " #{k}=\"#{v.to_s}\""}.compact.sort.join('')
attrs = " % #{attrs}" if !attrs.empty?
attrs
end
ESCAPE_MAP = {
"^" => "\\^{}",
"\\" => "\\textbackslash{}",
"~" => "\\ensuremath{\\sim}",
"|" => "\\textbar{}",
"<" => "\\textless{}",
">" => "\\textgreater{}",
"[" => "{[}",
"]" => "{]}",
}.merge(Hash[*("{}$%&_#".scan(/./).map {|c| [c, "\\#{c}"]}.flatten)]) # :nodoc:
ESCAPE_RE = Regexp.union(*ESCAPE_MAP.collect {|k,v| k}) # :nodoc:
# Escape the special LaTeX characters in the string +str+.
def escape(str)
str.gsub(ESCAPE_RE) {|m| ESCAPE_MAP[m]}
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/hash_ast.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/hash_ast.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser'
require 'kramdown/converter'
require 'kramdown/utils'
module Kramdown
module Converter
# Converts a Kramdown::Document to a nested hash for further processing or debug output.
class HashAST < Base
def convert(el)
hash = {:type => el.type}
hash[:attr] = el.attr unless el.attr.empty?
hash[:value] = el.value unless el.value.nil?
hash[:options] = el.options unless el.options.empty?
unless el.children.empty?
hash[:children] = []
el.children.each {|child| hash[:children] << convert(child)}
end
hash
end
end
HashAst = HashAST
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/kramdown.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/kramdown.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/converter'
require 'kramdown/utils'
module Kramdown
module Converter
# Converts an element tree to the kramdown format.
class Kramdown < Base
# :stopdoc:
include ::Kramdown::Utils::Html
def initialize(root, options)
super
@linkrefs = []
@footnotes = []
@abbrevs = []
@stack = []
end
def convert(el, opts = {:indent => 0})
res = send("convert_#{el.type}", el, opts)
if ![:html_element, :li, :dt, :dd, :td].include?(el.type) && (ial = ial_for_element(el))
res << ial
res << "\n\n" if Element.category(el) == :block
elsif [:ul, :dl, :ol, :codeblock].include?(el.type) && opts[:next] &&
([el.type, :codeblock].include?(opts[:next].type) ||
(opts[:next].type == :blank && opts[:nnext] && [el.type, :codeblock].include?(opts[:nnext].type)))
res << "^\n\n"
elsif Element.category(el) == :block &&
![:li, :dd, :dt, :td, :th, :tr, :thead, :tbody, :tfoot, :blank].include?(el.type) &&
(el.type != :html_element || @stack.last.type != :html_element) &&
(el.type != :p || !el.options[:transparent])
res << "\n"
end
res
end
def inner(el, opts = {:indent => 0})
@stack.push(el)
result = ''
el.children.each_with_index do |inner_el, index|
options = opts.dup
options[:index] = index
options[:prev] = (index == 0 ? nil : el.children[index-1])
options[:pprev] = (index <= 1 ? nil : el.children[index-2])
options[:next] = (index == el.children.length - 1 ? nil : el.children[index+1])
options[:nnext] = (index >= el.children.length - 2 ? nil : el.children[index+2])
result << convert(inner_el, options)
end
@stack.pop
result
end
def convert_blank(el, opts)
""
end
ESCAPED_CHAR_RE = /(\$\$|[\\*_`\[\]\{"'|])|^[ ]{0,3}(:)/
def convert_text(el, opts)
if opts[:raw_text]
el.value
else
el.value.gsub(/\A\n/) do
opts[:prev] && opts[:prev].type == :br ? '' : "\n"
end.gsub(/\s+/, ' ').gsub(ESCAPED_CHAR_RE) { "\\#{$1 || $2}" }
end
end
def convert_p(el, opts)
w = @options[:line_width] - opts[:indent].to_s.to_i
first, second, *rest = inner(el, opts).strip.gsub(/(.{1,#{w}})( +|$\n?)/, "\\1\n").split(/\n/)
first.gsub!(/^(?:(#|>)|(\d+)\.|([+-]\s))/) { $1 || $3 ? "\\#{$1 || $3}" : "#{$2}\\."} if first
second.gsub!(/^([=-]+\s*?)$/, "\\\1") if second
res = [first, second, *rest].compact.join("\n") + "\n"
if el.children.length == 1 && el.children.first.type == :math
res = "\\#{res}"
elsif res.start_with?('\$$') && res.end_with?("\\$$\n")
res.sub!(/^\\\$\$/, '\$\$')
end
res
end
def convert_codeblock(el, opts)
el.value.split(/\n/).map {|l| l.empty? ? " " : " #{l}"}.join("\n") + "\n"
end
def convert_blockquote(el, opts)
opts[:indent] += 2
inner(el, opts).chomp.split(/\n/).map {|l| "> #{l}"}.join("\n") << "\n"
end
def convert_header(el, opts)
res = ''
res << "#{'#' * output_header_level(el.options[:level])} #{inner(el, opts)}"
res[-1, 1] = "\\#" if res[-1] == ?#
res << " {##{el.attr['id']}}" if el.attr['id'] && !el.attr['id'].strip.empty?
res << "\n"
end
def convert_hr(el, opts)
"* * *\n"
end
def convert_ul(el, opts)
inner(el, opts).sub(/\n+\Z/, "\n")
end
alias :convert_ol :convert_ul
alias :convert_dl :convert_ul
def convert_li(el, opts)
sym, width = if @stack.last.type == :ul
['* ', el.children.first && el.children.first.type == :codeblock ? 4 : 2]
else
["#{opts[:index] + 1}.".ljust(4), 4]
end
if ial = ial_for_element(el)
sym << ial << " "
end
opts[:indent] += width
text = inner(el, opts)
newlines = text.scan(/\n*\Z/).first
first, *last = text.split(/\n/)
last = last.map {|l| " "*width + l}.join("\n")
text = (first.nil? ? "\n" : first + (last.empty? ? "" : "\n") + last + newlines)
if el.children.first && el.children.first.type == :p && !el.children.first.options[:transparent]
res = "#{sym}#{text}"
res << "^\n" if el.children.size == 1 && @stack.last.children.last == el &&
(@stack.last.children.any? {|c| c.children.first.type != :p} || @stack.last.children.size == 1)
res
elsif el.children.first && el.children.first.type == :codeblock
"#{sym}\n #{text}"
else
"#{sym}#{text}"
end
end
def convert_dd(el, opts)
sym, width = ": ", (el.children.first && el.children.first.type == :codeblock ? 4 : 2)
if ial = ial_for_element(el)
sym << ial << " "
end
opts[:indent] += width
text = inner(el, opts)
newlines = text.scan(/\n*\Z/).first
first, *last = text.split(/\n/)
last = last.map {|l| " "*width + l}.join("\n")
text = first.to_s + (last.empty? ? "" : "\n") + last + newlines
text.chomp! if text =~ /\n\n\Z/ && opts[:next] && opts[:next].type == :dd
text << "\n" if (text !~ /\n\n\Z/ && opts[:next] && opts[:next].type == :dt)
text << "\n" if el.children.empty?
if el.children.first && el.children.first.type == :p && !el.children.first.options[:transparent]
"\n#{sym}#{text}"
elsif el.children.first && el.children.first.type == :codeblock
"#{sym}\n #{text}"
else
"#{sym}#{text}"
end
end
def convert_dt(el, opts)
result = ''
if ial = ial_for_element(el)
result << ial << " "
end
result << inner(el, opts) << "\n"
end
HTML_TAGS_WITH_BODY=['div', 'script', 'iframe', 'textarea']
def convert_html_element(el, opts)
markdown_attr = el.options[:category] == :block && el.children.any? do |c|
c.type != :html_element && (c.type != :p || !c.options[:transparent]) && Element.category(c) == :block
end
opts[:force_raw_text] = true if %w{script pre code}.include?(el.value)
opts[:raw_text] = opts[:force_raw_text] || opts[:block_raw_text] || (el.options[:category] != :span && !markdown_attr)
opts[:block_raw_text] = true if el.options[:category] == :block && opts[:raw_text]
res = inner(el, opts)
if el.options[:category] == :span
"<#{el.value}#{html_attributes(el.attr)}" << (!res.empty? || HTML_TAGS_WITH_BODY.include?(el.value) ? ">#{res}</#{el.value}>" : " />")
else
output = ''
attr = el.attr.dup
attr['markdown'] = '1' if markdown_attr
output << "<#{el.value}#{html_attributes(attr)}"
if !res.empty? && el.options[:content_model] != :block
output << ">#{res}</#{el.value}>"
elsif !res.empty?
output << ">\n#{res}" << "</#{el.value}>"
elsif HTML_TAGS_WITH_BODY.include?(el.value)
output << "></#{el.value}>"
else
output << " />"
end
output << "\n" if @stack.last.type != :html_element || @stack.last.options[:content_model] != :raw
output
end
end
def convert_xml_comment(el, opts)
if el.options[:category] == :block && (@stack.last.type != :html_element || @stack.last.options[:content_model] != :raw)
el.value + "\n"
else
el.value.dup
end
end
alias :convert_xml_pi :convert_xml_comment
def convert_table(el, opts)
opts[:alignment] = el.options[:alignment]
inner(el, opts)
end
def convert_thead(el, opts)
rows = inner(el, opts)
if opts[:alignment].all? {|a| a == :default}
"#{rows}|" << "-"*10 << "\n"
else
"#{rows}| " << opts[:alignment].map do |a|
case a
when :left then ":-"
when :right then "-:"
when :center then ":-:"
when :default then "-"
end
end.join(' ') << "\n"
end
end
def convert_tbody(el, opts)
res = ''
res << inner(el, opts)
res << '|' << '-'*10 << "\n" if opts[:next] && opts[:next].type == :tbody
res
end
def convert_tfoot(el, opts)
"|" << "="*10 << "\n#{inner(el, opts)}"
end
def convert_tr(el, opts)
"| " << el.children.map {|c| convert(c, opts)}.join(" | ") << " |\n"
end
def convert_td(el, opts)
inner(el, opts)
end
def convert_comment(el, opts)
if el.options[:category] == :block
"{::comment}\n#{el.value}\n{:/}\n"
else
"{::comment}#{el.value}{:/}"
end
end
def convert_br(el, opts)
" \n"
end
def convert_a(el, opts)
if el.attr['href'].empty?
"[#{inner(el, opts)}]()"
elsif el.attr['href'] =~ /^(?:http|ftp)/ || el.attr['href'].count("()") > 0
index = if link_el = @linkrefs.find {|c| c.attr['href'] == el.attr['href']}
@linkrefs.index(link_el) + 1
else
@linkrefs << el
@linkrefs.size
end
"[#{inner(el, opts)}][#{index}]"
else
title = parse_title(el.attr['title'])
"[#{inner(el, opts)}](#{el.attr['href']}#{title})"
end
end
def convert_img(el, opts)
alt_text = el.attr['alt'].to_s.gsub(ESCAPED_CHAR_RE) { $1 ? "\\#{$1}" : $2 }
src = el.attr['src'].to_s
if src.empty?
"![#{alt_text}]()"
else
title = parse_title(el.attr['title'])
link = if src.count("()") > 0
"<#{src}>"
else
src
end
""
end
end
def convert_codespan(el, opts)
delim = (el.value.scan(/`+/).max || '') + '`'
"#{delim}#{' ' if delim.size > 1}#{el.value}#{' ' if delim.size > 1}#{delim}"
end
def convert_footnote(el, opts)
@footnotes << [el.options[:name], el.value]
"[^#{el.options[:name]}]"
end
def convert_raw(el, opts)
attr = (el.options[:type] || []).join(' ')
attr = " type=\"#{attr}\"" if attr.length > 0
if @stack.last.type == :html_element
el.value
elsif el.options[:category] == :block
"{::nomarkdown#{attr}}\n#{el.value}\n{:/}\n"
else
"{::nomarkdown#{attr}}#{el.value}{:/}"
end
end
def convert_em(el, opts)
"*#{inner(el, opts)}*" +
(opts[:next] && [:em, :strong].include?(opts[:next].type) && !ial_for_element(el) ? '{::}' : '')
end
def convert_strong(el, opts)
"**#{inner(el, opts)}**" +
(opts[:next] && [:em, :strong].include?(opts[:next].type) && !ial_for_element(el) ? '{::}' : '')
end
def convert_entity(el, opts)
entity_to_str(el.value, el.options[:original])
end
TYPOGRAPHIC_SYMS = {
:mdash => '---', :ndash => '--', :hellip => '...',
:laquo_space => '<< ', :raquo_space => ' >>',
:laquo => '<<', :raquo => '>>'
}
def convert_typographic_sym(el, opts)
TYPOGRAPHIC_SYMS[el.value]
end
def convert_smart_quote(el, opts)
el.value.to_s =~ /[rl]dquo/ ? "\"" : "'"
end
def convert_math(el, opts)
"$$#{el.value}$$" + (el.options[:category] == :block ? "\n" : '')
end
def convert_abbreviation(el, opts)
el.value
end
def convert_root(el, opts)
res = inner(el, opts)
res << create_link_defs
res << create_footnote_defs
res << create_abbrev_defs
res
end
def create_link_defs
res = ''
res << "\n\n" if @linkrefs.size > 0
@linkrefs.each_with_index do |el, i|
title = parse_title(el.attr['title'])
res << "[#{i+1}]: #{el.attr['href']}#{title}\n"
end
res
end
def create_footnote_defs
res = ''
@footnotes.each do |name, data|
res << "[^#{name}]:\n"
res << inner(data).chomp.split(/\n/).map {|l| " #{l}"}.join("\n") + "\n\n"
end
res
end
def create_abbrev_defs
return '' unless @root.options[:abbrev_defs]
res = ''
@root.options[:abbrev_defs].each do |name, text|
res << "*[#{name}]: #{text}\n"
res << ial_for_element(Element.new(:unused, nil, @root.options[:abbrev_attr][name])).to_s << "\n\n"
end
res
end
# Return the IAL containing the attributes of the element +el+.
def ial_for_element(el)
res = el.attr.map do |k,v|
next if [:img, :a].include?(el.type) && ['href', 'src', 'alt', 'title'].include?(k)
next if el.type == :header && k == 'id' && !v.strip.empty?
if v.nil?
''
elsif k == 'class' && !v.empty? && !v.index(/[\.#]/)
" " + v.split(/\s+/).map {|w| ".#{w}"}.join(" ")
elsif k == 'id' && !v.strip.empty?
" ##{v}"
else
" #{k}=\"#{v.to_s}\""
end
end.compact.join('')
res = "toc" << (res.strip.empty? ? '' : " #{res}") if (el.type == :ul || el.type == :ol) &&
(el.options[:ial][:refs].include?('toc') rescue nil)
res = "footnotes" << (res.strip.empty? ? '' : " #{res}") if (el.type == :ul || el.type == :ol) &&
(el.options[:ial][:refs].include?('footnotes') rescue nil)
if el.type == :dl && el.options[:ial] && el.options[:ial][:refs]
auto_ids = el.options[:ial][:refs].select {|ref| ref =~ /\Aauto_ids/}.join(" ")
res = auto_ids << (res.strip.empty? ? '' : " #{res}") unless auto_ids.empty?
end
res.strip.empty? ? nil : "{:#{res}}"
end
def parse_title(attr)
attr.to_s.empty? ? '' : ' "' + attr.gsub(/"/, '"') + '"'
end
# :startdoc:
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/base.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/base.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'erb'
require 'kramdown/utils'
require 'kramdown/document'
module Kramdown
module Converter
# == \Base class for converters
#
# This class serves as base class for all converters. It provides methods that can/should be
# used by all converters (like #generate_id) as well as common functionality that is
# automatically applied to the result (for example, embedding the output into a template).
#
# A converter object is used as a throw-away object, i.e. it is only used for storing the needed
# state information during conversion. Therefore one can't instantiate a converter object
# directly but only use the Base::convert method.
#
# == Implementing a converter
#
# Implementing a new converter is rather easy: just derive a new class from this class and put
# it in the Kramdown::Converter module (the latter is only needed if auto-detection should work
# properly). Then you need to implement the #convert method which has to contain the conversion
# code for converting an element and has to return the conversion result.
#
# The actual transformation of the document tree can be done in any way. However, writing one
# method per element type is a straight forward way to do it - this is how the Html and Latex
# converters do the transformation.
#
# Have a look at the Base::convert method for additional information!
class Base
# Can be used by a converter for storing arbitrary information during the conversion process.
attr_reader :data
# The hash with the conversion options.
attr_reader :options
# The root element that is converted.
attr_reader :root
# The warnings array.
attr_reader :warnings
# Initialize the converter with the given +root+ element and +options+ hash.
def initialize(root, options)
@options = options
@root = root
@data = {}
@warnings = []
end
private_class_method(:new, :allocate)
# Returns whether the template should be applied before the conversion of the tree.
#
# Defaults to false.
def apply_template_before?
false
end
# Returns whether the template should be applied after the conversion of the tree.
#
# Defaults to true.
def apply_template_after?
true
end
# Convert the element tree +tree+ and return the resulting conversion object (normally a
# string) and an array with warning messages. The parameter +options+ specifies the conversion
# options that should be used.
#
# Initializes a new instance of the calling class and then calls the #convert method with
# +tree+ as parameter.
#
# If the +template+ option is specified and non-empty, the template is evaluate with ERB
# before and/or after the tree conversion depending on the result of #apply_template_before?
# and #apply_template_after?. If the template is evaluated before, an empty string is used for
# the body; if evaluated after, the result is used as body. See ::apply_template.
#
# The template resolution is done in the following way (for the converter ConverterName):
#
# 1. Look in the current working directory for the template.
#
# 2. Append +.converter_name+ (e.g. +.html+) to the template name and look for the resulting
# file in the current working directory (the form +.convertername+ is deprecated).
#
# 3. Append +.converter_name+ to the template name and look for it in the kramdown data
# directory (the form +.convertername+ is deprecated).
#
# 4. Check if the template name starts with 'string://' and if so, strip this prefix away and
# use the rest as template.
def self.convert(tree, options = {})
converter = new(tree, ::Kramdown::Options.merge(options.merge(tree.options[:options] || {})))
apply_template(converter, '') if !converter.options[:template].empty? && converter.apply_template_before?
result = converter.convert(tree)
result.encode!(tree.options[:encoding]) if result.respond_to?(:encode!) && result.encoding != Encoding::BINARY
result = apply_template(converter, result) if !converter.options[:template].empty? && converter.apply_template_after?
[result, converter.warnings]
end
# Convert the element +el+ and return the resulting object.
#
# This is the only method that has to be implemented by sub-classes!
def convert(el)
raise NotImplementedError
end
# Apply the +template+ using +body+ as the body string.
#
# The template is evaluated using ERB and the body is available in the @body instance variable
# and the converter object in the @converter instance variable.
def self.apply_template(converter, body) # :nodoc:
erb = ERB.new(get_template(converter.options[:template]))
obj = Object.new
obj.instance_variable_set(:@converter, converter)
obj.instance_variable_set(:@body, body)
erb.result(obj.instance_eval{binding})
end
# Return the template specified by +template+.
def self.get_template(template)
#DEPRECATED: use content of #get_template_new in 2.0
format_ext = '.' + self.name.split(/::/).last.downcase
shipped = File.join(::Kramdown.data_dir, template + format_ext)
if File.exist?(template)
File.read(template)
elsif File.exist?(template + format_ext)
File.read(template + format_ext)
elsif File.exist?(shipped)
File.read(shipped)
elsif template.start_with?('string://')
template.sub(/\Astring:\/\//, '')
else
get_template_new(template)
end
end
def self.get_template_new(template) # :nodoc:
format_ext = '.' + ::Kramdown::Utils.snake_case(self.name.split(/::/).last)
shipped = File.join(::Kramdown.data_dir, template + format_ext)
if File.exist?(template)
File.read(template)
elsif File.exist?(template + format_ext)
File.read(template + format_ext)
elsif File.exist?(shipped)
File.read(shipped)
elsif template.start_with?('string://')
template.sub(/\Astring:\/\//, '')
else
raise "The specified template file #{template} does not exist"
end
end
# Add the given warning +text+ to the warning array.
def warning(text)
@warnings << text
end
# Return +true+ if the header element +el+ should be used for the table of contents (as
# specified by the +toc_levels+ option).
def in_toc?(el)
@options[:toc_levels].include?(el.options[:level]) && (el.attr['class'] || '') !~ /\bno_toc\b/
end
# Return the output header level given a level.
#
# Uses the +header_offset+ option for adjusting the header level.
def output_header_level(level)
[[level + @options[:header_offset], 6].min, 1].max
end
# Extract the code block/span language from the attributes.
def extract_code_language(attr)
if attr['class'] && attr['class'] =~ /\blanguage-\S+/
attr['class'].scan(/\blanguage-(\S+)/).first.first
end
end
# See #extract_code_language
#
# *Warning*: This version will modify the given attributes if a language is present.
def extract_code_language!(attr)
lang = extract_code_language(attr)
attr['class'] = attr['class'].sub(/\blanguage-\S+/, '').strip if lang
attr.delete('class') if lang && attr['class'].empty?
lang
end
# Highlight the given +text+ in the language +lang+ with the syntax highlighter configured
# through the option 'syntax_highlighter'.
def highlight_code(text, lang, type, opts = {})
return nil unless @options[:syntax_highlighter]
highlighter = ::Kramdown::Converter.syntax_highlighter(@options[:syntax_highlighter])
if highlighter
highlighter.call(self, text, lang, type, opts)
else
warning("The configured syntax highlighter #{@options[:syntax_highlighter]} is not available.")
nil
end
end
# Format the given math element with the math engine configured through the option
# 'math_engine'.
def format_math(el, opts = {})
return nil unless @options[:math_engine]
engine = ::Kramdown::Converter.math_engine(@options[:math_engine])
if engine
engine.call(self, el, opts)
else
warning("The configured math engine #{@options[:math_engine]} is not available.")
nil
end
end
# Generate an unique alpha-numeric ID from the the string +str+ for use as a header ID.
#
# Uses the option +auto_id_prefix+: the value of this option is prepended to every generated
# ID.
def generate_id(str)
str = ::Kramdown::Utils::Unidecoder.decode(str) if @options[:transliterated_header_ids]
gen_id = basic_generate_id(str)
gen_id = 'section' if gen_id.length == 0
@used_ids ||= {}
if @used_ids.has_key?(gen_id)
gen_id += '-' << (@used_ids[gen_id] += 1).to_s
else
@used_ids[gen_id] = 0
end
@options[:auto_id_prefix] + gen_id
end
# The basic version of the ID generator, without any special provisions for empty or unique
# IDs.
def basic_generate_id(str)
gen_id = str.gsub(/^[^a-zA-Z]+/, '')
gen_id.tr!('^a-zA-Z0-9 -', '')
gen_id.tr!(' ', '-')
gen_id.downcase!
gen_id
end
SMART_QUOTE_INDICES = {:lsquo => 0, :rsquo => 1, :ldquo => 2, :rdquo => 3} # :nodoc:
# Return the entity that represents the given smart_quote element.
def smart_quote_entity(el)
res = @options[:smart_quotes][SMART_QUOTE_INDICES[el.value]]
::Kramdown::Utils::Entities.entity(res)
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/syntax_highlighter.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/syntax_highlighter.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Converter
# == Container for Syntax Highlighters
#
# This module serves as container for the syntax highlighters that can be used together with
# kramdown.
#
# A syntax highlighter should not store any data itself but should use the provided converter
# object to do so (See Kramdown::Converter::Base#data).
#
# == Implementing a Syntax Highlighter
#
# Implementing a new syntax highlighter is easy because it is just an object that needs to
# respond to #call.
#
# The method #call needs to take the following arguments:
#
# converter:: This argument contains the converter object that calls the syntax highlighter. It
# can be used, for example, to store data in Kramdown::Converter::Base#data for one
# conversion run.
#
# text:: The raw text that should be highlighted.
#
# lang:: The language that the text should be highlighted for (e.g. ruby, python, ...).
#
# type:: The type of text, either :span for span-level code or :block for a codeblock.
#
# opts:: A Hash with options that may be passed from the converter.
#
# The return value of the method should be the highlighted text, suitable for the given
# converter (e.g. HTML for the HTML converter).
#
# == Special Implementation Details
#
# HTML converter:: If the syntax highlighter is used with a HTML converter, it should return
# :block type text correctly wrapped (i.e. normally inside a pre-tag, but may
# also be a table-tag or just a div-tag) but :span type text *without* a
# code-tag!
#
# Also, a syntax highlighter should store the default highlighting language for
# the invocation in the +opts+ hash under the key :default_lang.
module SyntaxHighlighter
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/toc.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/toc.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/converter'
module Kramdown
module Converter
# Converts a Kramdown::Document to an element tree that represents the table of contents.
#
# The returned tree consists of Element objects of type :toc where the root element is just used
# as container object. Each :toc element contains as value the wrapped :header element and under
# the attribute key :id the header ID that should be used (note that this ID may not exist in
# the wrapped element).
#
# Since the TOC tree consists of special :toc elements, one cannot directly feed this tree to
# other converters!
class Toc < Base
def initialize(root, options)
super
@toc = Element.new(:toc)
@stack = []
@options[:template] = ''
end
def convert(el)
if el.type == :header && in_toc?(el)
attr = el.attr.dup
attr['id'] = generate_id(el.options[:raw_text]) if @options[:auto_ids] && !attr['id']
add_to_toc(el, attr['id']) if attr['id']
else
el.children.each {|child| convert(child)}
end
@toc
end
private
def add_to_toc(el, id)
toc_element = Element.new(:toc, el, :id => id)
success = false
while !success
if @stack.empty?
@toc.children << toc_element
@stack << toc_element
success = true
elsif @stack.last.value.options[:level] < el.options[:level]
@stack.last.children << toc_element
@stack << toc_element
success = true
else
@stack.pop
end
end
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/man.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/man.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/converter'
module Kramdown
module Converter
# Converts a Kramdown::Document to a manpage in groff format. See man(7), groff_man(7) and
# man-pages(7) for information regarding the output.
class Man < Base
def convert(el, opts = {:indent => 0, :result => ''}) #:nodoc:
send("convert_#{el.type}", el, opts)
end
private
def inner(el, opts, use = :all)
arr = el.children.reject {|e| e.type == :blank}
arr.each_with_index do |inner_el, index|
next if use == :rest && index == 0
break if use == :first && index > 0
options = opts.dup
options[:parent] = el
options[:index] = index
options[:prev] = (index == 0 ? nil : arr[index - 1])
options[:next] = (index == arr.length - 1 ? nil : arr[index + 1])
convert(inner_el, options)
end
end
def convert_root(el, opts)
@title_done = false
opts[:result] = ".\\\" generated by kramdown\n"
inner(el, opts)
opts[:result]
end
def convert_blank(*)
end
alias :convert_hr :convert_blank
alias :convert_xml_pi :convert_blank
def convert_p(el, opts)
if (opts[:index] != 0 && opts[:prev].type != :header) ||
(opts[:parent].type == :blockquote && opts[:index] == 0)
opts[:result] << macro("P")
end
inner(el, opts)
newline(opts[:result])
end
def convert_header(el, opts)
return unless opts[:parent].type == :root
case el.options[:level]
when 1
unless @title_done
@title_done = true
data = el.options[:raw_text].scan(/([^(]+)\s*\((\d\w*)\)(?:\s*-+\s*(.*))?/).first ||
el.options[:raw_text].scan(/([^\s]+)\s*(?:-*\s+)?()(.*)/).first
return unless data && data[0]
name = data[0]
section = (data[1].to_s.empty? ? el.attr['data-section'] || '7' : data[1])
description = (data[2].to_s.empty? ? nil : " - #{data[2]}")
date = el.attr['data-date'] ? quote(el.attr['data-date']) : nil
extra = (el.attr['data-extra'] ? quote(escape(el.attr['data-extra'].to_s)) : nil)
opts[:result] << macro("TH", quote(escape(name.upcase)), quote(section), date, extra)
if description
opts[:result] << macro("SH", "NAME") << escape("#{name}#{description}") << "\n"
end
end
when 2
opts[:result] << macro("SH", quote(escape(el.options[:raw_text])))
when 3
opts[:result] << macro("SS", quote(escape(el.options[:raw_text])))
else
warning("Header levels greater than three are not supported")
end
end
def convert_codeblock(el, opts)
opts[:result] << macro("sp") << macro("RS", 4) << macro("EX")
opts[:result] << newline(escape(el.value, true))
opts[:result] << macro("EE") << macro("RE")
end
def convert_blockquote(el, opts)
opts[:result] << macro("RS")
inner(el, opts)
opts[:result] << macro("RE")
end
def convert_ul(el, opts)
compact = (el.attr['class'] =~ /\bcompact\b/)
opts[:result] << macro("sp") << macro("PD", 0) if compact
inner(el, opts)
opts[:result] << macro("PD") if compact
end
alias :convert_dl :convert_ul
alias :convert_ol :convert_ul
def convert_li(el, opts)
sym = (opts[:parent].type == :ul ? '\(bu' : "#{opts[:index] + 1}.")
opts[:result] << macro("IP", sym, 4)
inner(el, opts, :first)
if el.children.size > 1
opts[:result] << macro("RS")
inner(el, opts, :rest)
opts[:result] << macro("RE")
end
end
def convert_dt(el, opts)
opts[:result] << macro(opts[:prev] && opts[:prev].type == :dt ? "TQ" : "TP")
inner(el, opts)
opts[:result] << "\n"
end
def convert_dd(el, opts)
inner(el, opts, :first)
if el.children.size > 1
opts[:result] << macro("RS")
inner(el, opts, :rest)
opts[:result] << macro("RE")
end
opts[:result] << macro("sp") if opts[:next] && opts[:next].type == :dd
end
TABLE_CELL_ALIGNMENT = {:left => 'l', :center => 'c', :right => 'r', :default => 'l'}
def convert_table(el, opts)
opts[:alignment] = el.options[:alignment].map {|a| TABLE_CELL_ALIGNMENT[a]}
table_options = ["box"]
table_options << "center" if el.attr['class'] =~ /\bcenter\b/
opts[:result] << macro("TS") << "#{table_options.join(" ")} ;\n"
inner(el, opts)
opts[:result] << macro("TE") << macro("sp")
end
def convert_thead(el, opts)
opts[:result] << opts[:alignment].map {|a| "#{a}b"}.join(' ') << " .\n"
inner(el, opts)
opts[:result] << "=\n"
end
def convert_tbody(el, opts)
opts[:result] << ".T&\n" if opts[:index] != 0
opts[:result] << opts[:alignment].join(' ') << " .\n"
inner(el, opts)
opts[:result] << (opts[:next].type == :tfoot ? "=\n" : "_\n") if opts[:next]
end
def convert_tfoot(el, opts)
inner(el, opts)
end
def convert_tr(el, opts)
inner(el, opts)
opts[:result] << "\n"
end
def convert_td(el, opts)
result = opts[:result]
opts[:result] = ''
inner(el, opts)
if opts[:result] =~ /\n/
warning("Table cells using links are not supported")
result << "\t"
else
result << opts[:result] << "\t"
end
end
def convert_html_element(*)
warning("HTML elements are not supported")
end
def convert_xml_comment(el, opts)
newline(opts[:result]) << ".\"#{escape(el.value, true).rstrip.gsub(/\n/, "\n.\"")}\n"
end
alias :convert_comment :convert_xml_comment
def convert_a(el, opts)
if el.children.size == 1 && el.children[0].type == :text &&
el.attr['href'] == el.children[0].value
newline(opts[:result]) << macro("UR", escape(el.attr['href'])) << macro("UE")
elsif el.attr['href'].start_with?('mailto:')
newline(opts[:result]) << macro("MT", escape(el.attr['href'].sub(/^mailto:/, ''))) <<
macro("UE")
else
newline(opts[:result]) << macro("UR", escape(el.attr['href']))
inner(el, opts)
newline(opts[:result]) << macro("UE")
end
end
def convert_img(el, opts)
warning("Images are not supported")
end
def convert_em(el, opts)
opts[:result] << '\fI'
inner(el, opts)
opts[:result] << '\fP'
end
def convert_strong(el, opts)
opts[:result] << '\fB'
inner(el, opts)
opts[:result] << '\fP'
end
def convert_codespan(el, opts)
opts[:result] << "\\fB#{escape(el.value)}\\fP"
end
def convert_br(el, opts)
newline(opts[:result]) << macro("br")
end
def convert_abbreviation(el, opts)
opts[:result] << escape(el.value)
end
def convert_math(el, opts)
if el.options[:category] == :block
convert_codeblock(el, opts)
else
convert_codespan(el, opts)
end
end
def convert_footnote(*)
warning("Footnotes are not supported")
end
def convert_raw(*)
warning("Raw content is not supported")
end
def convert_text(el, opts)
text = escape(el.value)
text.lstrip! if opts[:result][-1] == ?\n
opts[:result] << text
end
def convert_entity(el, opts)
opts[:result] << unicode_char(el.value.code_point)
end
def convert_smart_quote(el, opts)
opts[:result] << unicode_char(::Kramdown::Utils::Entities.entity(el.value.to_s).code_point)
end
TYPOGRAPHIC_SYMS_MAP = {
:mdash => '\(em', :ndash => '\(em', :hellip => '\.\.\.',
:laquo_space => '\[Fo]', :raquo_space => '\[Fc]', :laquo => '\[Fo]', :raquo => '\[Fc]'
}
def convert_typographic_sym(el, opts)
opts[:result] << TYPOGRAPHIC_SYMS_MAP[el.value]
end
def macro(name, *args)
".#{[name, *args].compact.join(' ')}\n"
end
def newline(text)
text << "\n" unless text[-1] == ?\n
text
end
def quote(text)
"\"#{text.gsub(/"/, '\\"')}\""
end
def escape(text, preserve_whitespace = false)
text = (preserve_whitespace ? text.dup : text.gsub(/\s+/, ' '))
text.gsub!('\\', "\\e")
text.gsub!(/^\./, '\\\\&.')
text.gsub!(/[.'-]/) {|m| "\\#{m}"}
text
end
def unicode_char(codepoint)
"\\[u#{codepoint.to_s(16).rjust(4, '0')}]"
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/pdf.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/pdf.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'prawn'
require 'prawn/table'
require 'kramdown/converter'
require 'kramdown/utils'
require 'open-uri'
module Kramdown
module Converter
# Converts an element tree to a PDF using the prawn PDF library.
#
# This basic version provides a nice starting point for customizations but can also be used
# directly.
#
# There can be the following two methods for each element type: render_TYPE(el, opts) and
# TYPE_options(el, opts) where +el+ is a kramdown element and +opts+ an hash with rendering
# options.
#
# The render_TYPE(el, opts) is used for rendering the specific element. If the element is a span
# element, it should return a hash or an array of hashes that can be used by the #formatted_text
# method of Prawn::Document. This method can then be used in block elements to actually render
# the span elements.
#
# The rendering options are passed from the parent to its child elements. This allows one to
# define general options at the top of the tree (the root element) that can later be changed or
# amended.
#
#
# Currently supports the conversion of all elements except those of the following types:
#
# :html_element, :img, :footnote
#
#
class Pdf < Base
include Prawn::Measurements
def initialize(root, options)
super
@stack = []
@dests = {}
end
# PDF templates are applied before conversion. They should contain code to augment the
# converter object (i.e. to override the methods).
def apply_template_before?
true
end
# Returns +false+.
def apply_template_after?
false
end
DISPATCHER_RENDER = Hash.new {|h,k| h[k] = "render_#{k}"} #:nodoc:
DISPATCHER_OPTIONS = Hash.new {|h,k| h[k] = "#{k}_options"} #:nodoc:
# Invoke the special rendering method for the given element +el+.
#
# A PDF destination is also added at the current location if th element has an ID or if the
# element is of type :header and the :auto_ids option is set.
def convert(el, opts = {})
id = el.attr['id']
id = generate_id(el.options[:raw_text]) if !id && @options[:auto_ids] && el.type == :header
if !id.to_s.empty? && !@dests.has_key?(id)
@pdf.add_dest(id, @pdf.dest_xyz(0, @pdf.y))
@dests[id] = @pdf.dest_xyz(0, @pdf.y)
end
send(DISPATCHER_RENDER[el.type], el, opts)
end
protected
# Render the children of this element with the given options and return the results as array.
#
# Each time a child is rendered, the +TYPE_options+ method is invoked (if it exists) to get
# the specific options for the element with which the given options are updated.
def inner(el, opts)
@stack.push([el, opts])
result = el.children.map do |inner_el|
options = opts.dup
options.update(send(DISPATCHER_OPTIONS[inner_el.type], inner_el, options))
convert(inner_el, options)
end.flatten.compact
@stack.pop
result
end
# ----------------------------
# :section: Element rendering methods
# ----------------------------
def root_options(root, opts)
{:font => 'Times-Roman', :size => 12, :leading => 2}
end
def render_root(root, opts)
@pdf = setup_document(root)
inner(root, root_options(root, opts))
create_outline(root)
finish_document(root)
@pdf.render
end
def header_options(el, opts)
size = opts[:size] * 1.15**(6 - el.options[:level])
{
:font => "Helvetica", :styles => (opts[:styles] || []) + [:bold],
:size => size, :bottom_padding => opts[:size], :top_padding => opts[:size]
}
end
def render_header(el, opts)
render_padded_and_formatted_text(el, opts)
end
def p_options(el, opts)
bpad = (el.options[:transparent] ? opts[:leading] : opts[:size])
{:align => :justify, :bottom_padding => bpad}
end
def render_p(el, opts)
if el.children.size == 1 && el.children.first.type == :img
render_standalone_image(el, opts)
else
render_padded_and_formatted_text(el, opts)
end
end
def render_standalone_image(el, opts)
img = el.children.first
line = img.options[:location]
if img.attr['src'].empty?
warning("Rendering an image without a source is not possible#{line ? " (line #{line})" : ''}")
return nil
elsif img.attr['src'] !~ /\.jpe?g$|\.png$/
warning("Cannot render images other than JPEG or PNG, got #{img.attr['src']}#{line ? " on line #{line}" : ''}")
return nil
end
img_dirs = (@options[:image_directories] || ['.']).dup
begin
img_path = File.join(img_dirs.shift, img.attr['src'])
image_obj, image_info = @pdf.build_image_object(open(img_path))
rescue
img_dirs.empty? ? raise : retry
end
options = {:position => :center}
if img.attr['height'] && img.attr['height'] =~ /px$/
options[:height] = img.attr['height'].to_i / (@options[:image_dpi] || 150.0) * 72
elsif img.attr['width'] && img.attr['width'] =~ /px$/
options[:width] = img.attr['width'].to_i / (@options[:image_dpi] || 150.0) * 72
else
options[:scale] =[(@pdf.bounds.width - mm2pt(20)) / image_info.width.to_f, 1].min
end
if img.attr['class'] =~ /\bright\b/
options[:position] = :right
@pdf.float { @pdf.embed_image(image_obj, image_info, options) }
else
with_block_padding(el, opts) do
@pdf.embed_image(image_obj, image_info, options)
end
end
end
def blockquote_options(el, opts)
{:styles => [:italic]}
end
def render_blockquote(el, opts)
@pdf.indent(mm2pt(10), mm2pt(10)) { inner(el, opts) }
end
def ul_options(el, opts)
{:bottom_padding => opts[:size]}
end
def render_ul(el, opts)
with_block_padding(el, opts) do
el.children.each do |li|
@pdf.float { @pdf.formatted_text([text_hash("•", opts)]) }
@pdf.indent(mm2pt(6)) { convert(li, opts) }
end
end
end
def ol_options(el, opts)
{:bottom_padding => opts[:size]}
end
def render_ol(el, opts)
with_block_padding(el, opts) do
el.children.each_with_index do |li, index|
@pdf.float { @pdf.formatted_text([text_hash("#{index+1}.", opts)]) }
@pdf.indent(mm2pt(6)) { convert(li, opts) }
end
end
end
def li_options(el, opts)
{}
end
def render_li(el, opts)
inner(el, opts)
end
def dl_options(el, opts)
{}
end
def render_dl(el, opts)
inner(el, opts)
end
def dt_options(el, opts)
{:styles => (opts[:styles] || []) + [:bold], :bottom_padding => 0}
end
def render_dt(el, opts)
render_padded_and_formatted_text(el, opts)
end
def dd_options(el, opts)
{}
end
def render_dd(el, opts)
@pdf.indent(mm2pt(10)) { inner(el, opts) }
end
def math_options(el, opts)
{}
end
def render_math(el, opts)
if el.options[:category] == :block
@pdf.formatted_text([{:text => el.value}], block_hash(opts))
else
{:text => el.value}
end
end
def hr_options(el, opts)
{:top_padding => opts[:size], :bottom_padding => opts[:size]}
end
def render_hr(el, opts)
with_block_padding(el, opts) do
@pdf.stroke_horizontal_line(@pdf.bounds.left + mm2pt(5), @pdf.bounds.right - mm2pt(5))
end
end
def codeblock_options(el, opts)
{
:font => 'Courier', :color => '880000',
:bottom_padding => opts[:size]
}
end
def render_codeblock(el, opts)
with_block_padding(el, opts) do
@pdf.formatted_text([text_hash(el.value, opts, false)], block_hash(opts))
end
end
def table_options(el, opts)
{:bottom_padding => opts[:size]}
end
def render_table(el, opts)
data = []
el.children.each do |container|
container.children.each do |row|
data << []
row.children.each do |cell|
if cell.children.any? {|child| child.options[:category] == :block}
line = el.options[:location]
warning("Can't render tables with cells containing block elements#{line ? " (line #{line})" : ''}")
return
end
cell_data = inner(cell, opts)
data.last << cell_data.map {|c| c[:text]}.join('')
end
end
end
with_block_padding(el, opts) do
@pdf.table(data, :width => @pdf.bounds.right) do
el.options[:alignment].each_with_index do |alignment, index|
columns(index).align = alignment unless alignment == :default
end
end
end
end
def text_options(el, opts)
{}
end
def render_text(el, opts)
text_hash(el.value.to_s, opts)
end
def em_options(el, opts)
if opts[:styles] && opts[:styles].include?(:italic)
{:styles => opts[:styles].reject {|i| i == :italic}}
else
{:styles => (opts[:styles] || []) << :italic}
end
end
def strong_options(el, opts)
{:styles => (opts[:styles] || []) + [:bold]}
end
def a_options(el, opts)
hash = {:color => '000088'}
if el.attr['href'].start_with?('#')
hash[:anchor] = el.attr['href'].sub(/\A#/, '')
else
hash[:link] = el.attr['href']
end
hash
end
def render_em(el, opts)
inner(el, opts)
end
alias_method :render_strong, :render_em
alias_method :render_a, :render_em
def codespan_options(el, opts)
{:font => 'Courier', :color => '880000'}
end
def render_codespan(el, opts)
text_hash(el.value, opts)
end
def br_options(el, opts)
{}
end
def render_br(el, opts)
text_hash("\n", opts, false)
end
def smart_quote_options(el, opts)
{}
end
def render_smart_quote(el, opts)
text_hash(smart_quote_entity(el).char, opts)
end
def typographic_sym_options(el, opts)
{}
end
def render_typographic_sym(el, opts)
str = if el.value == :laquo_space
::Kramdown::Utils::Entities.entity('laquo').char +
::Kramdown::Utils::Entities.entity('nbsp').char
elsif el.value == :raquo_space
::Kramdown::Utils::Entities.entity('raquo').char +
::Kramdown::Utils::Entities.entity('nbsp').char
else
::Kramdown::Utils::Entities.entity(el.value.to_s).char
end
text_hash(str, opts)
end
def entity_options(el, opts)
{}
end
def render_entity(el, opts)
text_hash(el.value.char, opts)
end
def abbreviation_options(el, opts)
{}
end
def render_abbreviation(el, opts)
text_hash(el.value, opts)
end
def img_options(el, opts)
{}
end
def render_img(el, *args) #:nodoc:
line = el.options[:location]
warning("Rendering span images is not supported for PDF converter#{line ? " (line #{line})" : ''}")
nil
end
def xml_comment_options(el, opts) #:nodoc:
{}
end
alias_method :xml_pi_options, :xml_comment_options
alias_method :comment_options, :xml_comment_options
alias_method :blank_options, :xml_comment_options
alias_method :footnote_options, :xml_comment_options
alias_method :raw_options, :xml_comment_options
alias_method :html_element_options, :xml_comment_options
def render_xml_comment(el, opts) #:nodoc:
# noop
end
alias_method :render_xml_pi, :render_xml_comment
alias_method :render_comment, :render_xml_comment
alias_method :render_blank, :render_xml_comment
def render_footnote(el, *args) #:nodoc:
line = el.options[:location]
warning("Rendering #{el.type} not supported for PDF converter#{line ? " (line #{line})" : ''}")
nil
end
alias_method :render_raw, :render_footnote
alias_method :render_html_element, :render_footnote
# ----------------------------
# :section: Organizational methods
#
# These methods are used, for example, to up the needed Prawn::Document instance or to create
# a PDF outline.
# ----------------------------
# This module gets mixed into the Prawn::Document instance.
module PrawnDocumentExtension
# Extension for the formatted box class to recognize images and move text around them.
module CustomBox
def available_width
return super unless @document.respond_to?(:converter) && @document.converter
@document.image_floats.each do |pn, x, y, w, h|
next if @document.page_number != pn
if @at[1] + @baseline_y <= y - @document.bounds.absolute_bottom &&
(@at[1] + @baseline_y + @arranger.max_line_height + @leading >= y - h - @document.bounds.absolute_bottom)
return @width - w
end
end
return super
end
end
Prawn::Text::Formatted::Box.extensions << CustomBox
# Access the converter instance from within Prawn
attr_accessor :converter
def image_floats
@image_floats ||= []
end
# Override image embedding method for adding image positions to #image_floats.
def embed_image(pdf_obj, info, options)
# find where the image will be placed and how big it will be
w,h = info.calc_image_dimensions(options)
if options[:at]
x,y = map_to_absolute(options[:at])
else
x,y = image_position(w,h,options)
move_text_position h
end
#--> This part is new
if options[:position] == :right
image_floats << [page_number, x - 15, y, w + 15, h + 15]
end
# add a reference to the image object to the current page
# resource list and give it a label
label = "I#{next_image_id}"
state.page.xobjects.merge!(label => pdf_obj)
# add the image to the current page
instruct = "\nq\n%.3f 0 0 %.3f %.3f %.3f cm\n/%s Do\nQ"
add_content instruct % [ w, h, x, y - h, label ]
end
end
# Return a hash with options that are suitable for Prawn::Document.new.
#
# Used in #setup_document.
def document_options(root)
{
:page_size => 'A4', :page_layout => :portrait, :margin => mm2pt(20),
:info => {
:Creator => 'kramdown PDF converter',
:CreationDate => Time.now
},
:compress => true, :optimize_objects => true
}
end
# Create a Prawn::Document object and return it.
#
# Can be used to define repeatable content or register fonts.
#
# Used in #render_root.
def setup_document(root)
doc = Prawn::Document.new(document_options(root))
doc.extend(PrawnDocumentExtension)
doc.converter = self
doc
end
#
#
# Used in #render_root.
def finish_document(root)
# no op
end
# Create the PDF outline from the header elements in the TOC.
def create_outline(root)
toc = ::Kramdown::Converter::Toc.convert(root).first
text_of_header = lambda do |el|
if el.type == :text
el.value
else
el.children.map {|c| text_of_header.call(c)}.join('')
end
end
add_section = lambda do |item, parent|
text = text_of_header.call(item.value)
destination = @dests[item.attr[:id]]
if !parent
@pdf.outline.page(:title => text, :destination => destination)
else
@pdf.outline.add_subsection_to(parent) do
@pdf.outline.page(:title => text, :destination => destination)
end
end
item.children.each {|c| add_section.call(c, text)}
end
toc.children.each do |item|
add_section.call(item, nil)
end
end
# ----------------------------
# :section: Helper methods
# ----------------------------
# Move the prawn document cursor down before and/or after yielding the given block.
#
# The :top_padding and :bottom_padding options are used for determinig the padding amount.
def with_block_padding(el, opts)
@pdf.move_down(opts[:top_padding]) if opts.has_key?(:top_padding)
yield
@pdf.move_down(opts[:bottom_padding]) if opts.has_key?(:bottom_padding)
end
# Render the children of the given element as formatted text and respect the top/bottom
# padding (see #with_block_padding).
def render_padded_and_formatted_text(el, opts)
with_block_padding(el, opts) { @pdf.formatted_text(inner(el, opts), block_hash(opts)) }
end
# Helper function that returns a hash with valid "formatted text" options.
#
# The +text+ parameter is used as value for the :text key and if +squeeze_whitespace+ is
# +true+, all whitespace is converted into spaces.
def text_hash(text, opts, squeeze_whitespace = true)
text = text.gsub(/\s+/, ' ') if squeeze_whitespace
hash = {:text => text}
[:styles, :size, :character_spacing, :font, :color, :link,
:anchor, :draw_text_callback, :callback].each do |key|
hash[key] = opts[key] if opts.has_key?(key)
end
hash
end
# Helper function that returns a hash with valid options for the prawn #text_box extracted
# from the given options.
def block_hash(opts)
hash = {}
[:align, :valign, :mode, :final_gap, :leading, :fallback_fonts,
:direction, :indent_paragraphs].each do |key|
hash[key] = opts[key] if opts.has_key?(key)
end
hash
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/remove_html_tags.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/remove_html_tags.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/converter'
module Kramdown
module Converter
# Removes all block (and optionally span) level HTML tags from the element tree.
#
# This converter can be used on parsed HTML documents to get an element tree that will only
# contain native kramdown elements.
#
# *Note* that the returned element tree may not be fully conformant (i.e. the content models of
# *some elements may be violated)!
#
# This converter modifies the given tree in-place and returns it.
class RemoveHtmlTags < Base
def initialize(root, options)
super
@options[:template] = ''
end
def convert(el)
real_el, el = el, el.value if el.type == :footnote
children = el.children.dup
index = 0
while index < children.length
if [:xml_pi].include?(children[index].type) ||
(children[index].type == :html_element && %w[style script].include?(children[index].value))
children[index..index] = []
elsif children[index].type == :html_element &&
((@options[:remove_block_html_tags] && children[index].options[:category] == :block) ||
(@options[:remove_span_html_tags] && children[index].options[:category] == :span))
children[index..index] = children[index].children
else
convert(children[index])
index += 1
end
end
el.children = children
real_el || el
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/html.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/html.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser'
require 'kramdown/converter'
require 'kramdown/utils'
module Kramdown
module Converter
# Converts a Kramdown::Document to HTML.
#
# You can customize the HTML converter by sub-classing it and overriding the +convert_NAME+
# methods. Each such method takes the following parameters:
#
# [+el+] The element of type +NAME+ to be converted.
#
# [+indent+] A number representing the current amount of spaces for indent (only used for
# block-level elements).
#
# The return value of such a method has to be a string containing the element +el+ formatted as
# HTML element.
class Html < Base
include ::Kramdown::Utils::Html
include ::Kramdown::Parser::Html::Constants
# The amount of indentation used when nesting HTML tags.
attr_accessor :indent
# Initialize the HTML converter with the given Kramdown document +doc+.
def initialize(root, options)
super
@footnote_counter = @footnote_start = @options[:footnote_nr]
@footnotes = []
@footnotes_by_name = {}
@footnote_location = nil
@toc = []
@toc_code = nil
@indent = 2
@stack = []
end
# The mapping of element type to conversion method.
DISPATCHER = Hash.new {|h,k| h[k] = "convert_#{k}"}
# Dispatch the conversion of the element +el+ to a +convert_TYPE+ method using the +type+ of
# the element.
def convert(el, indent = -@indent)
send(DISPATCHER[el.type], el, indent)
end
# Return the converted content of the children of +el+ as a string. The parameter +indent+ has
# to be the amount of indentation used for the element +el+.
#
# Pushes +el+ onto the @stack before converting the child elements and pops it from the stack
# afterwards.
def inner(el, indent)
result = ''
indent += @indent
@stack.push(el)
el.children.each do |inner_el|
result << send(DISPATCHER[inner_el.type], inner_el, indent)
end
@stack.pop
result
end
def convert_blank(el, indent)
"\n"
end
def convert_text(el, indent)
escape_html(el.value, :text)
end
def convert_p(el, indent)
if el.options[:transparent]
inner(el, indent)
else
format_as_block_html(el.type, el.attr, inner(el, indent), indent)
end
end
def convert_codeblock(el, indent)
attr = el.attr.dup
lang = extract_code_language!(attr)
hl_opts = {}
highlighted_code = highlight_code(el.value, el.options[:lang] || lang, :block, hl_opts)
if highlighted_code
add_syntax_highlighter_to_class_attr(attr, lang || hl_opts[:default_lang])
"#{' '*indent}<div#{html_attributes(attr)}>#{highlighted_code}#{' '*indent}</div>\n"
else
result = escape_html(el.value)
result.chomp!
if el.attr['class'].to_s =~ /\bshow-whitespaces\b/
result.gsub!(/(?:(^[ \t]+)|([ \t]+$)|([ \t]+))/) do |m|
suffix = ($1 ? '-l' : ($2 ? '-r' : ''))
m.scan(/./).map do |c|
case c
when "\t" then "<span class=\"ws-tab#{suffix}\">\t</span>"
when " " then "<span class=\"ws-space#{suffix}\">⋅</span>"
end
end.join('')
end
end
code_attr = {}
code_attr['class'] = "language-#{lang}" if lang
"#{' '*indent}<pre#{html_attributes(attr)}><code#{html_attributes(code_attr)}>#{result}\n</code></pre>\n"
end
end
def convert_blockquote(el, indent)
format_as_indented_block_html(el.type, el.attr, inner(el, indent), indent)
end
def convert_header(el, indent)
attr = el.attr.dup
if @options[:auto_ids] && !attr['id']
attr['id'] = generate_id(el.options[:raw_text])
end
@toc << [el.options[:level], attr['id'], el.children] if attr['id'] && in_toc?(el)
level = output_header_level(el.options[:level])
format_as_block_html("h#{level}", attr, inner(el, indent), indent)
end
def convert_hr(el, indent)
"#{' '*indent}<hr#{html_attributes(el.attr)} />\n"
end
def convert_ul(el, indent)
if !@toc_code && (el.options[:ial][:refs].include?('toc') rescue nil)
@toc_code = [el.type, el.attr, (0..128).to_a.map{|a| rand(36).to_s(36)}.join]
@toc_code.last
elsif !@footnote_location && el.options[:ial] && (el.options[:ial][:refs] || []).include?('footnotes')
@footnote_location = (0..128).to_a.map{|a| rand(36).to_s(36)}.join
else
format_as_indented_block_html(el.type, el.attr, inner(el, indent), indent)
end
end
alias :convert_ol :convert_ul
def convert_dl(el, indent)
format_as_indented_block_html(el.type, el.attr, inner(el, indent), indent)
end
def convert_li(el, indent)
output = ' '*indent << "<#{el.type}" << html_attributes(el.attr) << ">"
res = inner(el, indent)
if el.children.empty? || (el.children.first.type == :p && el.children.first.options[:transparent])
output << res << (res =~ /\n\Z/ ? ' '*indent : '')
else
output << "\n" << res << ' '*indent
end
output << "</#{el.type}>\n"
end
alias :convert_dd :convert_li
def convert_dt(el, indent)
attr = el.attr.dup
@stack.last.options[:ial][:refs].each do |ref|
if ref =~ /\Aauto_ids(?:-([\w-]+))?/
attr['id'] = ($1 ? $1 : '') << basic_generate_id(el.options[:raw_text])
break
end
end if !attr['id'] && @stack.last.options[:ial] && @stack.last.options[:ial][:refs]
format_as_block_html(el.type, attr, inner(el, indent), indent)
end
def convert_html_element(el, indent)
res = inner(el, indent)
if el.options[:category] == :span
"<#{el.value}#{html_attributes(el.attr)}" << (res.empty? && HTML_ELEMENTS_WITHOUT_BODY.include?(el.value) ? " />" : ">#{res}</#{el.value}>")
else
output = ''
output << ' '*indent if @stack.last.type != :html_element || @stack.last.options[:content_model] != :raw
output << "<#{el.value}#{html_attributes(el.attr)}"
if el.options[:is_closed] && el.options[:content_model] == :raw
output << " />"
elsif !res.empty? && el.options[:content_model] != :block
output << ">#{res}</#{el.value}>"
elsif !res.empty?
output << ">\n#{res.chomp}\n" << ' '*indent << "</#{el.value}>"
elsif HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)
output << " />"
else
output << "></#{el.value}>"
end
output << "\n" if @stack.last.type != :html_element || @stack.last.options[:content_model] != :raw
output
end
end
def convert_xml_comment(el, indent)
if el.options[:category] == :block && (@stack.last.type != :html_element || @stack.last.options[:content_model] != :raw)
' '*indent << el.value << "\n"
else
el.value
end
end
alias :convert_xml_pi :convert_xml_comment
def convert_table(el, indent)
format_as_indented_block_html(el.type, el.attr, inner(el, indent), indent)
end
alias :convert_thead :convert_table
alias :convert_tbody :convert_table
alias :convert_tfoot :convert_table
alias :convert_tr :convert_table
ENTITY_NBSP = ::Kramdown::Utils::Entities.entity('nbsp') # :nodoc:
def convert_td(el, indent)
res = inner(el, indent)
type = (@stack[-2].type == :thead ? :th : :td)
attr = el.attr
alignment = @stack[-3].options[:alignment][@stack.last.children.index(el)]
if alignment != :default
attr = el.attr.dup
attr['style'] = (attr.has_key?('style') ? "#{attr['style']}; ": '') << "text-align: #{alignment}"
end
format_as_block_html(type, attr, res.empty? ? entity_to_str(ENTITY_NBSP) : res, indent)
end
def convert_comment(el, indent)
if el.options[:category] == :block
"#{' '*indent}<!-- #{el.value} -->\n"
else
"<!-- #{el.value} -->"
end
end
def convert_br(el, indent)
"<br />"
end
def convert_a(el, indent)
format_as_span_html(el.type, el.attr, inner(el, indent))
end
def convert_img(el, indent)
"<img#{html_attributes(el.attr)} />"
end
def convert_codespan(el, indent)
attr = el.attr.dup
lang = extract_code_language(attr)
hl_opts = {}
result = highlight_code(el.value, lang, :span, hl_opts)
if result
add_syntax_highlighter_to_class_attr(attr, hl_opts[:default_lang])
else
result = escape_html(el.value)
end
format_as_span_html('code', attr, result)
end
def convert_footnote(el, indent)
repeat = ''
if (footnote = @footnotes_by_name[el.options[:name]])
number = footnote[2]
repeat = ":#{footnote[3] += 1}"
else
number = @footnote_counter
@footnote_counter += 1
@footnotes << [el.options[:name], el.value, number, 0]
@footnotes_by_name[el.options[:name]] = @footnotes.last
end
"<sup id=\"fnref:#{el.options[:name]}#{repeat}\"><a href=\"#fn:#{el.options[:name]}\" class=\"footnote\">#{number}</a></sup>"
end
def convert_raw(el, indent)
if !el.options[:type] || el.options[:type].empty? || el.options[:type].include?('html')
el.value + (el.options[:category] == :block ? "\n" : '')
else
''
end
end
def convert_em(el, indent)
format_as_span_html(el.type, el.attr, inner(el, indent))
end
alias :convert_strong :convert_em
def convert_entity(el, indent)
entity_to_str(el.value, el.options[:original])
end
TYPOGRAPHIC_SYMS = {
:mdash => [::Kramdown::Utils::Entities.entity('mdash')],
:ndash => [::Kramdown::Utils::Entities.entity('ndash')],
:hellip => [::Kramdown::Utils::Entities.entity('hellip')],
:laquo_space => [::Kramdown::Utils::Entities.entity('laquo'), ::Kramdown::Utils::Entities.entity('nbsp')],
:raquo_space => [::Kramdown::Utils::Entities.entity('nbsp'), ::Kramdown::Utils::Entities.entity('raquo')],
:laquo => [::Kramdown::Utils::Entities.entity('laquo')],
:raquo => [::Kramdown::Utils::Entities.entity('raquo')]
} # :nodoc:
def convert_typographic_sym(el, indent)
if (result = @options[:typographic_symbols][el.value])
escape_html(result, :text)
else
TYPOGRAPHIC_SYMS[el.value].map {|e| entity_to_str(e)}.join('')
end
end
def convert_smart_quote(el, indent)
entity_to_str(smart_quote_entity(el))
end
def convert_math(el, indent)
if (result = format_math(el, :indent => indent))
result
else
attr = el.attr.dup
(attr['class'] = (attr['class'] || '') << " kdmath").lstrip!
if el.options[:category] == :block
format_as_block_html('div', attr, "$$\n#{el.value}\n$$", indent)
else
format_as_span_html('span', attr, "$#{el.value}$")
end
end
end
def convert_abbreviation(el, indent)
title = @root.options[:abbrev_defs][el.value]
attr = @root.options[:abbrev_attr][el.value].dup
attr['title'] = title unless title.empty?
format_as_span_html("abbr", attr, el.value)
end
def convert_root(el, indent)
result = inner(el, indent)
if @footnote_location
result.sub!(/#{@footnote_location}/, footnote_content.gsub(/\\/, "\\\\\\\\"))
else
result << footnote_content
end
if @toc_code
toc_tree = generate_toc_tree(@toc, @toc_code[0], @toc_code[1] || {})
text = if toc_tree.children.size > 0
convert(toc_tree, 0)
else
''
end
result.sub!(/#{@toc_code.last}/, text.gsub(/\\/, "\\\\\\\\"))
end
result
end
# Format the given element as span HTML.
def format_as_span_html(name, attr, body)
"<#{name}#{html_attributes(attr)}>#{body}</#{name}>"
end
# Format the given element as block HTML.
def format_as_block_html(name, attr, body, indent)
"#{' '*indent}<#{name}#{html_attributes(attr)}>#{body}</#{name}>\n"
end
# Format the given element as block HTML with a newline after the start tag and indentation
# before the end tag.
def format_as_indented_block_html(name, attr, body, indent)
"#{' '*indent}<#{name}#{html_attributes(attr)}>\n#{body}#{' '*indent}</#{name}>\n"
end
# Add the syntax highlighter name to the 'class' attribute of the given attribute hash. And
# overwrites or add a "language-LANG" part using the +lang+ parameter if +lang+ is not nil.
def add_syntax_highlighter_to_class_attr(attr, lang = nil)
(attr['class'] = (attr['class'] || '') + " highlighter-#{@options[:syntax_highlighter]}").lstrip!
attr['class'].sub!(/\blanguage-\S+|(^)/) { "language-#{lang}#{$1 ? ' ' : ''}" } if lang
end
# Generate and return an element tree for the table of contents.
def generate_toc_tree(toc, type, attr)
sections = Element.new(type, nil, attr)
sections.attr['id'] ||= 'markdown-toc'
stack = []
toc.each do |level, id, children|
li = Element.new(:li, nil, nil, {:level => level})
li.children << Element.new(:p, nil, nil, {:transparent => true})
a = Element.new(:a, nil)
a.attr['href'] = "##{id}"
a.attr['id'] = "#{sections.attr['id']}-#{id}"
a.children.concat(fix_for_toc_entry(Marshal.load(Marshal.dump(children))))
li.children.last.children << a
li.children << Element.new(type)
success = false
while !success
if stack.empty?
sections.children << li
stack << li
success = true
elsif stack.last.options[:level] < li.options[:level]
stack.last.children.last.children << li
stack << li
success = true
else
item = stack.pop
item.children.pop unless item.children.last.children.size > 0
end
end
end
while !stack.empty?
item = stack.pop
item.children.pop unless item.children.last.children.size > 0
end
sections
end
# Fixes the elements for use in a TOC entry.
def fix_for_toc_entry(elements)
remove_footnotes(elements)
unwrap_links(elements)
elements
end
# Remove all link elements by unwrapping them.
def unwrap_links(elements)
elements.map! do |c|
unwrap_links(c.children)
c.type == :a ? c.children : c
end.flatten!
end
# Remove all footnotes from the given elements.
def remove_footnotes(elements)
elements.delete_if do |c|
remove_footnotes(c.children)
c.type == :footnote
end
end
# Obfuscate the +text+ by using HTML entities.
def obfuscate(text)
result = ""
text.each_byte do |b|
result << (b > 128 ? b.chr : "&#%03d;" % b)
end
result.force_encoding(text.encoding)
result
end
FOOTNOTE_BACKLINK_FMT = "%s<a href=\"#fnref:%s\" class=\"reversefootnote\">%s</a>"
# Return a HTML ordered list with the footnote content for the used footnotes.
def footnote_content
ol = Element.new(:ol)
ol.attr['start'] = @footnote_start if @footnote_start != 1
i = 0
backlink_text = escape_html(@options[:footnote_backlink], :text)
while i < @footnotes.length
name, data, _, repeat = *@footnotes[i]
li = Element.new(:li, nil, {'id' => "fn:#{name}"})
li.children = Marshal.load(Marshal.dump(data.children))
para = nil
if li.children.last.type == :p || @options[:footnote_backlink_inline]
parent = li
while !parent.children.empty? && ![:p, :header].include?(parent.children.last.type)
parent = parent.children.last
end
para = parent.children.last
insert_space = true
end
unless para
li.children << (para = Element.new(:p))
insert_space = false
end
unless @options[:footnote_backlink].empty?
nbsp = entity_to_str(ENTITY_NBSP)
para.children << Element.new(:raw, FOOTNOTE_BACKLINK_FMT % [insert_space ? nbsp : '', name, backlink_text])
(1..repeat).each do |index|
para.children << Element.new(:raw, FOOTNOTE_BACKLINK_FMT % [nbsp, "#{name}:#{index}", "#{backlink_text}<sup>#{index+1}</sup>"])
end
end
ol.children << Element.new(:raw, convert(li, 4))
i += 1
end
(ol.children.empty? ? '' : format_as_indented_block_html('div', {:class => "footnotes"}, convert(ol, 2), 0))
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/math_engine/mathjaxnode.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/math_engine/mathjaxnode.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown::Converter::MathEngine
# Uses the mathjax-node-cli library for converting math formulas to MathML.
module MathjaxNode
# MathjaxNode is available if this constant is +true+.
AVAILABLE = begin
%x{node --version}[1..-2] >= '4.5'
rescue
begin
%x{nodejs --version}[1..-2] >= '4.5'
rescue
false
end
end && begin
npm = %x{npm --global --depth=1 list mathjax-node-cli 2>&1}
unless /mathjax-node-cli@/ === npm.lines.drop(1).join("\n")
npm = %x{npm --depth=1 list mathjax-node-cli 2>&1}
end
T2MPATH = File.join(npm.lines.first.strip, "node_modules/mathjax-node-cli/bin/tex2mml")
/mathjax-node-cli@/ === npm.lines.drop(1).join("\n") && File.exist?(T2MPATH)
rescue
false
end
def self.call(converter, el, opts)
type = el.options[:category]
cmd = [T2MPATH]
cmd << "--inline" unless type == :block
cmd << "--semantics" if converter.options[:math_engine_opts][:semantics] == true
cmd << "--notexhints" if converter.options[:math_engine_opts][:texhints] == false
result = IO.popen(cmd << el.value).read.strip
attr = el.attr.dup
attr.delete('xmlns')
attr.delete('display')
result.insert("<math".length, converter.html_attributes(attr))
(type == :block ? "#{' '*opts[:indent]}#{result}\n" : result)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/math_engine/itex2mml.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/math_engine/itex2mml.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown::Converter::MathEngine
# Uses the Itex2MML library for converting math formulas to MathML.
module Itex2MML
begin
require 'itextomml'
# Itex2MML is available if this constant is +true+.
AVAILABLE = true
rescue LoadError
AVAILABLE = false # :nodoc:
end
def self.call(converter, el, opts)
type = el.options[:category]
parser = ::Itex2MML::Parser.new
result = (type == :block ? parser.block_filter(el.value) : parser.inline_filter(el.value))
attr = el.attr.dup
attr.delete('xmlns')
attr.delete('display')
result.insert("<math".length, converter.html_attributes(attr))
(type == :block ? "#{' '*opts[:indent]}#{result}\n" : result)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/math_engine/mathjax.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/math_engine/mathjax.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown::Converter::MathEngine
# Uses the MathJax javascript library for displaying math.
#
# Note that the javascript library itself is not include or linked, this has to be done
# separately. Only the math content is marked up correctly.
module Mathjax
def self.call(converter, el, opts)
type = el.options[:category]
text = (el.value =~ /<|&/ ? "% <![CDATA[\n#{el.value} %]]>" : el.value)
text.gsub!(/<\/?script>?/, '')
preview = preview_string(converter, el, opts)
attr = {:type => "math/tex#{type == :block ? '; mode=display' : ''}"}
if type == :block
preview << converter.format_as_block_html('script', attr, text, opts[:indent])
else
preview << converter.format_as_span_html('script', attr, text)
end
end
def self.preview_string(converter, el, opts)
preview = converter.options[:math_engine_opts][:preview]
return '' unless preview
preview = (preview == true ? converter.escape_html(el.value) : preview.to_s)
preview_as_code = converter.options[:math_engine_opts][:preview_as_code]
if el.options[:category] == :block
if preview_as_code
converter.format_as_block_html('pre', {'class' => 'MathJax_Preview'},
converter.format_as_span_html('code', {}, preview),
opts[:indent])
else
converter.format_as_block_html('div', {'class' => 'MathJax_Preview'}, preview,
opts[:indent])
end
else
converter.format_as_span_html(preview_as_code ? 'code' : 'span',
{'class' => 'MathJax_Preview'}, preview)
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/math_engine/sskatex.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/math_engine/sskatex.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2017 Christian Cornelssen <ccorn@1tein.de>
#
# This file is part of kramdown which is licensed under the MIT.
#++
module Kramdown::Converter::MathEngine
# Consider this a lightweight alternative to MathjaxNode. Uses KaTeX and ExecJS (via ::SsKaTeX)
# instead of MathJax and Node.js. Javascript execution context initialization is done only once.
# As a result, the performance is reasonable.
module SsKaTeX
# Indicate whether SsKaTeX may be available.
#
# This test is incomplete; it cannot test the existence of _katex_js_ nor the availability of a
# specific _js_run_ because those depend on configuration not given here. This test mainly
# indicates whether static dependencies such as the +sskatex+ and +execjs+ gems are available.
AVAILABLE = begin
require 'sskatex'
# No test for any JS engine availability here; specifics are config-dependent anyway
true
rescue LoadError
false
end
if AVAILABLE
# Class-level cache for ::SsKaTeX converter state, queried by configuration. Note: KTXC
# contents may become stale if the contents of used JS files change while the configuration
# remains unchanged.
KTXC = ::Kramdown::Utils::LRUCache.new(10)
# A logger that routes messages to the debug channel only. No need to create this dynamically.
DEBUG_LOGGER = lambda { |level, &expr| warn(expr.call) }
class << self
private
# Given a Kramdown::Converter::Base object _converter_, retrieves the logging options and
# builds an object usable for ::SsKaTeX#logger. The result is either +nil+ (no logging) or a
# +Proc+ object which, when given a _level_ (either +:verbose+ or +:debug+) and a block,
# decides whether logging is enabled, and if so, evaluates the given block for the message
# and routes that message to the appropriate channels. With <tt>level == :verbose+</tt>,
# messages are passed to _converter_.warning if the _converter_'s +:verbose+ option is set.
# All messages are passed to +warn+ if the _converter_'s +:debug+ option is set.
#
# Note that the returned logger may contain references to the given _converter_ and is not
# affected by subsequent changes in the _converter_'s logging options.
def logger(converter)
config = converter.options[:math_engine_opts]
debug = config[:debug]
if config[:verbose]
# Need a closure
lambda do |level, &expr|
verbose = (level == :verbose)
msg = expr.call if debug || verbose
warn(msg) if debug
converter.warning(msg) if verbose
end
elsif debug
DEBUG_LOGGER
end
end
# Given a Kramdown::Converter::Base object _converter_, return a ::SsKaTeX converter _sktx_
# that has been configured with _converter_'s +math_engine_opts+, but not for logging. Cache
# _sktx_ for reuse, without references to _converter_.
def katex_conv(converter)
config = converter.options[:math_engine_opts]
# Could .reject { |key, _| [:verbose, :debug].include?(key.to_sym) }
# because the JS engine setup can be reused for different logging settings.
# But then the +math_engine_opts+ dict would be essentially dup'ed every time,
# and late activation of logging would miss the initialization if the engine is reused.
KTXC[config] ||= ::SsKaTeX.new(config)
end
public
# The function used by kramdown for rendering TeX math to HTML
def call(converter, el, opts)
display_mode = el.options[:category]
ans = katex_conv(converter).call(el.value, display_mode == :block, &logger(converter))
attr = el.attr.dup
attr.delete('xmlns')
attr.delete('display')
ans.insert(ans =~ /[[:space:]>]/, converter.html_attributes(attr))
ans = ' ' * opts[:indent] << ans << "\n" if display_mode == :block
ans
end
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/math_engine/katex.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/math_engine/katex.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2018 Gleb Mazovetskiy <glex.spb@gmail.com>
#
# This file is part of kramdown which is licensed under the MIT.
#++
module Kramdown::Converter::MathEngine
# Uses the KaTeX gem for converting math formulas to KaTeX HTML.
module Katex
AVAILABLE = begin
require 'katex'
true
rescue LoadError
false
end
def self.call(converter, el, opts)
display_mode = el.options[:category] == :block
result = ::Katex.render(
el.value,
display_mode: display_mode,
throw_on_error: false,
**converter.options[:math_engine_opts]
)
attr = el.attr.dup
attr.delete('xmlns')
attr.delete('display')
result.insert(result =~ /[[:space:]>]/, converter.html_attributes(attr))
result = "#{' ' * opts[:indent]}#{result}\n" if display_mode
result
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/math_engine/ritex.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/math_engine/ritex.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown::Converter::MathEngine
# Uses the Ritex library for converting math formulas to MathML.
module Ritex
begin
require 'ritex'
# Ritex is available if this constant is +true+.
AVAILABLE = true
rescue LoadError
AVAILABLE = false # :nodoc:
end
def self.call(converter, el, opts)
type = el.options[:category]
result = ::Ritex::Parser.new.parse(el.value, :display => (type == :block))
attr = el.attr.dup
attr.delete('xmlns')
attr.delete('display')
result.insert("<math".length, converter.html_attributes(attr))
(type == :block ? "#{' '*opts[:indent]}#{result}\n" : result)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/syntax_highlighter/minted.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/syntax_highlighter/minted.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown::Converter::SyntaxHighlighter
# Uses Minted to highlight code blocks and code spans.
module Minted
def self.call(converter, text, lang, type, _opts)
opts = converter.options[:syntax_highlighter_opts]
# Fallback to default language
lang ||= opts[:default_lang]
options = []
options << "breaklines" if opts[:wrap]
options << "linenos" if opts[:line_numbers]
options << "frame=#{opts[:frame]}" if opts[:frame]
if lang && type == :block
"\\begin{minted}[#{options.join(',')}]{#{lang}}\n#{text}\n\\end{minted}"
elsif lang && type == :span
"\\mintinline{#{lang}}{#{text}}"
else
nil
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/syntax_highlighter/coderay.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/syntax_highlighter/coderay.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown::Converter::SyntaxHighlighter
# Uses Coderay to highlight code blocks and code spans.
module Coderay
begin
require 'coderay'
# Highlighting via coderay is available if this constant is +true+.
AVAILABLE = true
rescue LoadError
AVAILABLE = false # :nodoc:
end
def self.call(converter, text, lang, type, call_opts)
return nil unless converter.options[:enable_coderay]
if type == :span && lang
::CodeRay.scan(text, lang.to_sym).html(options(converter, :span)).chomp
elsif type == :block && (lang || options(converter, :default_lang))
lang ||= call_opts[:default_lang] = options(converter, :default_lang)
::CodeRay.scan(text, lang.to_s.gsub(/-/, '_').to_sym).html(options(converter, :block)).chomp << "\n"
else
nil
end
rescue
converter.warning("There was an error using CodeRay: #{$!.message}")
nil
end
def self.options(converter, type)
prepare_options(converter)
converter.data[:syntax_highlighter_coderay][type]
end
def self.prepare_options(converter)
return if converter.data.key?(:syntax_highlighter_coderay)
cache = converter.data[:syntax_highlighter_coderay] = {}
opts = converter.options[:syntax_highlighter_opts].dup
span_opts = (opts.delete(:span) || {}).dup
block_opts = (opts.delete(:block) || {}).dup
[span_opts, block_opts].each do |hash|
hash.keys.each do |k|
hash[k.kind_of?(String) ? Kramdown::Options.str_to_sym(k) : k] = hash.delete(k)
end
end
cache[:default_lang] = converter.options[:coderay_default_lang] || opts.delete(:default_lang)
cache[:span] = {
:css => converter.options[:coderay_css]
}.update(opts).update(span_opts).update(:wrap => :span)
cache[:block] = {
:wrap => converter.options[:coderay_wrap],
:line_numbers => converter.options[:coderay_line_numbers],
:line_number_start => converter.options[:coderay_line_number_start],
:tab_width => converter.options[:coderay_tab_width],
:bold_every => converter.options[:coderay_bold_every],
:css => converter.options[:coderay_css]
}.update(opts).update(block_opts)
[:css, :wrap, :line_numbers].each do |key|
[:block, :span].each do |type|
cache[type][key] = cache[type][key].to_sym if cache[type][key].kind_of?(String)
end
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/syntax_highlighter/rouge.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/converter/syntax_highlighter/rouge.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown::Converter::SyntaxHighlighter
# Uses Rouge which is CSS-compatible to Pygments to highlight code blocks and code spans.
module Rouge
begin
require 'rouge'
# Highlighting via Rouge is available if this constant is +true+.
AVAILABLE = true
rescue LoadError, SyntaxError
AVAILABLE = false # :nodoc:
end
def self.call(converter, text, lang, type, call_opts)
opts = options(converter, type)
call_opts[:default_lang] = opts[:default_lang]
lexer = ::Rouge::Lexer.find_fancy(lang || opts[:default_lang], text)
return nil if opts[:disable] || !lexer
opts[:css_class] ||= 'highlight' # For backward compatibility when using Rouge 2.0
formatter = formatter_class(opts).new(opts)
formatter.format(lexer.lex(text))
end
def self.options(converter, type)
prepare_options(converter)
converter.data[:syntax_highlighter_rouge][type]
end
def self.prepare_options(converter)
return if converter.data.key?(:syntax_highlighter_rouge)
cache = converter.data[:syntax_highlighter_rouge] = {}
opts = converter.options[:syntax_highlighter_opts].dup
span_opts = (opts.delete(:span) || {}).dup
block_opts = (opts.delete(:block) || {}).dup
[span_opts, block_opts].each do |hash|
hash.keys.each do |k|
hash[k.kind_of?(String) ? Kramdown::Options.str_to_sym(k) : k] = hash.delete(k)
end
end
cache[:span] = opts.merge(span_opts).update(:wrap => false)
cache[:block] = opts.merge(block_opts)
end
def self.formatter_class(opts = {})
case formatter = opts[:formatter]
when Class
formatter
when /\A[[:upper:]][[:alnum:]_]*\z/
::Rouge::Formatters.const_get(formatter)
else
# Available in Rouge 2.0 or later
::Rouge::Formatters::HTMLLegacy
end
rescue NameError
# Fallback to Rouge 1.x
::Rouge::Formatters::HTML
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/gfm.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/gfm.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser'
module Kramdown
module Parser
class GFM < Kramdown::Parser::Kramdown
def initialize(source, options)
super
@options[:auto_id_stripping] = true
@id_counter = Hash.new(-1)
@span_parsers.delete(:line_break) if @options[:hard_wrap]
@span_parsers.delete(:typographic_syms) if @options[:gfm_quirks].include?(:no_auto_typographic)
if @options[:gfm_quirks].include?(:paragraph_end)
atx_header_parser = :atx_header_gfm_quirk
@paragraph_end = self.class::PARAGRAPH_END_GFM
else
atx_header_parser = :atx_header_gfm
@paragraph_end = self.class::PARAGRAPH_END
end
{:codeblock_fenced => :codeblock_fenced_gfm,
:atx_header => atx_header_parser}.each do |current, replacement|
i = @block_parsers.index(current)
@block_parsers.delete(current)
@block_parsers.insert(i, replacement)
end
i = @span_parsers.index(:escaped_chars)
@span_parsers[i] = :escaped_chars_gfm if i
@span_parsers << :strikethrough_gfm
end
def parse
super
update_elements(@root)
end
def update_elements(element)
element.children.map! do |child|
if child.type == :text && @options[:hard_wrap] && child.value =~ /\n/
children = []
lines = child.value.split(/\n/, -1)
omit_trailing_br = (Kramdown::Element.category(element) == :block && element.children[-1] == child &&
lines[-1].empty?)
lines.each_with_index do |line, index|
new_element_options = { :location => child.options[:location] + index }
children << Element.new(:text, (index > 0 ? "\n#{line}" : line), nil, new_element_options)
children << Element.new(:br, nil, nil, new_element_options) if index < lines.size - 2 ||
(index == lines.size - 2 && !omit_trailing_br)
end
children
elsif child.type == :html_element
child
elsif child.type == :header && @options[:auto_ids] && !child.attr.has_key?('id')
child.attr['id'] = generate_gfm_header_id(child.options[:raw_text])
child
else
update_elements(child)
child
end
end.flatten!
end
# Update the raw text for automatic ID generation.
def update_raw_text(item)
raw_text = ''
append_text = lambda do |child|
if child.type == :text || child.type == :codespan || child.type ==:math
raw_text << child.value
elsif child.type == :entity
raw_text << child.value.char
elsif child.type == :smart_quote
raw_text << ::Kramdown::Utils::Entities.entity(child.value.to_s).char
elsif child.type == :typographic_sym
if child.value == :laquo_space
raw_text << "« "
elsif child.value == :raquo_space
raw_text << " »"
else
raw_text << ::Kramdown::Utils::Entities.entity(child.value.to_s).char
end
else
child.children.each {|c| append_text.call(c)}
end
end
append_text.call(item)
item.options[:raw_text] = raw_text
end
NON_WORD_RE = /[^\p{Word}\- \t]/
def generate_gfm_header_id(text)
result = text.downcase
result.gsub!(NON_WORD_RE, '')
result.tr!(" \t", '-')
@id_counter[result] += 1
result << (@id_counter[result] > 0 ? "-#{@id_counter[result]}" : '')
@options[:auto_id_prefix] + result
end
ATX_HEADER_START = /^(?<level>\#{1,6})[\t ]+(?<contents>.*)\n/
define_parser(:atx_header_gfm, ATX_HEADER_START, nil, 'parse_atx_header')
define_parser(:atx_header_gfm_quirk, ATX_HEADER_START)
# Copied from kramdown/parser/kramdown/header.rb, removed the first line
def parse_atx_header_gfm_quirk
text, id = parse_header_contents
text.sub!(/[\t ]#+\z/, '') && text.rstrip!
return false if text.empty?
add_header(@src["level"].length, text, id)
true
end
FENCED_CODEBLOCK_START = /^[ ]{0,3}[~`]{3,}/
FENCED_CODEBLOCK_MATCH = /^[ ]{0,3}(([~`]){3,})\s*?((\S+?)(?:\?\S*)?)?\s*?\n(.*?)^[ ]{0,3}\1\2*\s*?\n/m
define_parser(:codeblock_fenced_gfm, FENCED_CODEBLOCK_START, nil, 'parse_codeblock_fenced')
STRIKETHROUGH_DELIM = /~~/
STRIKETHROUGH_MATCH = /#{STRIKETHROUGH_DELIM}[^\s~](.*?)[^\s~]#{STRIKETHROUGH_DELIM}/m
define_parser(:strikethrough_gfm, STRIKETHROUGH_MATCH, '~~')
def parse_strikethrough_gfm
line_number = @src.current_line_number
@src.pos += @src.matched_size
el = Element.new(:html_element, 'del', {}, :category => :span, :line => line_number)
@tree.children << el
env = save_env
reset_env(:src => Kramdown::Utils::StringScanner.new(@src.matched[2..-3], line_number),
:text_type => :text)
parse_spans(el)
restore_env(env)
el
end
# To handle task-lists we override the parse method for lists, converting matching text into checkbox input
# elements where necessary (as well as applying classes to the ul/ol and li elements).
def parse_list
super
current_list = @tree.children.select{ |element| [:ul, :ol].include?(element.type) }.last
is_tasklist = false
box_unchecked = '<input type="checkbox" class="task-list-item-checkbox" disabled="disabled" />'
box_checked = '<input type="checkbox" class="task-list-item-checkbox" disabled="disabled" checked="checked" />'
current_list.children.each do |li|
next unless li.children.size > 0 && li.children[0].type == :p
# li -> p -> raw_text
checked = li.children[0].children[0].value.gsub!(/\A\s*\[ \]\s+/, box_unchecked)
unchecked = li.children[0].children[0].value.gsub!(/\A\s*\[x\]\s+/i, box_checked)
is_tasklist ||= (!checked.nil? || !unchecked.nil?)
li.attr['class'] = 'task-list-item' if is_tasklist
end
current_list.attr['class'] = 'task-list' if is_tasklist
true
end
ESCAPED_CHARS_GFM = /\\([\\.*_+`<>()\[\]{}#!:\|"'\$=\-~])/
define_parser(:escaped_chars_gfm, ESCAPED_CHARS_GFM, '\\\\', :parse_escaped_chars)
PARAGRAPH_END_GFM = /#{LAZY_END}|#{LIST_START}|#{ATX_HEADER_START}|#{DEFINITION_LIST_START}|#{BLOCKQUOTE_START}|#{FENCED_CODEBLOCK_START}/
def paragraph_end
@paragraph_end
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'strscan'
require 'stringio'
require 'kramdown/parser'
#TODO: use [[:alpha:]] in all regexp to allow parsing of international values in 1.9.1
#NOTE: use @src.pre_match only before other check/match?/... operations, otherwise the content is changed
module Kramdown
module Parser
# Used for parsing a document in kramdown format.
#
# If you want to extend the functionality of the parser, you need to do the following:
#
# * Create a new subclass
# * add the needed parser methods
# * modify the @block_parsers and @span_parsers variables and add the names of your parser
# methods
#
# Here is a small example for an extended parser class that parses ERB style tags as raw text if
# they are used as span-level elements (an equivalent block-level parser should probably also be
# made to handle the block case):
#
# require 'kramdown/parser/kramdown'
#
# class Kramdown::Parser::ERBKramdown < Kramdown::Parser::Kramdown
#
# def initialize(source, options)
# super
# @span_parsers.unshift(:erb_tags)
# end
#
# ERB_TAGS_START = /<%.*?%>/
#
# def parse_erb_tags
# @src.pos += @src.matched_size
# @tree.children << Element.new(:raw, @src.matched)
# end
# define_parser(:erb_tags, ERB_TAGS_START, '<%')
#
# end
#
# The new parser can be used like this:
#
# require 'kramdown/document'
# # require the file with the above parser class
#
# Kramdown::Document.new(input_text, :input => 'ERBKramdown').to_html
#
class Kramdown < Base
include ::Kramdown
# Create a new Kramdown parser object with the given +options+.
def initialize(source, options)
super
reset_env
@alds = {}
@footnotes = {}
@link_defs = {}
update_link_definitions(@options[:link_defs])
@block_parsers = [:blank_line, :codeblock, :codeblock_fenced, :blockquote, :atx_header,
:horizontal_rule, :list, :definition_list, :block_html, :setext_header,
:block_math, :table, :footnote_definition, :link_definition, :abbrev_definition,
:block_extensions, :eob_marker, :paragraph]
@span_parsers = [:emphasis, :codespan, :autolink, :span_html, :footnote_marker, :link, :smart_quotes, :inline_math,
:span_extensions, :html_entity, :typographic_syms, :line_break, :escaped_chars]
end
private_class_method(:new, :allocate)
# The source string provided on initialization is parsed into the @root element.
def parse
configure_parser
parse_blocks(@root, adapt_source(source))
update_tree(@root)
correct_abbreviations_attributes
replace_abbreviations(@root)
@footnotes.each do |name,data|
update_tree(data[:content])
replace_abbreviations(data[:content])
end
@footnotes.each do |name, data|
next if data.key?(:marker)
line = data[:content].options[:location]
warning("Footnote definition for '#{name}' on line #{line} is unreferenced - ignoring")
end
end
#######
protected
#######
# :doc:
#
# Update the parser specific link definitions with the data from +link_defs+ (the value of the
# :link_defs option).
#
# The parameter +link_defs+ is a hash where the keys are possibly unnormalized link IDs and
# the values are two element arrays consisting of the link target and a title (can be +nil+).
def update_link_definitions(link_defs)
link_defs.each {|k,v| @link_defs[normalize_link_id(k)] = v}
end
# Adapt the object to allow parsing like specified in the options.
def configure_parser
@parsers = {}
(@block_parsers + @span_parsers).each do |name|
if self.class.has_parser?(name)
@parsers[name] = self.class.parser(name)
else
raise Kramdown::Error, "Unknown parser: #{name}"
end
end
@span_start, @span_start_re = span_parser_regexps
end
# Create the needed span parser regexps.
def span_parser_regexps(parsers = @span_parsers)
span_start = /#{parsers.map {|name| @parsers[name].span_start}.join('|')}/
[span_start, /(?=#{span_start})/]
end
# Parse all block-level elements in +text+ into the element +el+.
def parse_blocks(el, text = nil)
@stack.push([@tree, @src, @block_ial])
@tree, @block_ial = el, nil
@src = (text.nil? ? @src : ::Kramdown::Utils::StringScanner.new(text, el.options[:location]))
status = catch(:stop_block_parsing) do
while !@src.eos?
@block_parsers.any? do |name|
if @src.check(@parsers[name].start_re)
send(@parsers[name].method)
else
false
end
end || begin
warning('Warning: this should not occur - no block parser handled the line')
add_text(@src.scan(/.*\n/))
end
end
end
@tree, @src, @block_ial = *@stack.pop
status
end
# Update the tree by parsing all :+raw_text+ elements with the span-level parser (resets the
# environment) and by updating the attributes from the IALs.
def update_tree(element)
last_blank = nil
element.children.map! do |child|
if child.type == :raw_text
last_blank = nil
reset_env(:src => ::Kramdown::Utils::StringScanner.new(child.value, element.options[:location]),
:text_type => :text)
parse_spans(child)
child.children
elsif child.type == :eob
update_attr_with_ial(child.attr, child.options[:ial]) if child.options[:ial]
[]
elsif child.type == :blank
if last_blank
last_blank.value << child.value
[]
else
last_blank = child
child
end
else
last_blank = nil
update_tree(child)
update_attr_with_ial(child.attr, child.options[:ial]) if child.options[:ial]
# DEPRECATED: option auto_id_stripping will be removed in 2.0 because then this will be
# the default behaviour
if child.type == :dt || (child.type == :header && @options[:auto_id_stripping])
update_raw_text(child)
end
child
end
end.flatten!
end
# Parse all span-level elements in the source string of @src into +el+.
#
# If the parameter +stop_re+ (a regexp) is used, parsing is immediately stopped if the regexp
# matches and if no block is given or if a block is given and it returns +true+.
#
# The parameter +parsers+ can be used to specify the (span-level) parsing methods that should
# be used for parsing.
#
# The parameter +text_type+ specifies the type which should be used for created text nodes.
def parse_spans(el, stop_re = nil, parsers = nil, text_type = @text_type)
@stack.push([@tree, @text_type]) unless @tree.nil?
@tree, @text_type = el, text_type
span_start = @span_start
span_start_re = @span_start_re
span_start, span_start_re = span_parser_regexps(parsers) if parsers
parsers = parsers || @span_parsers
used_re = (stop_re.nil? ? span_start_re : /(?=#{Regexp.union(stop_re, span_start)})/)
stop_re_found = false
while !@src.eos? && !stop_re_found
if result = @src.scan_until(used_re)
add_text(result)
if stop_re && @src.check(stop_re)
stop_re_found = (block_given? ? yield : true)
end
processed = parsers.any? do |name|
if @src.check(@parsers[name].start_re)
send(@parsers[name].method)
true
else
false
end
end unless stop_re_found
add_text(@src.getch) if !processed && !stop_re_found
else
(add_text(@src.rest); @src.terminate) unless stop_re
break
end
end
@tree, @text_type = @stack.pop
stop_re_found
end
# Reset the current parsing environment. The parameter +env+ can be used to set initial
# values for one or more environment variables.
def reset_env(opts = {})
opts = {:text_type => :raw_text, :stack => []}.merge(opts)
@src = opts[:src]
@tree = opts[:tree]
@block_ial = opts[:block_ial]
@stack = opts[:stack]
@text_type = opts[:text_type]
end
# Return the current parsing environment.
def save_env
[@src, @tree, @block_ial, @stack, @text_type]
end
# Restore the current parsing environment.
def restore_env(env)
@src, @tree, @block_ial, @stack, @text_type = *env
end
# Update the given attributes hash +attr+ with the information from the inline attribute list
# +ial+ and all referenced ALDs.
def update_attr_with_ial(attr, ial)
ial[:refs].each do |ref|
update_attr_with_ial(attr, ref) if ref = @alds[ref]
end if ial[:refs]
ial.each do |k,v|
if k == IAL_CLASS_ATTR
attr[k] = (attr[k] || '') << " #{v}"
attr[k].lstrip!
elsif k.kind_of?(String)
attr[k] = v
end
end
end
# Update the raw text for automatic ID generation.
def update_raw_text(item)
raw_text = ''
append_text = lambda do |child|
if child.type == :text
raw_text << child.value
else
child.children.each {|c| append_text.call(c)}
end
end
append_text.call(item)
item.options[:raw_text] = raw_text
end
# Create a new block-level element, taking care of applying a preceding block IAL if it
# exists. This method should always be used for creating a block-level element!
def new_block_el(*args)
el = Element.new(*args)
if @block_ial
el.options[:ial] = @block_ial
@block_ial = nil
end
el
end
@@parsers = {}
# Struct class holding all the needed data for one block/span-level parser method.
Data = Struct.new(:name, :start_re, :span_start, :method)
# Add a parser method
#
# * with the given +name+,
# * using +start_re+ as start regexp
# * and, for span parsers, +span_start+ as a String that can be used in a regexp and
# which identifies the starting character(s)
#
# to the registry. The method name is automatically derived from the +name+ or can explicitly
# be set by using the +meth_name+ parameter.
def self.define_parser(name, start_re, span_start = nil, meth_name = "parse_#{name}")
raise "A parser with the name #{name} already exists!" if @@parsers.has_key?(name)
@@parsers[name] = Data.new(name, start_re, span_start, meth_name)
end
# Return the Data structure for the parser +name+.
def self.parser(name = nil)
@@parsers[name]
end
# Return +true+ if there is a parser called +name+.
def self.has_parser?(name)
@@parsers.has_key?(name)
end
# Regexp for matching indentation (one tab or four spaces)
INDENT = /^(?:\t| {4})/
# Regexp for matching the optional space (zero or up to three spaces)
OPT_SPACE = / {0,3}/
require 'kramdown/parser/kramdown/blank_line'
require 'kramdown/parser/kramdown/eob'
require 'kramdown/parser/kramdown/paragraph'
require 'kramdown/parser/kramdown/header'
require 'kramdown/parser/kramdown/blockquote'
require 'kramdown/parser/kramdown/table'
require 'kramdown/parser/kramdown/codeblock'
require 'kramdown/parser/kramdown/horizontal_rule'
require 'kramdown/parser/kramdown/list'
require 'kramdown/parser/kramdown/link'
require 'kramdown/parser/kramdown/extensions'
require 'kramdown/parser/kramdown/footnote'
require 'kramdown/parser/kramdown/html'
require 'kramdown/parser/kramdown/escaped_chars'
require 'kramdown/parser/kramdown/html_entity'
require 'kramdown/parser/kramdown/line_break'
require 'kramdown/parser/kramdown/typographic_symbol'
require 'kramdown/parser/kramdown/autolink'
require 'kramdown/parser/kramdown/codespan'
require 'kramdown/parser/kramdown/emphasis'
require 'kramdown/parser/kramdown/smart_quotes'
require 'kramdown/parser/kramdown/math'
require 'kramdown/parser/kramdown/abbreviation'
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/base.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/base.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/utils'
require 'kramdown/parser'
module Kramdown
module Parser
# == \Base class for parsers
#
# This class serves as base class for parsers. It provides common methods that can/should be
# used by all parsers, especially by those using StringScanner(Kramdown) for parsing.
#
# A parser object is used as a throw-away object, i.e. it is only used for storing the needed
# state information during parsing. Therefore one can't instantiate a parser object directly but
# only use the Base::parse method.
#
# == Implementing a parser
#
# Implementing a new parser is rather easy: just derive a new class from this class and put it
# in the Kramdown::Parser module -- the latter is needed so that the auto-detection of the new
# parser works correctly. Then you need to implement the +#parse+ method which has to contain
# the parsing code.
#
# Have a look at the Base::parse, Base::new and Base#parse methods for additional information!
class Base
# The hash with the parsing options.
attr_reader :options
# The array with the parser warnings.
attr_reader :warnings
# The original source string.
attr_reader :source
# The root element of element tree that is created from the source string.
attr_reader :root
# Initialize the parser object with the +source+ string and the parsing +options+.
#
# The @root element, the @warnings array and @text_type (specifies the default type for newly
# created text nodes) are automatically initialized.
def initialize(source, options)
@source = source
@options = Kramdown::Options.merge(options)
@root = Element.new(:root, nil, nil, :encoding => (source.encoding rescue nil), :location => 1,
:options => {}, :abbrev_defs => {}, :abbrev_attr => {})
@warnings = []
@text_type = :text
end
private_class_method(:new, :allocate)
# Parse the +source+ string into an element tree, possibly using the parsing +options+, and
# return the root element of the element tree and an array with warning messages.
#
# Initializes a new instance of the calling class and then calls the +#parse+ method that must
# be implemented by each subclass.
def self.parse(source, options = {})
parser = new(source, options)
parser.parse
[parser.root, parser.warnings]
end
# Parse the source string into an element tree.
#
# The parsing code should parse the source provided in @source and build an element tree the
# root of which should be @root.
#
# This is the only method that has to be implemented by sub-classes!
def parse
raise NotImplementedError
end
# Add the given warning +text+ to the warning array.
def warning(text)
@warnings << text
#TODO: add position information
end
# Modify the string +source+ to be usable by the parser (unifies line ending characters to
# +\n+ and makes sure +source+ ends with a new line character).
def adapt_source(source)
unless source.valid_encoding?
raise "The source text contains invalid characters for the used encoding #{source.encoding}"
end
source = source.encode('UTF-8')
source.gsub(/\r\n?/, "\n").chomp + "\n"
end
# This helper method adds the given +text+ either to the last element in the +tree+ if it is a
# +type+ element or creates a new text element with the given +type+.
def add_text(text, tree = @tree, type = @text_type)
last = tree.children.last
if last && last.type == type
last.value << text
elsif !text.empty?
tree.children << Element.new(type, text, nil, :location => (last && last.options[:location] || tree.options[:location]))
end
end
# Extract the part of the StringScanner +strscan+ backed string specified by the +range+. This
# method works correctly under Ruby 1.8 and Ruby 1.9.
def extract_string(range, strscan)
result = nil
begin
enc = strscan.string.encoding
strscan.string.force_encoding('ASCII-8BIT')
result = strscan.string[range].force_encoding(enc)
ensure
strscan.string.force_encoding(enc)
end
result
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/markdown.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/markdown.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser'
module Kramdown
module Parser
# Used for parsing a document in Markdown format.
#
# This parser is based on the kramdown parser and removes the parser methods for the additional
# non-Markdown features. However, since some things are handled differently by the kramdown
# parser methods (like deciding when a list item contains just text), this parser differs from
# real Markdown parsers in some respects.
#
# Note, though, that the parser basically fails just one of the Markdown test cases (some others
# also fail but those failures are negligible).
class Markdown < Kramdown
# Array with all the parsing methods that should be removed from the standard kramdown parser.
EXTENDED = [:codeblock_fenced, :table, :definition_list, :footnote_definition, :abbrev_definition, :block_math,
:block_extensions,
:footnote_marker, :smart_quotes, :inline_math, :span_extensions, :typographic_syms]
def initialize(source, options) # :nodoc:
super
@block_parsers.delete_if {|i| EXTENDED.include?(i)}
@span_parsers.delete_if {|i| EXTENDED.include?(i)}
end
# :stopdoc:
BLOCK_BOUNDARY = /#{BLANK_LINE}|#{EOB_MARKER}|\Z/
LAZY_END = /#{BLANK_LINE}|#{EOB_MARKER}|^#{OPT_SPACE}#{LAZY_END_HTML_STOP}|^#{OPT_SPACE}#{LAZY_END_HTML_START}|\Z/
CODEBLOCK_MATCH = /(?:#{BLANK_LINE}?(?:#{INDENT}[ \t]*\S.*\n)+)*/
PARAGRAPH_END = LAZY_END
IAL_RAND_CHARS = (('a'..'z').to_a + ('0'..'9').to_a)
IAL_RAND_STRING = (1..20).collect {|a| IAL_RAND_CHARS[rand(IAL_RAND_CHARS.size)]}.join
LIST_ITEM_IAL = /^\s*(#{IAL_RAND_STRING})?\s*\n/
IAL_SPAN_START = LIST_ITEM_IAL
# :startdoc:
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/html.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/html.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'rexml/parsers/baseparser'
require 'strscan'
require 'kramdown/utils'
require 'kramdown/parser'
module Kramdown
module Parser
# Used for parsing a HTML document.
#
# The parsing code is in the Parser module that can also be used by other parsers.
class Html < Base
# Contains all constants that are used when parsing.
module Constants
#:stopdoc:
# The following regexps are based on the ones used by REXML, with some slight modifications.
HTML_DOCTYPE_RE = /<!DOCTYPE.*?>/im
HTML_COMMENT_RE = /<!--(.*?)-->/m
HTML_INSTRUCTION_RE = /<\?(.*?)\?>/m
HTML_ATTRIBUTE_RE = /\s*(#{REXML::Parsers::BaseParser::UNAME_STR})(?:\s*=\s*(["'])(.*?)\2)?/m
HTML_TAG_RE = /<((?>#{REXML::Parsers::BaseParser::UNAME_STR}))\s*((?>\s+#{REXML::Parsers::BaseParser::UNAME_STR}(?:\s*=\s*(["']).*?\3)?)*)\s*(\/)?>/m
HTML_TAG_CLOSE_RE = /<\/(#{REXML::Parsers::BaseParser::UNAME_STR})\s*>/m
HTML_ENTITY_RE = /&([\w:][\-\w\.:]*);|&#(\d+);|&\#x([0-9a-fA-F]+);/
HTML_CONTENT_MODEL_BLOCK = %w{address applet article aside blockquote body
dd details div dl fieldset figure figcaption footer form header hgroup iframe li main
map menu nav noscript object section summary td}
HTML_CONTENT_MODEL_SPAN = %w{a abbr acronym b bdo big button cite caption del dfn dt em
h1 h2 h3 h4 h5 h6 i ins label legend optgroup p q rb rbc
rp rt rtc ruby select small span strong sub sup th tt}
HTML_CONTENT_MODEL_RAW = %w{script style math option textarea pre code kbd samp var}
# The following elements are also parsed as raw since they need child elements that cannot
# be expressed using kramdown syntax: colgroup table tbody thead tfoot tr ul ol
HTML_CONTENT_MODEL = Hash.new {|h,k| h[k] = :raw}
HTML_CONTENT_MODEL_BLOCK.each {|i| HTML_CONTENT_MODEL[i] = :block}
HTML_CONTENT_MODEL_SPAN.each {|i| HTML_CONTENT_MODEL[i] = :span}
HTML_CONTENT_MODEL_RAW.each {|i| HTML_CONTENT_MODEL[i] = :raw}
# Some HTML elements like script belong to both categories (i.e. are valid in block and
# span HTML) and don't appear therefore!
# script, textarea
HTML_SPAN_ELEMENTS = %w{a abbr acronym b big bdo br button cite code del dfn em i img input
ins kbd label mark option q rb rbc rp rt rtc ruby samp select small span
strong sub sup tt u var}
HTML_BLOCK_ELEMENTS = %w{address article aside applet body blockquote caption col colgroup dd div dl dt fieldset
figcaption footer form h1 h2 h3 h4 h5 h6 header hgroup hr html head iframe legend menu
li main map nav ol optgroup p pre section summary table tbody td th thead tfoot tr ul}
HTML_ELEMENTS_WITHOUT_BODY = %w{area base br col command embed hr img input keygen link meta param source track wbr}
HTML_ELEMENT = Hash.new(false)
(HTML_SPAN_ELEMENTS + HTML_BLOCK_ELEMENTS + HTML_ELEMENTS_WITHOUT_BODY +
HTML_CONTENT_MODEL.keys).each do |a|
HTML_ELEMENT[a] = true
end
end
# Contains the parsing methods. This module can be mixed into any parser to get HTML parsing
# functionality. The only thing that must be provided by the class are instance variable
# @stack for storing the needed state and @src (instance of StringScanner) for the actual
# parsing.
module Parser
include Constants
# Process the HTML start tag that has already be scanned/checked via @src.
#
# Does the common processing steps and then yields to the caller for further processing
# (first parameter is the created element; the second parameter is +true+ if the HTML
# element is already closed, ie. contains no body; the third parameter specifies whether the
# body - and the end tag - need to be handled in case closed=false).
def handle_html_start_tag(line = nil) # :yields: el, closed, handle_body
name = @src[1]
name.downcase! if HTML_ELEMENT[name.downcase]
closed = !@src[4].nil?
attrs = parse_html_attributes(@src[2], line, HTML_ELEMENT[name])
el = Element.new(:html_element, name, attrs, :category => :block)
el.options[:location] = line if line
@tree.children << el
if !closed && HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)
closed = true
end
if name == 'script' || name == 'style'
handle_raw_html_tag(name)
yield(el, false, false)
else
yield(el, closed, true)
end
end
# Parses the given string for HTML attributes and returns the resulting hash.
#
# If the optional +line+ parameter is supplied, it is used in warning messages.
#
# If the optional +in_html_tag+ parameter is set to +false+, attributes are not modified to
# contain only lowercase letters.
def parse_html_attributes(str, line = nil, in_html_tag = true)
attrs = Utils::OrderedHash.new
str.scan(HTML_ATTRIBUTE_RE).each do |attr, sep, val|
attr.downcase! if in_html_tag
if attrs.has_key?(attr)
warning("Duplicate HTML attribute '#{attr}' on line #{line || '?'} - overwriting previous one")
end
attrs[attr] = val || ""
end
attrs
end
# Handle the raw HTML tag at the current position.
def handle_raw_html_tag(name)
curpos = @src.pos
if @src.scan_until(/(?=<\/#{name}\s*>)/mi)
add_text(extract_string(curpos...@src.pos, @src), @tree.children.last, :raw)
@src.scan(HTML_TAG_CLOSE_RE)
else
add_text(@src.rest, @tree.children.last, :raw)
@src.terminate
warning("Found no end tag for '#{name}' - auto-closing it")
end
end
HTML_RAW_START = /(?=<(#{REXML::Parsers::BaseParser::UNAME_STR}|\/|!--|\?))/ # :nodoc:
# Parse raw HTML from the current source position, storing the found elements in +el+.
# Parsing continues until one of the following criteria are fulfilled:
#
# - The end of the document is reached.
# - The matching end tag for the element +el+ is found (only used if +el+ is an HTML
# element).
#
# When an HTML start tag is found, processing is deferred to #handle_html_start_tag,
# providing the block given to this method.
def parse_raw_html(el, &block)
@stack.push(@tree)
@tree = el
done = false
while !@src.eos? && !done
if result = @src.scan_until(HTML_RAW_START)
add_text(result, @tree, :text)
line = @src.current_line_number
if result = @src.scan(HTML_COMMENT_RE)
@tree.children << Element.new(:xml_comment, result, nil, :category => :block, :location => line)
elsif result = @src.scan(HTML_INSTRUCTION_RE)
@tree.children << Element.new(:xml_pi, result, nil, :category => :block, :location => line)
elsif @src.scan(HTML_TAG_RE)
if method(:handle_html_start_tag).arity.abs >= 1
handle_html_start_tag(line, &block)
else
handle_html_start_tag(&block) # DEPRECATED: method needs to accept line number in 2.0
end
elsif @src.scan(HTML_TAG_CLOSE_RE)
if @tree.value == (HTML_ELEMENT[@tree.value] ? @src[1].downcase : @src[1])
done = true
else
add_text(@src.matched, @tree, :text)
warning("Found invalidly used HTML closing tag for '#{@src[1]}' on line #{line} - ignoring it")
end
else
add_text(@src.getch, @tree, :text)
end
else
add_text(@src.rest, @tree, :text)
@src.terminate
warning("Found no end tag for '#{@tree.value}' on line #{@tree.options[:location]} - auto-closing it") if @tree.type == :html_element
done = true
end
end
@tree = @stack.pop
end
end
# Converts HTML elements to native elements if possible.
class ElementConverter
# :stopdoc:
include Constants
include ::Kramdown::Utils::Entities
REMOVE_TEXT_CHILDREN = %w{html head hgroup ol ul dl table colgroup tbody thead tfoot tr select optgroup}
WRAP_TEXT_CHILDREN = %w{body section nav article aside header footer address div li dd blockquote figure
figcaption fieldset form}
REMOVE_WHITESPACE_CHILDREN = %w{body section nav article aside header footer address
div li dd blockquote figure figcaption td th fieldset form}
STRIP_WHITESPACE = %w{address article aside blockquote body caption dd div dl dt fieldset figcaption form footer
header h1 h2 h3 h4 h5 h6 legend li nav p section td th}
SIMPLE_ELEMENTS = %w{em strong blockquote hr br img p thead tbody tfoot tr td th ul ol dl li dl dt dd}
def initialize(root)
@root = root
end
def self.convert(root, el = root)
new(root).process(el)
end
# Convert the element +el+ and its children.
def process(el, do_conversion = true, preserve_text = false, parent = nil)
case el.type
when :xml_comment, :xml_pi
ptype = if parent.nil?
'div'
else
case parent.type
when :html_element then parent.value
when :code_span then 'code'
when :code_block then 'pre'
when :header then 'h1'
else parent.type.to_s
end
end
el.options.replace({:category => (HTML_CONTENT_MODEL[ptype] == :span ? :span : :block)})
return
when :html_element
when :root
el.children.each {|c| process(c)}
remove_whitespace_children(el)
return
else return
end
mname = "convert_#{el.value}"
if do_conversion && self.class.method_defined?(mname)
send(mname, el)
else
type = el.value
remove_text_children(el) if do_conversion && REMOVE_TEXT_CHILDREN.include?(type)
if do_conversion && SIMPLE_ELEMENTS.include?(type)
set_basics(el, type.intern)
process_children(el, do_conversion, preserve_text)
else
process_html_element(el, do_conversion, preserve_text)
end
if do_conversion
strip_whitespace(el) if STRIP_WHITESPACE.include?(type)
remove_whitespace_children(el) if REMOVE_WHITESPACE_CHILDREN.include?(type)
wrap_text_children(el) if WRAP_TEXT_CHILDREN.include?(type)
end
end
end
def process_children(el, do_conversion = true, preserve_text = false)
el.children.map! do |c|
if c.type == :text
process_text(c.value, preserve_text || !do_conversion)
else
process(c, do_conversion, preserve_text, el)
c
end
end.flatten!
end
# Process the HTML text +raw+: compress whitespace (if +preserve+ is +false+) and convert
# entities in entity elements.
def process_text(raw, preserve = false)
raw.gsub!(/\s+/, ' ') unless preserve
src = Kramdown::Utils::StringScanner.new(raw)
result = []
while !src.eos?
if tmp = src.scan_until(/(?=#{HTML_ENTITY_RE})/)
result << Element.new(:text, tmp)
src.scan(HTML_ENTITY_RE)
val = src[1] || (src[2] && src[2].to_i) || src[3].hex
result << if %w{lsquo rsquo ldquo rdquo}.include?(val)
Element.new(:smart_quote, val.intern)
elsif %w{mdash ndash hellip laquo raquo}.include?(val)
Element.new(:typographic_sym, val.intern)
else
begin
Element.new(:entity, entity(val), nil, :original => src.matched)
rescue ::Kramdown::Error
src.pos -= src.matched_size - 1
Element.new(:entity, ::Kramdown::Utils::Entities.entity('amp'))
end
end
else
result << Element.new(:text, src.rest)
src.terminate
end
end
result
end
def process_html_element(el, do_conversion = true, preserve_text = false)
el.options.replace(:category => HTML_SPAN_ELEMENTS.include?(el.value) ? :span : :block,
:content_model => (do_conversion ? HTML_CONTENT_MODEL[el.value] : :raw))
process_children(el, do_conversion, preserve_text)
end
def remove_text_children(el)
el.children.delete_if {|c| c.type == :text}
end
def wrap_text_children(el)
tmp = []
last_is_p = false
el.children.each do |c|
if Element.category(c) != :block || c.type == :text
if !last_is_p
tmp << Element.new(:p, nil, nil, :transparent => true)
last_is_p = true
end
tmp.last.children << c
tmp
else
tmp << c
last_is_p = false
end
end
el.children = tmp
end
def strip_whitespace(el)
return if el.children.empty?
if el.children.first.type == :text
el.children.first.value.lstrip!
end
if el.children.last.type == :text
el.children.last.value.rstrip!
end
end
def remove_whitespace_children(el)
i = -1
el.children = el.children.reject do |c|
i += 1
c.type == :text && c.value.strip.empty? &&
(i == 0 || i == el.children.length - 1 || (Element.category(el.children[i-1]) == :block &&
Element.category(el.children[i+1]) == :block))
end
end
def set_basics(el, type, opts = {})
el.type = type
el.options.replace(opts)
el.value = nil
end
def extract_text(el, raw)
raw << el.value.to_s if el.type == :text
el.children.each {|c| extract_text(c, raw)}
end
def convert_textarea(el)
process_html_element(el, true, true)
end
def convert_a(el)
if el.attr['href']
set_basics(el, :a)
process_children(el)
else
process_html_element(el, false)
end
end
EMPHASIS_TYPE_MAP = {'em' => :em, 'i' => :em, 'strong' => :strong, 'b' => :strong}
def convert_em(el)
text = ''
extract_text(el, text)
if text =~ /\A\s/ || text =~ /\s\z/
process_html_element(el, false)
else
set_basics(el, EMPHASIS_TYPE_MAP[el.value])
process_children(el)
end
end
%w{b strong i}.each do |i|
alias_method("convert_#{i}".to_sym, :convert_em)
end
def convert_h1(el)
set_basics(el, :header, :level => el.value[1..1].to_i)
extract_text(el, el.options[:raw_text] = '')
process_children(el)
end
%w{h2 h3 h4 h5 h6}.each do |i|
alias_method("convert_#{i}".to_sym, :convert_h1)
end
def convert_code(el)
raw = ''
extract_text(el, raw)
result = process_text(raw, true)
begin
str = result.inject('') do |mem, c|
if c.type == :text
mem << c.value
elsif c.type == :entity
if [60, 62, 34, 38].include?(c.value.code_point)
mem << c.value.code_point.chr
else
mem << c.value.char
end
elsif c.type == :smart_quote || c.type == :typographic_sym
mem << entity(c.value.to_s).char
else
raise "Bug - please report"
end
end
result.clear
result << Element.new(:text, str)
rescue
end
if result.length > 1 || result.first.type != :text
process_html_element(el, false, true)
else
if el.value == 'code'
set_basics(el, :codespan)
el.attr['class'].gsub!(/\s+\bhighlighter-\w+\b|\bhighlighter-\w+\b\s*/, '') if el.attr['class']
else
set_basics(el, :codeblock)
if el.children.size == 1 && el.children.first.value == 'code'
value = (el.children.first.attr['class'] || '').scan(/\blanguage-\S+/).first
el.attr['class'] = "#{value} #{el.attr['class']}".rstrip if value
end
end
el.value = result.first.value
el.children.clear
end
end
alias :convert_pre :convert_code
def convert_table(el)
if !is_simple_table?(el)
process_html_element(el, false)
return
end
remove_text_children(el)
process_children(el)
set_basics(el, :table)
calc_alignment = lambda do |c|
if c.type == :tr
el.options[:alignment] = c.children.map do |td|
if td.attr['style']
td.attr['style'].slice!(/(?:;\s*)?text-align:\s+(center|left|right)/)
td.attr.delete('style') if td.attr['style'].strip.empty?
$1 ? $1.to_sym : :default
else
:default
end
end
else
c.children.each {|cc| calc_alignment.call(cc)}
end
end
calc_alignment.call(el)
el.children.delete_if {|c| c.type == :html_element}
change_th_type = lambda do |c|
if c.type == :th
c.type = :td
else
c.children.each {|cc| change_th_type.call(cc)}
end
end
change_th_type.call(el)
if el.children.first.type == :tr
tbody = Element.new(:tbody)
tbody.children = el.children
el.children = [tbody]
end
end
def is_simple_table?(el)
only_phrasing_content = lambda do |c|
c.children.all? do |cc|
(cc.type == :text || !HTML_BLOCK_ELEMENTS.include?(cc.value)) && only_phrasing_content.call(cc)
end
end
check_cells = Proc.new do |c|
if c.value == 'th' || c.value == 'td'
return false if !only_phrasing_content.call(c)
else
c.children.each {|cc| check_cells.call(cc)}
end
end
check_cells.call(el)
nr_cells = 0
check_nr_cells = lambda do |t|
if t.value == 'tr'
count = t.children.select {|cc| cc.value == 'th' || cc.value == 'td'}.length
if count != nr_cells
if nr_cells == 0
nr_cells = count
else
nr_cells = -1
break
end
end
else
t.children.each {|cc| check_nr_cells.call(cc)}
end
end
check_nr_cells.call(el)
return false if nr_cells == -1
alignment = nil
check_alignment = Proc.new do |t|
if t.value == 'tr'
cur_alignment = t.children.select {|cc| cc.value == 'th' || cc.value == 'td'}.map do |cell|
md = /text-align:\s+(center|left|right|justify|inherit)/.match(cell.attr['style'].to_s)
return false if md && (md[1] == 'justify' || md[1] == 'inherit')
md.nil? ? :default : md[1]
end
alignment = cur_alignment if alignment.nil?
return false if alignment != cur_alignment
else
t.children.each {|cc| check_alignment.call(cc)}
end
end
check_alignment.call(el)
check_rows = lambda do |t, type|
t.children.all? {|r| (r.value == 'tr' || r.type == :text) && r.children.all? {|c| c.value == type || c.type == :text}}
end
check_rows.call(el, 'td') ||
(el.children.all? do |t|
t.type == :text || (t.value == 'thead' && check_rows.call(t, 'th')) ||
((t.value == 'tfoot' || t.value == 'tbody') && check_rows.call(t, 'td'))
end && el.children.any? {|t| t.value == 'tbody'})
end
def convert_script(el)
if !is_math_tag?(el)
process_html_element(el)
else
handle_math_tag(el)
end
end
def is_math_tag?(el)
el.attr['type'].to_s =~ /\bmath\/tex\b/
end
def handle_math_tag(el)
set_basics(el, :math, :category => (el.attr['type'] =~ /mode=display/ ? :block : :span))
el.value = el.children.shift.value.sub(/\A(?:%\s*)?<!\[CDATA\[\n?(.*?)(?:\s%)?\]\]>\z/m, '\1')
el.attr.delete('type')
end
end
include Parser
# Parse the source string provided on initialization as HTML document.
def parse
@stack, @tree = [], @root
@src = Kramdown::Utils::StringScanner.new(adapt_source(source))
while true
if result = @src.scan(/\s*#{HTML_INSTRUCTION_RE}/)
@tree.children << Element.new(:xml_pi, result.strip, nil, :category => :block)
elsif result = @src.scan(/\s*#{HTML_DOCTYPE_RE}/)
# ignore the doctype
elsif result = @src.scan(/\s*#{HTML_COMMENT_RE}/)
@tree.children << Element.new(:xml_comment, result.strip, nil, :category => :block)
else
break
end
end
tag_handler = lambda do |c, closed, handle_body|
parse_raw_html(c, &tag_handler) if !closed && handle_body
end
parse_raw_html(@tree, &tag_handler)
ElementConverter.convert(@tree)
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/codespan.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/codespan.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Parser
class Kramdown
CODESPAN_DELIMITER = /`+/
# Parse the codespan at the current scanner location.
def parse_codespan
start_line_number = @src.current_line_number
result = @src.scan(CODESPAN_DELIMITER)
simple = (result.length == 1)
saved_pos = @src.save_pos
if simple && @src.pre_match =~ /\s\Z/ && @src.match?(/\s/)
add_text(result)
return
end
if text = @src.scan_until(/#{result}/)
text.sub!(/#{result}\Z/, '')
if !simple
text = text[1..-1] if text[0..0] == ' '
text = text[0..-2] if text[-1..-1] == ' '
end
@tree.children << Element.new(:codespan, text, nil, :location => start_line_number)
else
@src.revert_pos(saved_pos)
add_text(result)
end
end
define_parser(:codespan, CODESPAN_DELIMITER, '`')
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/emphasis.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/emphasis.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Parser
class Kramdown
EMPHASIS_START = /(?:\*\*?|__?)/
# Parse the emphasis at the current location.
def parse_emphasis
start_line_number = @src.current_line_number
saved_pos = @src.save_pos
result = @src.scan(EMPHASIS_START)
element = (result.length == 2 ? :strong : :em)
type = result[0..0]
if (type == '_' && @src.pre_match =~ /[[:alpha:]-]\z/) || @src.check(/\s/) ||
@tree.type == element || @stack.any? {|el, _| el.type == element}
add_text(result)
return
end
sub_parse = lambda do |delim, elem|
el = Element.new(elem, nil, nil, :location => start_line_number)
stop_re = /#{Regexp.escape(delim)}/
found = parse_spans(el, stop_re) do
(@src.pre_match[-1, 1] !~ /\s/) &&
(elem != :em || !@src.match?(/#{Regexp.escape(delim*2)}(?!#{Regexp.escape(delim)})/)) &&
(type != '_' || !@src.match?(/#{Regexp.escape(delim)}[[:alnum:]]/)) && el.children.size > 0
end
[found, el, stop_re]
end
found, el, stop_re = sub_parse.call(result, element)
if !found && element == :strong && @tree.type != :em
@src.revert_pos(saved_pos)
@src.pos += 1
found, el, stop_re = sub_parse.call(type, :em)
end
if found
@src.scan(stop_re)
@tree.children << el
else
@src.revert_pos(saved_pos)
@src.pos += result.length
add_text(result)
end
end
define_parser(:emphasis, EMPHASIS_START, '\*|_')
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/codeblock.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/codeblock.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser/kramdown/blank_line'
require 'kramdown/parser/kramdown/extensions'
require 'kramdown/parser/kramdown/eob'
require 'kramdown/parser/kramdown/paragraph'
module Kramdown
module Parser
class Kramdown
CODEBLOCK_START = INDENT
CODEBLOCK_MATCH = /(?:#{BLANK_LINE}?(?:#{INDENT}[ \t]*\S.*\n)+(?:(?!#{IAL_BLOCK_START}|#{EOB_MARKER}|^#{OPT_SPACE}#{LAZY_END_HTML_STOP}|^#{OPT_SPACE}#{LAZY_END_HTML_START})^[ \t]*\S.*\n)*)*/
# Parse the indented codeblock at the current location.
def parse_codeblock
start_line_number = @src.current_line_number
data = @src.scan(self.class::CODEBLOCK_MATCH)
data.gsub!(/\n( {0,3}\S)/, ' \\1')
data.gsub!(INDENT, '')
@tree.children << new_block_el(:codeblock, data, nil, :location => start_line_number)
true
end
define_parser(:codeblock, CODEBLOCK_START)
FENCED_CODEBLOCK_START = /^~{3,}/
FENCED_CODEBLOCK_MATCH = /^((~){3,})\s*?((\S+?)(?:\?\S*)?)?\s*?\n(.*?)^\1\2*\s*?\n/m
# Parse the fenced codeblock at the current location.
def parse_codeblock_fenced
if @src.check(self.class::FENCED_CODEBLOCK_MATCH)
start_line_number = @src.current_line_number
@src.pos += @src.matched_size
el = new_block_el(:codeblock, @src[5], nil, :location => start_line_number, :fenced => true)
lang = @src[3].to_s.strip
unless lang.empty?
el.options[:lang] = lang
el.attr['class'] = "language-#{@src[4]}"
end
@tree.children << el
true
else
false
end
end
define_parser(:codeblock_fenced, FENCED_CODEBLOCK_START)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/smart_quotes.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/smart_quotes.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
#--
# Parts of this file are based on code from RubyPants:
#
# = RubyPants -- SmartyPants ported to Ruby
#
# Ported by Christian Neukirchen <mailto:chneukirchen@gmail.com>
# Copyright (C) 2004 Christian Neukirchen
#
# Incooporates ideas, comments and documentation by Chad Miller
# Copyright (C) 2004 Chad Miller
#
# Original SmartyPants by John Gruber
# Copyright (C) 2003 John Gruber
#
#
# = RubyPants -- SmartyPants ported to Ruby
#
#
# [snip]
#
# == Authors
#
# John Gruber did all of the hard work of writing this software in
# Perl for Movable Type and almost all of this useful documentation.
# Chad Miller ported it to Python to use with Pyblosxom.
#
# Christian Neukirchen provided the Ruby port, as a general-purpose
# library that follows the *Cloth API.
#
#
# == Copyright and License
#
# === SmartyPants license:
#
# Copyright (c) 2003 John Gruber
# (http://daringfireball.net)
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
#
# * Neither the name "SmartyPants" nor the names of its contributors
# may be used to endorse or promote products derived from this
# software without specific prior written permission.
#
# This software is provided by the copyright holders and contributors
# "as is" and any express or implied warranties, including, but not
# limited to, the implied warranties of merchantability and fitness
# for a particular purpose are disclaimed. In no event shall the
# copyright owner or contributors be liable for any direct, indirect,
# incidental, special, exemplary, or consequential damages (including,
# but not limited to, procurement of substitute goods or services;
# loss of use, data, or profits; or business interruption) however
# caused and on any theory of liability, whether in contract, strict
# liability, or tort (including negligence or otherwise) arising in
# any way out of the use of this software, even if advised of the
# possibility of such damage.
#
# === RubyPants license
#
# RubyPants is a derivative work of SmartyPants and smartypants.py.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
#
# This software is provided by the copyright holders and contributors
# "as is" and any express or implied warranties, including, but not
# limited to, the implied warranties of merchantability and fitness
# for a particular purpose are disclaimed. In no event shall the
# copyright owner or contributors be liable for any direct, indirect,
# incidental, special, exemplary, or consequential damages (including,
# but not limited to, procurement of substitute goods or services;
# loss of use, data, or profits; or business interruption) however
# caused and on any theory of liability, whether in contract, strict
# liability, or tort (including negligence or otherwise) arising in
# any way out of the use of this software, even if advised of the
# possibility of such damage.
#
# == Links
#
# John Gruber:: http://daringfireball.net
# SmartyPants:: http://daringfireball.net/projects/smartypants
#
# Chad Miller:: http://web.chad.org
#
# Christian Neukirchen:: http://kronavita.de/chris
#
#++
#
module Kramdown
module Parser
class Kramdown
SQ_PUNCT = '[!"#\$\%\'()*+,\-.\/:;<=>?\@\[\\\\\]\^_`{|}~]'
SQ_CLOSE = %![^\ \\\\\t\r\n\\[{(-]!
SQ_RULES = [
[/("|')(?=[_*]{1,2}\S)/, [:lquote1]],
[/("|')(?=#{SQ_PUNCT}(?!\.\.)\B)/, [:rquote1]],
# Special case for double sets of quotes, e.g.:
# <p>He said, "'Quoted' words in a larger quote."</p>
[/(\s?)"'(?=\w)/, [1, :ldquo, :lsquo]],
[/(\s?)'"(?=\w)/, [1, :lsquo, :ldquo]],
# Special case for decade abbreviations (the '80s):
[/(\s?)'(?=\d\ds)/, [1, :rsquo]],
# Get most opening single/double quotes:
[/(\s)('|")(?=\w)/, [1, :lquote2]],
# Single/double closing quotes:
[/(#{SQ_CLOSE})('|")/, [1, :rquote2]],
# Special case for e.g. "<i>Custer</i>'s Last Stand."
[/("|')(?=\s|s\b|$)/, [:rquote1]],
# Any remaining single quotes should be opening ones:
[/(.?)'/m, [1, :lsquo]],
[/(.?)"/m, [1, :ldquo]],
] #'"
SQ_SUBSTS = {
[:rquote1, '"'] => :rdquo,
[:rquote1, "'"] => :rsquo,
[:rquote2, '"'] => :rdquo,
[:rquote2, "'"] => :rsquo,
[:lquote1, '"'] => :ldquo,
[:lquote1, "'"] => :lsquo,
[:lquote2, '"'] => :ldquo,
[:lquote2, "'"] => :lsquo,
}
SMART_QUOTES_RE = /[^\\]?["']/
# Parse the smart quotes at current location.
def parse_smart_quotes
start_line_number = @src.current_line_number
substs = SQ_RULES.find {|reg, subst| @src.scan(reg)}[1]
substs.each do |subst|
if subst.kind_of?(Integer)
add_text(@src[subst])
else
val = SQ_SUBSTS[[subst, @src[subst.to_s[-1,1].to_i]]] || subst
@tree.children << Element.new(:smart_quote, val, nil, :location => start_line_number)
end
end
end
define_parser(:smart_quotes, SMART_QUOTES_RE, '[^\\\\]?["\']')
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/escaped_chars.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/escaped_chars.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Parser
class Kramdown
ESCAPED_CHARS = /\\([\\.*_+`<>()\[\]{}#!:|"'\$=-])/
# Parse the backslash-escaped character at the current location.
def parse_escaped_chars
@src.pos += @src.matched_size
add_text(@src[1])
end
define_parser(:escaped_chars, ESCAPED_CHARS, '\\\\')
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/table.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/table.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser/kramdown/block_boundary'
module Kramdown
module Parser
class Kramdown
TABLE_SEP_LINE = /^([+|: \t-]*?-[+|: \t-]*?)[ \t]*\n/
TABLE_HSEP_ALIGN = /[ \t]?(:?)-+(:?)[ \t]?/
TABLE_FSEP_LINE = /^[+|: \t=]*?=[+|: \t=]*?[ \t]*\n/
TABLE_ROW_LINE = /^(.*?)[ \t]*\n/
TABLE_PIPE_CHECK = /(?:\||.*?[^\\\n]\|)/
TABLE_LINE = /#{TABLE_PIPE_CHECK}.*?\n/
TABLE_START = /^#{OPT_SPACE}(?=\S)#{TABLE_LINE}/
# Parse the table at the current location.
def parse_table
return false if !after_block_boundary?
saved_pos = @src.save_pos
orig_pos = @src.pos
table = new_block_el(:table, nil, nil, :alignment => [], :location => @src.current_line_number)
leading_pipe = (@src.check(TABLE_LINE) =~ /^\s*\|/)
@src.scan(TABLE_SEP_LINE)
rows = []
has_footer = false
columns = 0
add_container = lambda do |type, force|
if !has_footer || type != :tbody || force
cont = Element.new(type)
cont.children, rows = rows, []
table.children << cont
end
end
while !@src.eos?
break if !@src.check(TABLE_LINE)
if @src.scan(TABLE_SEP_LINE)
if rows.empty?
# nothing to do, ignoring multiple consecutive separator lines
elsif table.options[:alignment].empty? && !has_footer
add_container.call(:thead, false)
table.options[:alignment] = @src[1].scan(TABLE_HSEP_ALIGN).map do |left, right|
(left.empty? && right.empty? && :default) || (right.empty? && :left) || (left.empty? && :right) || :center
end
else # treat as normal separator line
add_container.call(:tbody, false)
end
elsif @src.scan(TABLE_FSEP_LINE)
add_container.call(:tbody, true) if !rows.empty?
has_footer = true
elsif @src.scan(TABLE_ROW_LINE)
trow = Element.new(:tr)
# parse possible code spans on the line and correctly split the line into cells
env = save_env
cells = []
@src[1].split(/(<code.*?>.*?<\/code>)/).each_with_index do |str, i|
if i % 2 == 1
(cells.empty? ? cells : cells.last) << str
else
reset_env(:src => Kramdown::Utils::StringScanner.new(str, @src.current_line_number))
root = Element.new(:root)
parse_spans(root, nil, [:codespan])
root.children.each do |c|
if c.type == :raw_text
f, *l = c.value.split(/(?<!\\)\|/, -1).map {|t| t.gsub(/\\\|/, '|')}
(cells.empty? ? cells : cells.last) << f
cells.concat(l)
else
delim = (c.value.scan(/`+/).max || '') + '`'
tmp = "#{delim}#{' ' if delim.size > 1}#{c.value}#{' ' if delim.size > 1}#{delim}"
(cells.empty? ? cells : cells.last) << tmp
end
end
end
end
restore_env(env)
cells.shift if leading_pipe && cells.first.strip.empty?
cells.pop if cells.last.strip.empty?
cells.each do |cell_text|
tcell = Element.new(:td)
tcell.children << Element.new(:raw_text, cell_text.strip)
trow.children << tcell
end
columns = [columns, cells.length].max
rows << trow
else
break
end
end
if !before_block_boundary?
@src.revert_pos(saved_pos)
return false
end
# Parse all lines of the table with the code span parser
env = save_env
l_src = ::Kramdown::Utils::StringScanner.new(extract_string(orig_pos...(@src.pos-1), @src),
@src.current_line_number)
reset_env(:src => l_src)
root = Element.new(:root)
parse_spans(root, nil, [:codespan, :span_html])
restore_env(env)
# Check if each line has at least one unescaped pipe that is not inside a code span/code
# HTML element
# Note: It doesn't matter that we parse *all* span HTML elements because the row splitting
# algorithm above only takes <code> elements into account!
pipe_on_line = false
while (c = root.children.shift)
next unless (lines = c.value)
lines = lines.split("\n")
if c.type == :codespan
if lines.size > 2 || (lines.size == 2 && !pipe_on_line)
break
elsif lines.size == 2 && pipe_on_line
pipe_on_line = false
end
else
break if lines.size > 1 && !pipe_on_line && lines.first !~ /^#{TABLE_PIPE_CHECK}/
pipe_on_line = (lines.size > 1 ? false : pipe_on_line) || (lines.last =~ /^#{TABLE_PIPE_CHECK}/)
end
end
@src.revert_pos(saved_pos) and return false if !pipe_on_line
add_container.call(has_footer ? :tfoot : :tbody, false) if !rows.empty?
if !table.children.any? {|el| el.type == :tbody}
warning("Found table without body on line #{table.options[:location]} - ignoring it")
@src.revert_pos(saved_pos)
return false
end
# adjust all table rows to have equal number of columns, same for alignment defs
table.children.each do |kind|
kind.children.each do |row|
(columns - row.children.length).times do
row.children << Element.new(:td)
end
end
end
if table.options[:alignment].length > columns
table.options[:alignment] = table.options[:alignment][0...columns]
else
table.options[:alignment] += [:default] * (columns - table.options[:alignment].length)
end
@tree.children << table
true
end
define_parser(:table, TABLE_START)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/extensions.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/extensions.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Parser
class Kramdown
IAL_CLASS_ATTR = 'class'
# Parse the string +str+ and extract all attributes and add all found attributes to the hash
# +opts+.
def parse_attribute_list(str, opts)
return if str.strip.empty? || str.strip == ':'
attrs = str.scan(ALD_TYPE_ANY)
attrs.each do |key, sep, val, ref, id_and_or_class, _, _|
if ref
(opts[:refs] ||= []) << ref
elsif id_and_or_class
id_and_or_class.scan(ALD_TYPE_ID_OR_CLASS).each do |id_attr, class_attr|
if class_attr
opts[IAL_CLASS_ATTR] = (opts[IAL_CLASS_ATTR] || '') << " #{class_attr}"
opts[IAL_CLASS_ATTR].lstrip!
else
opts['id'] = id_attr
end
end
else
val.gsub!(/\\(\}|#{sep})/, "\\1")
opts[key] = val
end
end
warning("No or invalid attributes found in IAL/ALD content: #{str}") if attrs.length == 0
end
# Update the +ial+ with the information from the inline attribute list +opts+.
def update_ial_with_ial(ial, opts)
(ial[:refs] ||= []) << opts[:refs]
opts.each do |k,v|
if k == IAL_CLASS_ATTR
ial[k] = (ial[k] || '') << " #{v}"
ial[k].lstrip!
elsif k.kind_of?(String)
ial[k] = v
end
end
end
# Parse the generic extension at the current point. The parameter +type+ can either be :block
# or :span depending whether we parse a block or span extension tag.
def parse_extension_start_tag(type)
saved_pos = @src.save_pos
start_line_number = @src.current_line_number
@src.pos += @src.matched_size
error_block = lambda do |msg|
warning(msg)
@src.revert_pos(saved_pos)
add_text(@src.getch) if type == :span
false
end
if @src[4] || @src.matched == '{:/}'
name = (@src[4] ? "for '#{@src[4]}' " : '')
return error_block.call("Invalid extension stop tag #{name} found on line #{start_line_number} - ignoring it")
end
ext = @src[1]
opts = {}
body = nil
parse_attribute_list(@src[2] || '', opts)
if !@src[3]
stop_re = (type == :block ? /#{EXT_BLOCK_STOP_STR % ext}/ : /#{EXT_STOP_STR % ext}/)
if result = @src.scan_until(stop_re)
body = result.sub!(stop_re, '')
body.chomp! if type == :block
else
return error_block.call("No stop tag for extension '#{ext}' found on line #{start_line_number} - ignoring it")
end
end
if !handle_extension(ext, opts, body, type, start_line_number)
error_block.call("Invalid extension with name '#{ext}' specified on line #{start_line_number} - ignoring it")
else
true
end
end
def handle_extension(name, opts, body, type, line_no = nil)
case name
when 'comment'
@tree.children << Element.new(:comment, body, nil, :category => type, :location => line_no) if body.kind_of?(String)
true
when 'nomarkdown'
@tree.children << Element.new(:raw, body, nil, :category => type, :location => line_no, :type => opts['type'].to_s.split(/\s+/)) if body.kind_of?(String)
true
when 'options'
opts.select do |k,v|
k = k.to_sym
if Kramdown::Options.defined?(k)
begin
val = Kramdown::Options.parse(k, v)
@options[k] = val
(@root.options[:options] ||= {})[k] = val
rescue
end
false
else
true
end
end.each do |k,v|
warning("Unknown kramdown option '#{k}'")
end
@tree.children << new_block_el(:eob, :extension) if type == :block
true
else
false
end
end
ALD_ID_CHARS = /[\w-]/
ALD_ANY_CHARS = /\\\}|[^\}]/
ALD_ID_NAME = /\w#{ALD_ID_CHARS}*/
ALD_CLASS_NAME = /[^\s\.#]+/
ALD_TYPE_KEY_VALUE_PAIR = /(#{ALD_ID_NAME})=("|')((?:\\\}|\\\2|[^\}\2])*?)\2/
ALD_TYPE_CLASS_NAME = /\.(#{ALD_CLASS_NAME})/
ALD_TYPE_ID_NAME = /#([A-Za-z][\w:-]*)/
ALD_TYPE_ID_OR_CLASS = /#{ALD_TYPE_ID_NAME}|#{ALD_TYPE_CLASS_NAME}/
ALD_TYPE_ID_OR_CLASS_MULTI = /((?:#{ALD_TYPE_ID_NAME}|#{ALD_TYPE_CLASS_NAME})+)/
ALD_TYPE_REF = /(#{ALD_ID_NAME})/
ALD_TYPE_ANY = /(?:\A|\s)(?:#{ALD_TYPE_KEY_VALUE_PAIR}|#{ALD_TYPE_REF}|#{ALD_TYPE_ID_OR_CLASS_MULTI})(?=\s|\Z)/
ALD_START = /^#{OPT_SPACE}\{:(#{ALD_ID_NAME}):(#{ALD_ANY_CHARS}+)\}\s*?\n/
EXT_STOP_STR = "\\{:/(%s)?\\}"
EXT_START_STR = "\\{::(\\w+)(?:\\s(#{ALD_ANY_CHARS}*?)|)(\\/)?\\}"
EXT_BLOCK_START = /^#{OPT_SPACE}(?:#{EXT_START_STR}|#{EXT_STOP_STR % ALD_ID_NAME})\s*?\n/
EXT_BLOCK_STOP_STR = "^#{OPT_SPACE}#{EXT_STOP_STR}\s*?\n"
IAL_BLOCK = /\{:(?!:|\/)(#{ALD_ANY_CHARS}+)\}\s*?\n/
IAL_BLOCK_START = /^#{OPT_SPACE}#{IAL_BLOCK}/
BLOCK_EXTENSIONS_START = /^#{OPT_SPACE}\{:/
# Parse one of the block extensions (ALD, block IAL or generic extension) at the current
# location.
def parse_block_extensions
if @src.scan(ALD_START)
parse_attribute_list(@src[2], @alds[@src[1]] ||= Utils::OrderedHash.new)
@tree.children << new_block_el(:eob, :ald)
true
elsif @src.check(EXT_BLOCK_START)
parse_extension_start_tag(:block)
elsif @src.scan(IAL_BLOCK_START)
if @tree.children.last && @tree.children.last.type != :blank &&
(@tree.children.last.type != :eob || [:link_def, :abbrev_def, :footnote_def].include?(@tree.children.last.value))
parse_attribute_list(@src[1], @tree.children.last.options[:ial] ||= Utils::OrderedHash.new)
@tree.children << new_block_el(:eob, :ial) unless @src.check(IAL_BLOCK_START)
else
parse_attribute_list(@src[1], @block_ial ||= Utils::OrderedHash.new)
end
true
else
false
end
end
define_parser(:block_extensions, BLOCK_EXTENSIONS_START)
EXT_SPAN_START = /#{EXT_START_STR}|#{EXT_STOP_STR % ALD_ID_NAME}/
IAL_SPAN_START = /\{:(#{ALD_ANY_CHARS}+)\}/
SPAN_EXTENSIONS_START = /\{:/
# Parse the extension span at the current location.
def parse_span_extensions
if @src.check(EXT_SPAN_START)
parse_extension_start_tag(:span)
elsif @src.check(IAL_SPAN_START)
if @tree.children.last && @tree.children.last.type != :text
@src.pos += @src.matched_size
attr = Utils::OrderedHash.new
parse_attribute_list(@src[1], attr)
update_ial_with_ial(@tree.children.last.options[:ial] ||= Utils::OrderedHash.new, attr)
update_attr_with_ial(@tree.children.last.attr, attr)
else
warning("Found span IAL after text - ignoring it")
add_text(@src.getch)
end
else
add_text(@src.getch)
end
end
define_parser(:span_extensions, SPAN_EXTENSIONS_START, '\{:')
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/horizontal_rule.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/horizontal_rule.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Parser
class Kramdown
HR_START = /^#{OPT_SPACE}(\*|-|_)[ \t]*\1[ \t]*\1(\1|[ \t])*\n/
# Parse the horizontal rule at the current location.
def parse_horizontal_rule
start_line_number = @src.current_line_number
@src.pos += @src.matched_size
@tree.children << new_block_el(:hr, nil, nil, :location => start_line_number)
true
end
define_parser(:horizontal_rule, HR_START)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/math.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/math.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser/kramdown/block_boundary'
module Kramdown
module Parser
class Kramdown
BLOCK_MATH_START = /^#{OPT_SPACE}(\\)?\$\$(.*?)\$\$(\s*?\n)?/m
# Parse the math block at the current location.
def parse_block_math
start_line_number = @src.current_line_number
if !after_block_boundary?
return false
elsif @src[1]
@src.scan(/^#{OPT_SPACE}\\/) if @src[3]
return false
end
saved_pos = @src.save_pos
@src.pos += @src.matched_size
data = @src[2].strip
if before_block_boundary?
@tree.children << new_block_el(:math, data, nil, :category => :block, :location => start_line_number)
true
else
@src.revert_pos(saved_pos)
false
end
end
define_parser(:block_math, BLOCK_MATH_START)
INLINE_MATH_START = /\$\$(.*?)\$\$/m
# Parse the inline math at the current location.
def parse_inline_math
start_line_number = @src.current_line_number
@src.pos += @src.matched_size
@tree.children << Element.new(:math, @src[1].strip, nil, :category => :span, :location => start_line_number)
end
define_parser(:inline_math, INLINE_MATH_START, '\$')
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/autolink.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/autolink.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Parser
class Kramdown
ACHARS = '[[:alnum:]]_'
AUTOLINK_START_STR = "<((mailto|https?|ftps?):.+?|[-.#{ACHARS}]+@[-#{ACHARS}]+(?:\.[-#{ACHARS}]+)*\.[a-z]+)>"
AUTOLINK_START = /#{AUTOLINK_START_STR}/u
# Parse the autolink at the current location.
def parse_autolink
start_line_number = @src.current_line_number
@src.pos += @src.matched_size
href = (@src[2].nil? ? "mailto:#{@src[1]}" : @src[1])
el = Element.new(:a, nil, {'href' => href}, :location => start_line_number)
add_text(@src[1].sub(/^mailto:/, ''), el)
@tree.children << el
end
define_parser(:autolink, AUTOLINK_START, '<')
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/line_break.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/line_break.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Parser
class Kramdown
LINE_BREAK = /( |\\\\)(?=\n)/
# Parse the line break at the current location.
def parse_line_break
@tree.children << Element.new(:br, nil, nil, :location => @src.current_line_number)
@src.pos += @src.matched_size
end
define_parser(:line_break, LINE_BREAK, '( |\\\\)(?=\n)')
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/link.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/link.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser/kramdown/escaped_chars'
module Kramdown
module Parser
class Kramdown
# Normalize the link identifier.
def normalize_link_id(id)
id.gsub(/[\s]+/, ' ').downcase
end
LINK_DEFINITION_START = /^#{OPT_SPACE}\[([^\n\]]+)\]:[ \t]*(?:<(.*?)>|([^\n]*?\S[^\n]*?))(?:(?:[ \t]*?\n|[ \t]+?)[ \t]*?(["'])(.+?)\4)?[ \t]*?\n/
# Parse the link definition at the current location.
def parse_link_definition
return false if @src[3].to_s =~ /[ \t]+["']/
@src.pos += @src.matched_size
link_id, link_url, link_title = normalize_link_id(@src[1]), @src[2] || @src[3], @src[5]
warning("Duplicate link ID '#{link_id}' on line #{@src.current_line_number} - overwriting") if @link_defs[link_id]
@tree.children << new_block_el(:eob, :link_def)
@link_defs[link_id] = [link_url, link_title, @tree.children.last]
true
end
define_parser(:link_definition, LINK_DEFINITION_START)
# This helper methods adds the approriate attributes to the element +el+ of type +a+ or +img+
# and the element itself to the @tree.
def add_link(el, href, title, alt_text = nil, ial = nil)
el.options[:ial] = ial
update_attr_with_ial(el.attr, ial) if ial
if el.type == :a
el.attr['href'] = href
else
el.attr['src'] = href
el.attr['alt'] = alt_text
el.children.clear
end
el.attr['title'] = title if title
@tree.children << el
end
LINK_BRACKET_STOP_RE = /(\])|!?\[/
LINK_PAREN_STOP_RE = /(\()|(\))|\s(?=['"])/
LINK_INLINE_ID_RE = /\s*?\[([^\]]+)?\]/
LINK_INLINE_TITLE_RE = /\s*?(["'])(.+?)\1\s*?\)/m
LINK_START = /!?\[(?=[^^])/
# Parse the link at the current scanner position. This method is used to parse normal links as
# well as image links.
def parse_link
start_line_number = @src.current_line_number
result = @src.scan(LINK_START)
cur_pos = @src.pos
saved_pos = @src.save_pos
link_type = (result =~ /^!/ ? :img : :a)
# no nested links allowed
if link_type == :a && (@tree.type == :img || @tree.type == :a || @stack.any? {|t,s| t && (t.type == :img || t.type == :a)})
add_text(result)
return
end
el = Element.new(link_type, nil, nil, :location => start_line_number)
count = 1
found = parse_spans(el, LINK_BRACKET_STOP_RE) do
count = count + (@src[1] ? -1 : 1)
count - el.children.select {|c| c.type == :img}.size == 0
end
unless found
@src.revert_pos(saved_pos)
add_text(result)
return
end
alt_text = extract_string(cur_pos...@src.pos, @src).gsub(ESCAPED_CHARS, '\1')
@src.scan(LINK_BRACKET_STOP_RE)
# reference style link or no link url
if @src.scan(LINK_INLINE_ID_RE) || !@src.check(/\(/)
emit_warning = !@src[1]
link_id = normalize_link_id(@src[1] || alt_text)
if @link_defs.has_key?(link_id)
add_link(el, @link_defs[link_id][0], @link_defs[link_id][1], alt_text,
@link_defs[link_id][2] && @link_defs[link_id][2].options[:ial])
else
if emit_warning
warning("No link definition for link ID '#{link_id}' found on line #{start_line_number}")
end
@src.revert_pos(saved_pos)
add_text(result)
end
return
end
# link url in parentheses
if @src.scan(/\(<(.*?)>/)
link_url = @src[1]
if @src.scan(/\)/)
add_link(el, link_url, nil, alt_text)
return
end
else
link_url = ''
nr_of_brackets = 0
while temp = @src.scan_until(LINK_PAREN_STOP_RE)
link_url << temp
if @src[2]
nr_of_brackets -= 1
break if nr_of_brackets == 0
elsif @src[1]
nr_of_brackets += 1
else
break
end
end
link_url = link_url[1..-2]
link_url.strip!
if nr_of_brackets == 0
add_link(el, link_url, nil, alt_text)
return
end
end
if @src.scan(LINK_INLINE_TITLE_RE)
add_link(el, link_url, @src[2], alt_text)
else
@src.revert_pos(saved_pos)
add_text(result)
end
end
define_parser(:link, LINK_START, '!?\[')
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/blockquote.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/blockquote.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser/kramdown/blank_line'
require 'kramdown/parser/kramdown/extensions'
require 'kramdown/parser/kramdown/eob'
module Kramdown
module Parser
class Kramdown
BLOCKQUOTE_START = /^#{OPT_SPACE}> ?/
# Parse the blockquote at the current location.
def parse_blockquote
start_line_number = @src.current_line_number
result = @src.scan(PARAGRAPH_MATCH)
while !@src.match?(self.class::LAZY_END)
result << @src.scan(PARAGRAPH_MATCH)
end
result.gsub!(BLOCKQUOTE_START, '')
el = new_block_el(:blockquote, nil, nil, :location => start_line_number)
@tree.children << el
parse_blocks(el, result)
true
end
define_parser(:blockquote, BLOCKQUOTE_START)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/eob.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/eob.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Parser
class Kramdown
EOB_MARKER = /^\^\s*?\n/
# Parse the EOB marker at the current location.
def parse_eob_marker
@src.pos += @src.matched_size
@tree.children << new_block_el(:eob)
true
end
define_parser(:eob_marker, EOB_MARKER)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/typographic_symbol.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/typographic_symbol.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Parser
class Kramdown
TYPOGRAPHIC_SYMS = [['---', :mdash], ['--', :ndash], ['...', :hellip],
['\\<<', '<<'], ['\\>>', '>>'],
['<< ', :laquo_space], [' >>', :raquo_space],
['<<', :laquo], ['>>', :raquo]]
TYPOGRAPHIC_SYMS_SUBST = Hash[*TYPOGRAPHIC_SYMS.flatten]
TYPOGRAPHIC_SYMS_RE = /#{TYPOGRAPHIC_SYMS.map {|k,v| Regexp.escape(k)}.join('|')}/
# Parse the typographic symbols at the current location.
def parse_typographic_syms
start_line_number = @src.current_line_number
@src.pos += @src.matched_size
val = TYPOGRAPHIC_SYMS_SUBST[@src.matched]
if val.kind_of?(Symbol)
@tree.children << Element.new(:typographic_sym, val, nil, :location => start_line_number)
elsif @src.matched == '\\<<'
@tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('lt'),
nil, :location => start_line_number)
@tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('lt'),
nil, :location => start_line_number)
else
@tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('gt'),
nil, :location => start_line_number)
@tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('gt'),
nil, :location => start_line_number)
end
end
define_parser(:typographic_syms, TYPOGRAPHIC_SYMS_RE, '--|\\.\\.\\.|(?:\\\\| )?(?:<<|>>)')
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/list.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/list.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser/kramdown/blank_line'
require 'kramdown/parser/kramdown/eob'
require 'kramdown/parser/kramdown/horizontal_rule'
require 'kramdown/parser/kramdown/extensions'
module Kramdown
module Parser
class Kramdown
LIST_ITEM_IAL = /^\s*(?:\{:(?!(?:#{ALD_ID_NAME})?:|\/)(#{ALD_ANY_CHARS}+)\})\s*/
LIST_ITEM_IAL_CHECK = /^#{LIST_ITEM_IAL}?\s*\n/
PARSE_FIRST_LIST_LINE_REGEXP_CACHE = Hash.new do |h, indentation|
indent_re = /^ {#{indentation}}/
content_re = /^(?:(?:\t| {4}){#{indentation / 4}} {#{indentation % 4}}|(?:\t| {4}){#{indentation / 4 + 1}}).*\S.*\n/
lazy_re = /(?!^ {0,#{[indentation, 3].min}}(?:#{IAL_BLOCK}|#{LAZY_END_HTML_STOP}|#{LAZY_END_HTML_START})).*\S.*\n/
h[indentation] = [content_re, lazy_re, indent_re]
end
# Used for parsing the first line of a list item or a definition, i.e. the line with list item
# marker or the definition marker.
def parse_first_list_line(indentation, content)
if content =~ self.class::LIST_ITEM_IAL_CHECK
indentation = 4
else
while content =~ /^ *\t/
temp = content.scan(/^ */).first.length + indentation
content.sub!(/^( *)(\t+)/) {$1 << " "*(4 - (temp % 4) + ($2.length - 1)*4)}
end
indentation += content[/^ */].length
end
content.sub!(/^\s*/, '')
[content, indentation, *PARSE_FIRST_LIST_LINE_REGEXP_CACHE[indentation]]
end
LIST_START_UL = /^(#{OPT_SPACE}[+*-])([\t| ].*?\n)/
LIST_START_OL = /^(#{OPT_SPACE}\d+\.)([\t| ].*?\n)/
LIST_START = /#{LIST_START_UL}|#{LIST_START_OL}/
# Parse the ordered or unordered list at the current location.
def parse_list
start_line_number = @src.current_line_number
type, list_start_re = (@src.check(LIST_START_UL) ? [:ul, LIST_START_UL] : [:ol, LIST_START_OL])
list = new_block_el(type, nil, nil, :location => start_line_number)
item = nil
content_re, lazy_re, indent_re = nil
eob_found = false
nested_list_found = false
last_is_blank = false
while !@src.eos?
start_line_number = @src.current_line_number
if last_is_blank && @src.check(HR_START)
break
elsif @src.scan(EOB_MARKER)
eob_found = true
break
elsif @src.scan(list_start_re)
item = Element.new(:li, nil, nil, :location => start_line_number)
item.value, indentation, content_re, lazy_re, indent_re = parse_first_list_line(@src[1].length, @src[2])
list.children << item
item.value.sub!(self.class::LIST_ITEM_IAL) do |match|
parse_attribute_list($1, item.options[:ial] ||= {})
''
end
list_start_re = (type == :ul ? /^( {0,#{[3, indentation - 1].min}}[+*-])([\t| ].*?\n)/ :
/^( {0,#{[3, indentation - 1].min}}\d+\.)([\t| ].*?\n)/)
nested_list_found = (item.value =~ LIST_START)
last_is_blank = false
item.value = [item.value]
elsif (result = @src.scan(content_re)) || (!last_is_blank && (result = @src.scan(lazy_re)))
result.sub!(/^(\t+)/) { " " * 4 * $1.length }
indentation_found = result.sub!(indent_re, '')
if !nested_list_found && indentation_found && result =~ LIST_START
item.value << ''
nested_list_found = true
elsif nested_list_found && !indentation_found && result =~ LIST_START
result = " " * (indentation + 4) << result
end
item.value.last << result
last_is_blank = false
elsif result = @src.scan(BLANK_LINE)
nested_list_found = true
last_is_blank = true
item.value.last << result
else
break
end
end
@tree.children << list
last = nil
list.children.each do |it|
temp = Element.new(:temp, nil, nil, :location => it.options[:location])
env = save_env
location = it.options[:location]
it.value.each do |val|
@src = ::Kramdown::Utils::StringScanner.new(val, location)
parse_blocks(temp)
location = @src.current_line_number
end
restore_env(env)
it.children = temp.children
it.value = nil
next if it.children.size == 0
# Handle the case where an EOB marker is inserted by a block IAL for the first paragraph
it.children.delete_at(1) if it.children.first.type == :p &&
it.children.length >= 2 && it.children[1].type == :eob && it.children.first.options[:ial]
if it.children.first.type == :p &&
(it.children.length < 2 || it.children[1].type != :blank ||
(it == list.children.last && it.children.length == 2 && !eob_found)) &&
(list.children.last != it || list.children.size == 1 ||
list.children[0..-2].any? {|cit| !cit.children.first || cit.children.first.type != :p || cit.children.first.options[:transparent]})
it.children.first.children.first.value << "\n" if it.children.size > 1 && it.children[1].type != :blank
it.children.first.options[:transparent] = true
end
if it.children.last.type == :blank
last = it.children.pop
else
last = nil
end
end
@tree.children << last if !last.nil? && !eob_found
true
end
define_parser(:list, LIST_START)
DEFINITION_LIST_START = /^(#{OPT_SPACE}:)([\t| ].*?\n)/
# Parse the ordered or unordered list at the current location.
def parse_definition_list
children = @tree.children
if !children.last || (children.length == 1 && children.last.type != :p ) ||
(children.length >= 2 && children[-1].type != :p && (children[-1].type != :blank || children[-1].value != "\n" || children[-2].type != :p))
return false
end
first_as_para = false
deflist = new_block_el(:dl)
para = @tree.children.pop
if para.type == :blank
para = @tree.children.pop
first_as_para = true
end
deflist.options[:location] = para.options[:location] # take location from preceding para which is the first definition term
para.children.first.value.split(/\n/).each do |term|
el = Element.new(:dt, nil, nil, :location => @src.current_line_number)
term.sub!(self.class::LIST_ITEM_IAL) do
parse_attribute_list($1, el.options[:ial] ||= {})
''
end
el.options[:raw_text] = term
el.children << Element.new(:raw_text, term)
deflist.children << el
end
deflist.options[:ial] = para.options[:ial]
item = nil
content_re, lazy_re, indent_re = nil
def_start_re = DEFINITION_LIST_START
last_is_blank = false
while !@src.eos?
start_line_number = @src.current_line_number
if @src.scan(def_start_re)
item = Element.new(:dd, nil, nil, :location => start_line_number)
item.options[:first_as_para] = first_as_para
item.value, indentation, content_re, lazy_re, indent_re = parse_first_list_line(@src[1].length, @src[2])
deflist.children << item
item.value.sub!(self.class::LIST_ITEM_IAL) do |match|
parse_attribute_list($1, item.options[:ial] ||= {})
''
end
def_start_re = /^( {0,#{[3, indentation - 1].min}}:)([\t| ].*?\n)/
first_as_para = false
last_is_blank = false
elsif @src.check(EOB_MARKER)
break
elsif (result = @src.scan(content_re)) || (!last_is_blank && (result = @src.scan(lazy_re)))
result.sub!(/^(\t+)/) { " "*($1 ? 4*$1.length : 0) }
result.sub!(indent_re, '')
item.value << result
first_as_para = false
last_is_blank = false
elsif result = @src.scan(BLANK_LINE)
first_as_para = true
item.value << result
last_is_blank = true
else
break
end
end
last = nil
deflist.children.each do |it|
next if it.type == :dt
parse_blocks(it, it.value)
it.value = nil
next if it.children.size == 0
if it.children.last.type == :blank
last = it.children.pop
else
last = nil
end
if it.children.first && it.children.first.type == :p && !it.options.delete(:first_as_para)
it.children.first.children.first.value << "\n" if it.children.size > 1
it.children.first.options[:transparent] = true
end
end
if @tree.children.length >= 1 && @tree.children.last.type == :dl
@tree.children[-1].children.concat(deflist.children)
elsif @tree.children.length >= 2 && @tree.children[-1].type == :blank && @tree.children[-2].type == :dl
@tree.children.pop
@tree.children[-1].children.concat(deflist.children)
else
@tree.children << deflist
end
@tree.children << last if !last.nil?
true
end
define_parser(:definition_list, DEFINITION_LIST_START)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/paragraph.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/paragraph.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser/kramdown/blank_line'
require 'kramdown/parser/kramdown/extensions'
require 'kramdown/parser/kramdown/eob'
require 'kramdown/parser/kramdown/list'
require 'kramdown/parser/kramdown/html'
module Kramdown
module Parser
class Kramdown
LAZY_END_HTML_SPAN_ELEMENTS = HTML_SPAN_ELEMENTS + %w{script}
LAZY_END_HTML_START = /<(?>(?!(?:#{LAZY_END_HTML_SPAN_ELEMENTS.join('|')})\b)#{REXML::Parsers::BaseParser::UNAME_STR})/
LAZY_END_HTML_STOP = /<\/(?!(?:#{LAZY_END_HTML_SPAN_ELEMENTS.join('|')})\b)#{REXML::Parsers::BaseParser::UNAME_STR}\s*>/m
LAZY_END = /#{BLANK_LINE}|#{IAL_BLOCK_START}|#{EOB_MARKER}|^#{OPT_SPACE}#{LAZY_END_HTML_STOP}|^#{OPT_SPACE}#{LAZY_END_HTML_START}|\Z/
PARAGRAPH_START = /^#{OPT_SPACE}[^ \t].*?\n/
PARAGRAPH_MATCH = /^.*?\n/
PARAGRAPH_END = /#{LAZY_END}|#{DEFINITION_LIST_START}/
# Parse the paragraph at the current location.
def parse_paragraph
pos = @src.pos
start_line_number = @src.current_line_number
result = @src.scan(PARAGRAPH_MATCH)
while !@src.match?(paragraph_end)
result << @src.scan(PARAGRAPH_MATCH)
end
result.rstrip!
if @tree.children.last && @tree.children.last.type == :p
last_item_in_para = @tree.children.last.children.last
if last_item_in_para && last_item_in_para.type == @text_type
joiner = (extract_string((pos - 3)...pos, @src) == " \n" ? " \n" : "\n")
last_item_in_para.value << joiner << result
else
add_text(result, @tree.children.last)
end
else
@tree.children << new_block_el(:p, nil, nil, :location => start_line_number)
result.lstrip!
add_text(result, @tree.children.last)
end
true
end
define_parser(:paragraph, PARAGRAPH_START)
def paragraph_end
self.class::PARAGRAPH_END
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/block_boundary.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/block_boundary.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser/kramdown/extensions'
require 'kramdown/parser/kramdown/blank_line'
require 'kramdown/parser/kramdown/eob'
module Kramdown
module Parser
class Kramdown
BLOCK_BOUNDARY = /#{BLANK_LINE}|#{EOB_MARKER}|#{IAL_BLOCK_START}|\Z/
# Return +true+ if we are after a block boundary.
def after_block_boundary?
!@tree.children.last || @tree.children.last.type == :blank ||
(@tree.children.last.type == :eob && @tree.children.last.value.nil?) || @block_ial
end
# Return +true+ if we are before a block boundary.
def before_block_boundary?
@src.check(self.class::BLOCK_BOUNDARY)
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/header.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/header.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser/kramdown/block_boundary'
module Kramdown
module Parser
class Kramdown
SETEXT_HEADER_START = /^#{OPT_SPACE}(?<contents>[^ \t].*)\n(?<level>[-=])[-=]*[ \t\r\f\v]*\n/
# Parse the Setext header at the current location.
def parse_setext_header
return false if !after_block_boundary?
text, id = parse_header_contents
return false if text.empty?
add_header(@src["level"] == '-' ? 2 : 1, text, id)
true
end
define_parser(:setext_header, SETEXT_HEADER_START)
ATX_HEADER_START = /^(?<level>\#{1,6})[\t ]*(?<contents>[^ \t].*)\n/
# Parse the Atx header at the current location.
def parse_atx_header
return false if !after_block_boundary?
text, id = parse_header_contents
text.sub!(/[\t ]#+\z/, '') && text.rstrip!
return false if text.empty?
add_header(@src["level"].length, text, id)
true
end
define_parser(:atx_header, ATX_HEADER_START)
protected
HEADER_ID = /[\t ]{#(?<id>[A-Za-z][\w:-]*)}\z/
# Returns header text and optional ID.
def parse_header_contents
text = @src["contents"]
text.rstrip!
id_match = HEADER_ID.match(text)
if id_match
id = id_match["id"]
text = text[0...-id_match[0].length]
text.rstrip!
end
[text, id]
end
def add_header(level, text, id)
start_line_number = @src.current_line_number
@src.pos += @src.matched_size
el = new_block_el(:header, nil, nil, :level => level, :raw_text => text, :location => start_line_number)
add_text(text, el)
el.attr['id'] = id if id
@tree.children << el
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/html_entity.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/html_entity.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
require 'kramdown/parser/html'
module Kramdown
module Parser
class Kramdown
# Parse the HTML entity at the current location.
def parse_html_entity
start_line_number = @src.current_line_number
@src.pos += @src.matched_size
begin
@tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity(@src[1] || (@src[2] && @src[2].to_i) || @src[3].hex),
nil, :original => @src.matched, :location => start_line_number)
rescue ::Kramdown::Error
@tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('amp'),
nil, :location => start_line_number)
add_text(@src.matched[1..-1])
end
end
define_parser(:html_entity, Kramdown::Parser::Html::Constants::HTML_ENTITY_RE, '&')
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/abbreviation.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/abbreviation.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Parser
class Kramdown
ABBREV_DEFINITION_START = /^#{OPT_SPACE}\*\[(.+?)\]:(.*?)\n/
# Parse the link definition at the current location.
def parse_abbrev_definition
start_line_number = @src.current_line_number
@src.pos += @src.matched_size
abbrev_id, abbrev_text = @src[1], @src[2]
abbrev_text.strip!
warning("Duplicate abbreviation ID '#{abbrev_id}' on line #{start_line_number} - overwriting") if @root.options[:abbrev_defs][abbrev_id]
@tree.children << new_block_el(:eob, :abbrev_def)
@root.options[:abbrev_defs][abbrev_id] = abbrev_text
@root.options[:abbrev_attr][abbrev_id] = @tree.children.last
true
end
define_parser(:abbrev_definition, ABBREV_DEFINITION_START)
# Correct abbreviation attributes.
def correct_abbreviations_attributes
@root.options[:abbrev_attr].keys.each do |k|
@root.options[:abbrev_attr][k] = @root.options[:abbrev_attr][k].attr
end
end
# Replace the abbreviation text with elements.
def replace_abbreviations(el, regexps = nil)
return if @root.options[:abbrev_defs].empty?
if !regexps
sorted_abbrevs = @root.options[:abbrev_defs].keys.sort {|a,b| b.length <=> a.length}
regexps = [Regexp.union(*sorted_abbrevs.map {|k| /#{Regexp.escape(k)}/})]
regexps << /(?=(?:\W|^)#{regexps.first}(?!\w))/ # regexp should only match on word boundaries
end
el.children.map! do |child|
if child.type == :text
if child.value =~ regexps.first
result = []
strscan = Kramdown::Utils::StringScanner.new(child.value, child.options[:location])
text_lineno = strscan.current_line_number
while temp = strscan.scan_until(regexps.last)
abbr_lineno = strscan.current_line_number
abbr = strscan.scan(regexps.first) # begin of line case of abbr with \W char as first one
if abbr.nil?
temp << strscan.scan(/\W|^/)
abbr = strscan.scan(regexps.first)
end
result << Element.new(:text, temp, nil, :location => text_lineno)
result << Element.new(:abbreviation, abbr, nil, :location => abbr_lineno)
text_lineno = strscan.current_line_number
end
result << Element.new(:text, strscan.rest, nil, :location => text_lineno)
else
child
end
else
replace_abbreviations(child, regexps)
child
end
end.flatten!
end
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
grab/engineering-blog | https://github.com/grab/engineering-blog/blob/d8026a4e9cc6348bf38951ee96c523f4ec19f3c4/_vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/blank_line.rb | _vendor/ruby/2.6.0/gems/kramdown-1.17.0/lib/kramdown/parser/kramdown/blank_line.rb | # -*- coding: utf-8 -*-
#
#--
# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
#
# This file is part of kramdown which is licensed under the MIT.
#++
#
module Kramdown
module Parser
class Kramdown
BLANK_LINE = /(?>^\s*\n)+/
# Parse the blank line at the current postition.
def parse_blank_line
@src.pos += @src.matched_size
if @tree.children.last && @tree.children.last.type == :blank
@tree.children.last.value << @src.matched
else
@tree.children << new_block_el(:blank, @src.matched)
end
true
end
define_parser(:blank_line, BLANK_LINE)
end
end
end
| ruby | MIT | d8026a4e9cc6348bf38951ee96c523f4ec19f3c4 | 2026-01-04T17:45:10.474201Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.