ro 4.2.0 → 4.4.0

data/lib/ro/collection.rb

@@ -42,13 +42,56 @@ module Ro
       @path.subdirectory_for(name)
     end
 
-    def each(&block)
+    def each(offset:nil, limit:nil, &block)
       accum = []
 
-      subdirectories do |subdirectory|
-        node = node_for(subdirectory)
+      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 = []
 
-        block ? block.call(node) : accum.push(node)
+      loop do
+        number += 1
+        page = self.page(number, size:)
+        break if page.empty?
+        block ? block.call(page) : accum.push(page)
       end
 
       block ? self : accum

data/lib/ro/config.rb

@@ -11,6 +11,9 @@ module Ro
         :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),
 
@@ -48,6 +51,7 @@ module Ro
       :root      => :root,
       :build     => :path,
       :url       => :url,
+      :img_url   => :url,
       :page_size => :int,
       :log       => :bool,
       :debug     => :bool,

data/lib/ro/error.rb

@@ -1,8 +1,11 @@
 module Ro
   class Error < ::StandardError
-    def initialize(message, context = nil)
-      super(message)
+    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/methods.rb

@@ -1,5 +1,5 @@
 module Ro
-	module Methods
+  module Methods
     # cast methods
     # |
     # v
@@ -51,10 +51,19 @@ module Ro
     # v
     def url_for(path, *args)
       options = Map.extract_options!(args)
-      base = options[:base] || options[:url] || Ro.config.url
+
+      base = (options.delete(:base) || options.delete(:url))
 
       path = Path.for(path, *args)
 
+      base ||= (
+        if Ro.is_image?(path)
+          Ro.config.img_url
+        else
+          Ro.config.url
+        end
+      )
+
       fragment = options.delete(:fragment)
       query = options.delete(:query) || options
 
@@ -63,8 +72,7 @@ module Ro
       uri.path = '' if uri.path == '/'
 
       uri.query = query_string_for(query) unless query.empty?
-
-      uri.fragment = fragment if fragment
+      uri.fragment = fragment unless fragment.nil?
 
       uri.to_s
     end
@@ -127,8 +135,8 @@ module Ro
         end
     end
 
-    def error!(message, context = nil)
-      error = Error.new(message, context)
+    def error!(message, **context)
+      error = Error.new(message, **context)
 
       begin
         raise error
@@ -139,6 +147,14 @@ module Ro
       end
     end
 
+    def emsg(e)
+      if e.is_a?(Exception)
+        "#{ e.message } (#{ e.class.name })\n#{ Array(e.backtrace).join(10.chr) }"
+      else
+        e.to_s
+      end
+    end
+
     # template methods
     # |
     # v
@@ -158,7 +174,8 @@ module Ro
     # |
     # v
     EXPAND_ASSET_URL_STRATEGIES = %i[
-      accurate_expand_asset_urls sloppy_expand_asset_urls
+      accurate_expand_asset_urls
+      sloppy_expand_asset_urls
     ]
 
     def expand_asset_url_strategies
@@ -166,55 +183,58 @@ module Ro
     end
 
     def expand_asset_urls(html, node)
-      last = expand_asset_url_strategies.size - 1
+      strategies = expand_asset_url_strategies
+      error = nil
 
-      expand_asset_url_strategies.each_with_index do |strategy, i|
+      strategies.each do |strategy|
         return send(strategy, html, node)
       rescue Object => e
-        raise if i == last
-
-        Ro.log(e)
+        error = e
+        Ro.log(:error, emsg(error))
+        Ro.log(:error, "failed to expand assets via #{ strategy }")
       end
 
-      Ro.error! "could not expand assets via #{expand_asset_url_strategies.join(' | ')}"
+      raise error
     end
 
     def accurate_expand_asset_urls(html, node)
-      doc = REXML::Document.new('<__ro__>' + html + '</__ro__>')
+      doc = Nokogiri::HTML.fragment(html.to_str)
 
