ro 1.4.6 → 4.4.0

data/lib/ro/collection.rb

@@ -0,0 +1,211 @@
+module Ro
+  class Collection
+    include Klass
+    include Enumerable
+
+    attr_reader :path, :root
+
+    def initialize(path)
+      @path = Path.for(path)
+      @root = Root.for(@path.parent)
+    end
+
+    def name
+      @path.name
+    end
+
+    def id
+      name
+    end
+
+    def type
+      name
+    end
+
+    def identifier
+      type
+    end
+
+    def inspect
+      identifier
+    end
+
+    def node_for(path)
+      Node.new(path)
+    end
+
+    def subdirectories(...)
+      @path.subdirectories(...)
+    end
+
+    def subdirectory_for(name)
+      @path.subdirectory_for(name)
+    end
+
+    def each(offset:nil, limit:nil, &block)
+      accum = []
+
+      if offset
+        i = -1
+        n = 0
+        subdirectories do |subdirectory|
+          i += 1
+          next if i < offset
+          node = node_for(subdirectory)
+          block ? block.call(node) : accum.push(node)
+          n += 1
+          break if limit && n >= limit
+        end
+      else
+        subdirectories do |subdirectory|
+          node = node_for(subdirectory)
+          block ? block.call(node) : accum.push(node)
+        end
+      end
+
+      block ? self : accum
+    end
+
+    class Page < ::Array
+      attr_accessor :number
+
+      def initialize(nodes = [], number: 1)
+        replace(nodes)
+        @number = number
+      end
+    end
+
+    def page(number, size: 10)
+      offset = [(number - 1), 0].max * size
+      limit = [size, 1].max
+
+      nodes = each(offset:, limit:)
+      Page.new(nodes, number:)
+    end
+
+    def paginate(size: 10, &block)
+      number = 0
+      accum = []
+
+      loop do
+        number += 1
+        page = self.page(number, size:)
+        break if page.empty?
+        block ? block.call(page) : accum.push(page)
+      end
+
+      block ? self : accum
+    end
+
+    def load(&block)
+      n = 8
+      q = Queue.new # FIXME
+      o = Queue.new # FIXME
+
+      producer =
+        Thread.new do
+          Thread.current.abort_on_exception = true
+
+          subdirectories do |subdirectory|
+            q.push(subdirectory)
+          end
+        end
+
+      loaders =
+        n.times.map do
+          Thread.new do
+            Thread.current.abort_on_exception = true
+
+            loop do
+              subdirectory = q.pop
+
+              begin
+                node = node_for(subdirectory)
+                o.push(node)
+              rescue => e
+                o.push(e) # FIXME
+                nil # FIXME
+              end
+            end
+          end
+        end
+
+        accum = []
+
+        consumer =
+          Thread.new do
+            Thread.current.abort_on_exception = true
+              loop do
+                node = o.pop
+                block ? block.call(node) : accum.push(node)
+              end
+          end
+
+        producer.join
+        loaders.map{|loader| loader.join}
+        consumer.join
+
+        block ? self : accum
+    end
+
+    def to_array(...)
+      each(...)
+    end
+
+    alias to_a to_array
+
+    alias all to_array
+
+    alias nodes to_array
+
+    def first(*args)
+      if args.size.zero?
+        node_for(subdirectories.first)
+      else
+        subdirectories.first(*args).map{|subdirectory| node_for(subdirectory)}
+      end
+    end
+
+    def last(*args)
+      if args.size.zero?
+        node_for(subdirectories.last)
+      else
+        subdirectories.last(*args).map{|subdirectory| node_for(subdirectory)}
+      end
+    end
+
+    def size
+      subdirectories.size
+    end
+
+    def paths_for(name)
+      [
+        subdirectory_for(name),
+        subdirectory_for(Slug.for(name, :join => '-')),
+        subdirectory_for(Slug.for(name, :join => '_')),
+      ]
+    end
+
+    def get(name)
+      paths_for(name).each do |path|
+        next unless path.exist?
+
+        return node_for(path)
+      end
+
+      nil
+    end
+
+    def [](name)
+      get(name)
+    end
+
+    def slice(...)
+      subdirectories.slice(...).map{|subdirectory| node_for(subdirectory)}
+    end
+
+    def method_missing(name, *args, **kws, &block)
+      get(name) || super
+    end
+  end
+end

data/lib/ro/config.rb

@@ -0,0 +1,72 @@
+module Ro
+  class Config < ::Map
+    def Config.defaults
+      {
+        :root =>
+          (Ro.env.root || Ro.defaults.root),
+
+        :build =>
+          (Ro.env.build || Ro.defaults.build),
+
+        :url =>
+          (Ro.env.url || Ro.defaults.url),
+
+        :img_url =>
+          (Ro.env.img_url || Ro.defaults.img_url),
+
+        :page_size =>
+          (Ro.env.page_size || Ro.defaults.page_size),
+
+        :log =>
+          (Ro.env.log || Ro.defaults.log),
+
+        :debug =>
+          (Ro.env.debug || Ro.defaults.debug),
+
+        :port =>
+          (Ro.env.port || Ro.defaults.port),
+
+        :md_theme =>
+          (Ro.env.md_theme || Ro.defaults.md_theme),
+      }
+    end
+
+    def initialize(*args, **kws)
+      configure!(Config.defaults)
+
+      args.each do |arg|
+        configure!(arg) if arg.is_a?(Hash)
+      end
+
+      configure!(kws)
+    end
+
+    def configure!(hash)
+      hash.each do |key, value|
+        send("#{ key }=", value)
+      end
+    end
+
+    {
+      :root      => :root,
+      :build     => :path,
+      :url       => :url,
+      :img_url   => :url,
+      :page_size => :int,
+      :log       => :bool,
+      :debug     => :bool,
+      :port      => :int,
+      :md_theme  => :string,
+    }.each do |attribute, cast|
+      class_eval <<-____, __FILE__, __LINE__ + 1
+        def #{ attribute }
+          get :#{ attribute }
+        end
+
+        def #{ attribute }=(value)
+          set :#{ attribute }, Ro.cast(:#{ cast }, value)
+        end
+      ____
+    end
+  end
+end

