ro 4.2.0 → 5.0.0

data/lib/ro/asset.rb

@@ -2,14 +2,6 @@ module Ro
   class Asset < ::String
     include Klass
 
-    DEFAULT_IMAGE_PATTERNS = [
-      /[.](webp|jpg|jpeg|png|gif|tif|tiff|svg)$/i
-    ]
-
-    def Asset.image_patterns
-      @image_patterns ||= DEFAULT_IMAGE_PATTERNS.dup
-    end
-
     attr_reader :path, :node, :relative_path, :name, :url
 
     def initialize(arg, *args)
@@ -17,9 +9,48 @@ module Ro
 
       @path = Path.for(arg, *args)
 
-      @node = options.fetch(:node) { Node.for(@path.split('/assets/').first) }
+      # T029: Updated to split on node ID instead of /assets/ segment
+      @node = options.fetch(:node) do
+        # Try to find node by splitting path
+        # In new structure: no /assets/ segment
+        # In old structure: /assets/ segment exists
+        if @path.to_s.include?('/assets/')
+          # Old structure
+          Node.for(@path.split('/assets/').first)
+        else
+          # New structure: find node directory by looking at parent paths
+          # Asset path like: /collection/node-id/file.jpg
+          # Node path should be: /collection/node-id
+          found_node = nil
+          node_path = @path.parent
+          while node_path && !node_path.basename.to_s.match(/\.(yml|yaml|json|toml)$/)
+            # Check if there's a metadata file for this directory
+            collection_path = node_path.parent
+            node_id = node_path.basename.to_s
+
+            %w[yml yaml json toml].each do |ext|
+              metadata_file = collection_path.join("#{node_id}.#{ext}")
+              if metadata_file.exist?
+                root = Root.for(collection_path.parent)
+                collection = root.collection_for(collection_path)
+                found_node = Node.new(collection, metadata_file)
+                break
+              end
+            end
 
-      @relative_path = @path.relative_to(@node.path)
+            break if found_node
+            node_path = node_path.parent
+          end
+
+          # Fallback: old behavior
+          found_node || Node.for(@path.split('/assets/').first)
+        end
+      end
+
+      # T030: Updated relative_path calculation for new structure
+      # In new structure, path is already relative to node.asset_dir
+      # In old structure, need to account for assets/ prefix
+      @relative_path = @path.relative_to(@node.asset_dir)
 
       @name = @relative_path
 
@@ -28,18 +59,38 @@ module Ro
       super(@path)
     end
 
-    def image?
-      @path.file? && Asset.image_patterns.any? { |pattern| pattern === @path.basename }
+    def is_img?
+      @path.file? && Ro.is_image?(@path.basename)
     end
 
-    def src
+    alias is_img is_img?
+
+    def img
+      return unless is_img?
+      Ro.image_info(path.to_s)
+    end
+
+    def is_src?
       key = relative_path.parts
-      subdir = key.size > 2 ? key[1] : nil
-      is_src = subdir == 'src'
+      # Check if the first directory in the path is 'src'
+      # e.g., src/file.js or src/subdir/file.js
+      first_dir = key.size >= 2 ? key[0] : nil
+      !!(first_dir == 'src')
+    end
 
-      return unless is_src
+    alias is_src is_src?
 
+    def src
+      return unless is_src?
       Ro.render_src(path, node)
     end
+
+    def stat
+      @path.stat.size
+    end
+
+    def size
+      stat.size
+    end
   end
 end

data/lib/ro/collection.rb

@@ -34,6 +34,20 @@ module Ro
       Node.new(path)
     end
 
+    # T021: Scan for metadata files in new structure format
+    def metadata_files
+      extensions = %w[yml yaml json toml]
+      files = []
+
+      extensions.each do |ext|
+        @path.glob("*.#{ext}").each do |file|
+          files << file if file.file?
+        end
+      end
+
+      files.sort
+    end
+
     def subdirectories(...)
       @path.subdirectories(...)
     end
@@ -42,13 +56,61 @@ module Ro
       @path.subdirectory_for(name)
     end
 
-    def each(&block)
-      accum = []
+    # T020: Modified to discover nodes from metadata files (new structure)
+    def each(offset:nil, limit:nil, &block)
+      # Return enumerator if no block given and no offset/limit
+      return to_enum(:each, offset: offset, limit: limit) unless block_given?
+
+      # Use metadata files for new structure instead of subdirectories
+      files = metadata_files
+
+      if offset
+        i = -1
+        n = 0
+        files.each do |metadata_file|
+          i += 1
+          next if i < offset
+          node = Node.new(self, metadata_file)
+          block.call(node)
+          n += 1
+          break if limit && n >= limit
+        end
+      else
+        files.each do |metadata_file|
+          node = Node.new(self, metadata_file)
+          block.call(node)
+        end
+      end
+
+      self
+    end
+
+    class Page < ::Array
+      attr_accessor :number
 
-      subdirectories do |subdirectory|
-        node = node_for(subdirectory)
+      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
@@ -105,8 +167,10 @@ module Ro
         block ? self : accum
     end
 
-    def to_array(...)
-      each(...)
+    def to_array(offset: nil, limit: nil)
+      accum = []
+      each(offset: offset, limit: limit) { |node| accum << node }
+      accum
     end
 
     alias to_a to_array
@@ -143,11 +207,28 @@ module Ro
       ]
     end
 
+    # T022: Modified to find nodes by metadata filename
     def get(name)
-      paths_for(name).each do |path|
-        next unless path.exist?
+      # Try to find metadata file for this node ID
+      extensions = %w[yml yaml json toml]
+      extensions.each do |ext|
+        metadata_file = @path.join("#{name}.#{ext}")
+        if metadata_file.exist? && metadata_file.file?
+          return Node.new(self, metadata_file)
+        end
+      end
 
-        return node_for(path)
+      # Also try with slugified versions
+      [
+        Slug.for(name, :join => '-'),
+        Slug.for(name, :join => '_')
+      ].each do |slug|
+        extensions.each do |ext|
+          metadata_file = @path.join("#{slug}.#{ext}")
+          if metadata_file.exist? && metadata_file.file?
+            return Node.new(self, metadata_file)
+          end
+        end
       end
 
       nil

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