-      doc.each_recursive do |element|
-        next unless element.respond_to?(:attributes)
-
-        src = {}
-        element.attributes.each do |key, value|
-          src[key] = value
-        end
-
-        dst = expand_asset_values(src, node)
-
-        dst.each do |k, v|
-          element.attributes[k] = v
+      doc.traverse do |element|
+        if element.respond_to?(:attributes)
+          attributes = element.attributes
+          expand_asset_values!(attributes) unless attributes.empty?
         end
       end
 
-      doc.to_s.tap do |xml|
-        xml.sub!(/^\s*<.?__ro__>\s*/, '')
-        xml.sub!(/\s*<.?__ro__>\s*$/, '')
-        xml.strip!
-      end
+      expanded = doc.to_s.strip
+
+      HTML.new(expanded)
     end
 
     def sloppy_expand_asset_urls(html, node)
-      html.to_s.gsub(%r{\s*=\s*['"](?:[.]/)?assets/[^'"\s]+['"]}) do |match|
-        path = match[%r{assets/[^'"\s]+}]
-        url = node.url_for(path)
-        "='#{url}'"
-      end
+      re = %r`\s*=\s*['"](?:[.]/)?(assets/[^'"\s]+)['"]`
+
+      expanded =
+        html.to_str.gsub(re) do |match|
+          path = match[%r`assets/[^'"\s]+`]
+
+          if node.path_for(path).exist?
+            url = node.url_for(path)
+            "='#{url}'"
+          else
+            match
+          end
+        end
+
+      HTML.new(expanded)
     end
 
-    def expand_asset_values(hash, node)
+   def expand_asset_values(hash, node)
       src = Map.for(hash)
-      dst = Map.new
+      dst = Map.new(hash)
+
+      return dst if src.empty?
 
       re = %r{\A(?:[.]/)?(assets/[^\s]+)\s*\z}
 
@@ -232,6 +252,43 @@ module Ro
 
       dst.to_hash
     end
+
+    def expand_asset_values!(hash, node)
+      expand_asset_values(hash, node).each do |key, value|
+        hash[key] = value
+      end
+    end
+
+  #
+    DEFAULT_IMAGE_EXTENSIONS = %i[
+      webp jpg jpeg png gif tif tiff svg
+    ]
+
+    DEFAULT_IMAGE_PATTERNS = [
+      /[.](#{ DEFAULT_IMAGE_EXTENSIONS.join('|') })$/i
+    ]
+
+    def image_patterns
+      @image_patterns ||= DEFAULT_IMAGE_PATTERNS.dup
+    end
+
+    def image_pattern
+      Regexp.union(Ro.image_patterns)
+    end
+
+    def is_image?(path)
+      !!(URI.parse(path.to_s).path =~ Ro.image_pattern)
+    end
+
+    def image_info(path)
+      is = ImageSize.path(path)
+      format, width, height = is.format.to_s, is.width, is.height
+      {format:, width:, height:}
+    end
+
+    def uuid
+      SecureRandom.uuid_v7.to_s
+    end
   end
 
   extend Methods

data/lib/ro/node.rb

@@ -47,40 +47,34 @@ module Ro
       @attributes = Map.new
 
       _load_base_attributes
+      _load_file_attributes
       _load_asset_attributes
       _load_meta_attributes
-      _load_file_attributes
 
       @attributes
     end
 
     def _load_base_attributes
-      disallowed =
-        %w[
-          assets
-          _meta
-        ]
-
-      glob =
-        "attributes.{yml,yaml,json}"
+      glob = "attributes.{yml,yaml,json}"
 
       @path.glob(glob) do |file|
         attrs = _render(file)
-
-        disallowed.each do |key|
-          Ro.error!("#{ file } must not contain the key #{key.inspect}") if attrs.has_key?(key)
-        end
-
-        @attributes.update(attrs)
+        update_attributes!(attrs, file:)
       end
     end
 
-
     def _load_asset_attributes
       {}.tap do |hash|
         assets.each do |asset|
           key = asset.name
-          value = { url: asset.url, path: asset.path.relative_to(@root), src: asset.src }
+          url = asset.url
+          path = asset.path.relative_to(@root)
+          src = asset.src
+          img = asset.img
+          size = asset.size
+
+          value = { url:, path:, size:, img:, src: }
+
           hash[key] = value
         end
 
@@ -94,7 +88,9 @@ module Ro
           identifier:,
           type:,
           id:,
-          urls:
+          urls:,
+          created_at:,
+          updated_at:,
         )
 
         @attributes.set(_meta: hash)
@@ -114,16 +110,46 @@ module Ro
         base = basename.split('.', 2).first
         key.push(base)
 
-        if @attributes.has?(key)
-          raise Error.new("#{ @path } clobbers #{ key.inspect }!")
+        value = _render(file)
+
+        if value.is_a?(HTML)
+          attrs = value.front_matter
+          update_attributes!(attrs, file:)
         end
 
-        value = _render(file)
+        if @attributes.has?(key)
+          raise Error.new("path=#{ @path.inspect } masks #{ key.inspect } in #{ @attributes.inspect }!")
+        end
 
         @attributes.set(key => value)
       end
     end
 
+    def update_attributes!(attrs = {}, **context)
+      attrs = Map.for(attrs)
+
+      blacklist = %w[
+        assets
+        _meta
+      ]
+
+      blacklist.each do |key|
+        if attrs.has_key?(key)
+          Ro.error!("#{ key } is blacklisted!", **context)
+        end
+      end
+
+      keys = @attributes.depth_first_keys
+
+      attrs.depth_first_keys.each do |key|
+        if keys.include?(key)
+          Ro.error!("#{ attrs.inspect } clobbers #{ @attributes.inspect }!", **context)
+        end
+      end
+
+      @attributes.update(attrs)
+    end
+
     def _ignored_files
       ignored_files =
         %w[
@@ -139,11 +165,19 @@ module Ro
     end
 
     def _render(file)
+      node = self
+
       value = Ro.render(file, _render_context)
 
-      if value.is_a?(Ro::Template::HTML)
-        html = value
-        value = Ro.expand_asset_urls(html, self)
+      if value.is_a?(HTML)
+        front_matter = value.front_matter
+        html = Ro.expand_asset_urls(value, node)
+        value = HTML.new(html, front_matter:)
+      end
+
+      if value.is_a?(Hash)
+        attributes = value
+        value = Ro.expand_asset_values(attributes, node)
       end
 
       value
@@ -156,6 +190,10 @@ module Ro
       end
     end
 
+    def fetch(*args)
+      attributes.fetch(*args)
+    end
+
     def get(*args)
       attributes.get(*args)
     end
@@ -219,14 +257,13 @@ module Ro
     end
 
     def url_for(relative_path, options = {})
-      raise ArgumentError, relative_path if Path.absolute?(relative_path)
-
-      fullpath = Path.for(path, relative_path).expand
-      raise ArgumentError, "#{relative_path.inspect} -- DOES NOT EXIST" unless fullpath.exist?
-
       Ro.url_for(self.relative_path, relative_path, options)
     end
 
+    def path_for(...)
+      @path.join(...)
+    end
+
     def src_for(*args)
       key = Path.relative(:assets, :src, args).split('/')
       get(key)
@@ -250,6 +287,10 @@ module Ro
       to_json(...)
     end
 
+    def to_str(...)
+      to_json(...)
+    end
+
     def to_json(...)
       JSON.pretty_generate(to_hash, ...)
     end
@@ -262,12 +303,6 @@ module Ro
       to_hash.to_yaml(...)
     end
 
-    def _mapify(data)
-      converted = 'this_recursively_converts_nested_hashes_into_maps'
-
-      Map.for(converted => data)[converted]
-    end
-
     def files
       path.glob('**/**').select { |entry| entry.file? }.sort
     end
@@ -291,5 +326,13 @@ module Ro
 
       [position, published_at, created_at, name]
     end
+
+    def created_at
+      files.map{|file| File.stat(file).ctime}.min
+    end
+
+    def updated_at
+      files.map{|file| File.stat(file).mtime}.max
+    end
   end
 end

data/lib/ro/path.rb

@@ -221,5 +221,9 @@ module Ro
     def <=>(other)
       sort_key <=> other.sort_key
     end
+
+    def stat
+      File.stat(self)
+    end
   end
 end