data/lib/ro/error.rb

@@ -0,0 +1,11 @@
+module Ro
+  class Error < ::StandardError
+    attr_reader :context
+
+    def initialize(message, **context)
+      @context = context
+      msg = context.empty? ? "#{ message }" : "#{ message }, #{ context.inspect }"
+      super(msg)
+    end
+  end
+end

data/lib/ro/html.rb

@@ -0,0 +1,23 @@
+module Ro
+  require_relative 'html_safe'
+
+  class HTML < ::ActiveSupport::SafeBuffer
+    def initialize(*args, **kws, &block)
+      self.front_matter = kws.fetch(:front_matter){ {} }
+
+      super(args.join)
+    end
+
+    def front_matter
+      @front_matter ||= Map.new
+    end
+
+    def front_matter=(hash = {})
+      @front_matter = Map.for(hash)
+    end
+
+    def attributes
+      front_matter
+    end
+  end
+end

data/lib/ro/html_safe.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+unless defined?(ActiveSupport::SafeBuffer)
+
+class Object
+  def html_safe?
+    false
+  end
+end
+
+class Numeric
+  def html_safe?
+    true
+  end
+end
+
+module ActiveSupport #:nodoc:
+  class SafeBuffer < String
+    UNSAFE_STRING_METHODS = %w(
+      capitalize chomp chop delete downcase gsub lstrip next reverse rstrip
+      slice squeeze strip sub succ swapcase tr tr_s upcase
+    )
+
+    alias_method :original_concat, :concat
+    private :original_concat
+
+    # Raised when <tt>ActiveSupport::SafeBuffer#safe_concat</tt> is called on unsafe buffers.
+    class SafeConcatError < StandardError
+      def initialize
+        super "Could not concatenate to the buffer because it is not html safe."
+      end
+    end
+
+    def [](*args)
+      if args.size < 2
+        super
+      elsif html_safe?
+        new_safe_buffer = super
+
+        if new_safe_buffer
+          new_safe_buffer.instance_variable_set :@html_safe, true
+        end
+
+        new_safe_buffer
+      else
+        to_str[*args]
+      end
+    end
+
+    def safe_concat(value)
+      raise SafeConcatError unless html_safe?
+      original_concat(value)
+    end
+
+    def initialize(str = "")
+      @html_safe = true
+      super
+    end
+
+    def initialize_copy(other)
+      super
+      @html_safe = other.html_safe?
+    end
+
+    def clone_empty
+      self[0, 0]
+    end
+
+    def concat(value)
+      super(html_escape_interpolated_argument(value))
+    end
+    alias << concat
+
+    def prepend(value)
+      super(html_escape_interpolated_argument(value))
+    end
+
+    def +(other)
+      dup.concat(other)
+    end
+
+    def %(args)
+      case args
+      when Hash
+        escaped_args = Hash[args.map { |k, arg| [k, html_escape_interpolated_argument(arg)] }]
+      else
+        escaped_args = Array(args).map { |arg| html_escape_interpolated_argument(arg) }
+      end
+
+      self.class.new(super(escaped_args))
+    end
+
+    def html_safe?
+      defined?(@html_safe) && @html_safe
+    end
+
+    def to_s
+      self
+    end
+
+    def to_param
+      to_str
+    end
+
+    def encode_with(coder)
+      coder.represent_object nil, to_str
+    end
+
+    UNSAFE_STRING_METHODS.each do |unsafe_method|
+      if unsafe_method.respond_to?(unsafe_method)
+        class_eval <<-EOT, __FILE__, __LINE__ + 1
+          def #{unsafe_method}(*args, &block)       # def capitalize(*args, &block)
+            to_str.#{unsafe_method}(*args, &block)  #   to_str.capitalize(*args, &block)
+          end                                       # end
+
+          def #{unsafe_method}!(*args)              # def capitalize!(*args)
+            @html_safe = false                      #   @html_safe = false
+            super                                   #   super
+          end                                       # end
+        EOT
+      end
+    end
+
+    private
+
+      def html_escape_interpolated_argument(arg)
+        (!html_safe? || arg.html_safe?) ? arg : CGI.escapeHTML(arg.to_s)
+      end
+  end
+end
+
+class String
+  # Marks a string as trusted safe. It will be inserted into HTML with no
+  # additional escaping performed. It is your responsibility to ensure that the
+  # string contains no malicious content. This method is equivalent to the
+  # +raw+ helper in views. It is recommended that you use +sanitize+ instead of
+  # this method. It should never be called on user input.
+  def html_safe
+    ActiveSupport::SafeBuffer.new(self)
+  end
+end
+
+end

data/lib/ro/klass.rb

@@ -0,0 +1,25 @@
+module Ro
+  module Klass
+    module ClassMethods
+      def klass(arg, *args, **kws, &block)
+        return arg if arg.is_a?(self.class) && args.empty? && kws.empty? && block.nil?
+
+        new(arg, *args, **kws, &block)
+      end
+
+      alias for klass
+    end
+
+    module InstanceMethods
+      def klass
+        self.class
+      end
+    end
+
+    def Klass.included(other)
+      other.send(:extend, ClassMethods)
+      other.send(:include, InstanceMethods)
+      super
+    end
+  end
+end