ro 1.4.6 → 4.4.0

data/lib/ro/methods.rb

@@ -0,0 +1,295 @@
+module Ro
+  module Methods
+    # cast methods
+    # |
+    # v
+    def cast(which, arg, *args)
+      which = which.to_s
+      values = [arg, *args].join(',').scan(/[^,\s]+/)
+
+      list_of = which.match(/^list_of_(.+)$/)
+      which = list_of[1] if list_of
+
+      cast = casts.fetch(which.to_s.to_sym)
+
+      if list_of
+        values.map { |value| cast[value] }
+      else
+        raise ArgumentError, "too many values in #{values.inspect}" if values.size > 1
+
+        value = values.first
+        cast[value]
+      end
+    end
+
+    def casts
+      {
+        :string        => proc { |value| String(value) },
+        :int           => proc { |value| Integer(value.to_s) },
+        :string_or_nil => proc { |value| String(value).empty? ? nil : String(value) },
+        :url           => proc { |value| Ro.normalize_url(value) },
+        :array         => proc { |value| String(value).scan(/[^,:]+/) },
+        :bool          => proc { |value| String(value) !~ /^\s*(f|false|off|no|0){0,1}\s*$/ },
+        :path          => proc { |value| Path.for(value) },
+        :path_or_nil   => proc { |value| String(value).empty? ? nil : Path.for(value) },
+        :root          => proc { |value| Root.for(value) },
+        :time          => proc { |value| Time.parse(value.to_s) },
+        :date          => proc { |value| Date.parse(value.to_s) },
+      }
+    end
+
+    def mapify(pod)
+      Map.for(:pod => pod)[:pod]
+    end
+
+    def pod(object)
+      JSON.parse(object.to_json)
+    end
+
+    # url methods
+    # |
+    # v
+    def url_for(path, *args)
+      options = Map.extract_options!(args)
+
+      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
+
+      uri = URI.parse(base.to_s)
+      uri.path = Path.for(uri.path, path).absolute
+      uri.path = '' if uri.path == '/'
+
+      uri.query = query_string_for(query) unless query.empty?
+      uri.fragment = fragment unless fragment.nil?
+
+      uri.to_s
+    end
+
+    def query_string_for(hash, options = {})
+      options = Map.for(options)
+      escape = options.has_key?(:escape) ? options[:escape] : true
+      pairs = []
+      esc = escape ? proc { |v| CGI.escape(v.to_s) } : proc { |v| v.to_s }
+      hash.each do |key, values|
+        key = key.to_s
+        values = [values].flatten
+        values.each do |value|
+          value = value.to_s
+          pairs << if value.empty?
+                     [esc[key]]
+                   else
+                     [esc[key], esc[value]].join('=')
+                   end
+        end
+      end
+      pairs.replace(pairs.sort_by { |pair| pair.size })
+      pairs.join('&')
+    end
+
+    def normalize_url(url)
+      uri = URI.parse(url.to_s).normalize
+      uri.path = Path.for(uri.path).absolute
+      uri.to_s
+    end
+
+    # log methods
+    # |
+    # v
+    attr_accessor :logger
+
+    def log(*args, &block)
+      level = nil
+
+      level = if args.size == 0 || args.size == 1
+                :info
+              else
+                args.shift.to_s.to_sym
+              end
+
+      @logger && @logger.send(level, *args, &block)
+    end
+
+    def log!
+      Ro.logger =
+        ::Logger.new(STDERR).tap do |logger|
+          logger.level = ::Logger::INFO
+        end
+    end
+
+    def debug!
+      Ro.logger =
+        ::Logger.new(STDERR).tap do |logger|
+          logger.level = ::Logger::DEBUG
+        end
+    end
+
+    def error!(message, **context)
+      error = Error.new(message, **context)
+
+      begin
+        raise error
+      rescue Error
+        backtrace = error.backtrace || []
+        error.set_backtrace(backtrace[1..-1])
+        raise
+      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
+    def template(method = :tap, *args, &block)
+      Template.send(method, *args, &(block || proc {}))
+    end
+
+    def render(path, context = nil)
+      Template.render(path, context:)
+    end
+
+    def render_src(path, context = nil)
+      Template.render_src(path, context:)
+    end
+
+    # asset expansion methods 
+    # |
+    # v
+    EXPAND_ASSET_URL_STRATEGIES = %i[
+      accurate_expand_asset_urls
+      sloppy_expand_asset_urls
+    ]
+
+    def expand_asset_url_strategies
+      @expand_asset_url_strategies ||= EXPAND_ASSET_URL_STRATEGIES.dup
+    end
+
+    def expand_asset_urls(html, node)
+      strategies = expand_asset_url_strategies
+      error = nil
+
+      strategies.each do |strategy|
+        return send(strategy, html, node)
+      rescue Object => e
+        error = e
+        Ro.log(:error, emsg(error))
+        Ro.log(:error, "failed to expand assets via #{ strategy }")
+      end
+
+      raise error
+    end
+
+    def accurate_expand_asset_urls(html, node)
+      doc = Nokogiri::HTML.fragment(html.to_str)
+
+      doc.traverse do |element|
+        if element.respond_to?(:attributes)
+          attributes = element.attributes
+          expand_asset_values!(attributes) unless attributes.empty?
+        end
+      end
+
+      expanded = doc.to_s.strip
+
+      HTML.new(expanded)
+    end
+
+    def sloppy_expand_asset_urls(html, node)
+      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)
+      src = Map.for(hash)
+      dst = Map.new(hash)
+
+      return dst if src.empty?
+
+      re = %r{\A(?:[.]/)?(assets/[^\s]+)\s*\z}
+
+      src.depth_first_each do |key, value|
+        next unless value.is_a?(String)
+
+        if (match = re.match(value.strip))
+          path = match[1].strip
+          url = node.url_for(path)
+          value = url
+        end
+
+        dst.set(key, value)
+      end
+
+      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
+end

data/lib/ro/model.rb

@@ -1,97 +1,113 @@
 begin
   require 'active_model'
   require 'active_support'
-  require 'active_support/core_ext/string/inflections.rb'
+  require 'active_support/core_ext/string/inflections'
 rescue LoadError => e
   abort "you need to add the 'active_model' and 'active_support' gems to use Ro::Model"
 end
 
+require_relative '../ro' unless defined?(Ro)
+
 module Ro
   class Model
-  #
+    require_relative 'pagination'
+
     extend ActiveModel::Naming
     extend ActiveModel::Translation
     include ActiveModel::Validations
     include ActiveModel::Conversion
 
-  #
-    Fattr(:collection){ default_collection_name }
-    Fattr(:default_collection_name){ self.name.to_s.split(/::/).last.underscore.pluralize } 
-    Fattr(:root){ Ro.root }
-    Fattr(:prefix){ File.join(root, collection) }
+    class << Model
+      def root
+        @root ||= Ro.root
+      end
 
-    def Model.nodes(*args, &block)
-      root.nodes.send(collection)
-    end
+      def root=(root)
+        @root = Ro::Root.for(root)
+      end
 
-    def Model.all(*args, &block)
-      models_for(nodes)
-    end
+      def default_collection_name
+        name.to_s.split(/::/).last.underscore.pluralize
+      end
 
-    def Model.select(*args, &block)
-      all.select(*args, &block)
-    end
+      def collection_name(collection_name = nil)
+        @collection_name = collection_name.to_s if collection_name
 
-    def Model.detect(*args, &block)
-      all.detect(*args, &block)
-    end
+        @collection_name || default_collection_name
+      end
 
-    def Model.count(*args, &block)
-      if args.empty? and block.nil?
-        all.size
-      else
-        where(*args, &block).size
+      def collection
+        root.collections[collection_name]
       end
-    end
 
-    def Model.where(*args, &block)
-      all.select do |model|
-        !!model.instance_eval(&block)
+      def nodes
+        collection.to_a
       end
-    end
 
-    def Model.first
-      all.first
-    end
+      def all
+        models_for(nodes)
+      end
 
-    def Model.last
-      all.last
-    end
+      def select(*args, &block)
+        all.select(*args, &block)
+      end
 
-    def Model.find(id)
-      re = %r/#{ id.to_s.gsub(/[-_]/, '[-_]') }/i
-      all.detect{|model| model.id.to_s == id.to_s}
-    end
+      def detect(*args, &block)
+        all.detect(*args, &block)
+      end
 
-    def Model.[](id)
-      find(id)
-    end
+      def count(*args, &block)
+        if args.empty? and block.nil?
+          all.size
+        else
+          where(*args, &block).size
+        end
+      end
 
-    def Model.method_missing(method, *args, &block)
-      id = method
-      model = find(id)
-      return model if model
-      super
-    end
+      def where(*_args, &block)
+        all.select do |model|
+          !!model.instance_eval(&block)
+        end
+      end
+
+      def first
+        all.first
+      end
+
+      def last
+        all.last
+      end
 
-    def Model.models_for(result)
-      case result
+      def find(id)
+        slug = Slug.for(id)
+        all.detect { |model| Slug.for(model.id) == slug }
+      end
+
+      def [](id)
+        find(id)
+      end
+
+      def models_for(result)
+        case result
         when Array
-          List.for(Array(result).flatten.compact.map{|element| new(element)})
+          List.for(Array(result).flatten.compact.map { |element| new(element) })
         else
           new(result)
+        end
       end
-    end
 
-    def Model.paginate(*args, &block)
-      all.paginate(*args, &block)
+      def paginate(*args, &block)
+        all.paginate(*args, &block)
+      end
     end
 
     class List < ::Array
       include Pagination
 
-      def List.for(*args, &block)
-        new(*args, &block)
+      class << List
+        def for(*args, &block)
+          new(*args, &block)
+        end
       end
 
       def select(*args, &block)
@@ -107,26 +123,17 @@ module Ro
       List.new(*args, &block)
     end
 
-  #
     attr_accessor(:node)
 
-    def initialize(*args, &block)
+    def initialize(*args)
       attributes = Map.options_for!(args)
 
-      node = args.detect{|arg| arg.is_a?(Node)}
-      model = args.detect{|arg| arg.is_a?(Model)}
+      node = args.detect { |arg| arg.is_a?(Node) }
+      model = args.detect { |arg| arg.is_a?(Model) }
 
-      if node.nil? and not model.nil?
-        node = model.node
-      end
+      node = model.node if node.nil? and !model.nil?
 
-      if node
-        @node = node
-      else
-        path = File.join(prefix, ':new')
-        node = Node.new(path)
-        @node = node
-      end
+      @node = node
     end
 
     def attributes
@@ -137,54 +144,16 @@ module Ro
       true
     end
 
-  #
-    def prefix
-      self.class.prefix
-    end
-
-    def directory
-      File.join(prefix, id)
-    end
-
-  #
     def method_missing(method, *args, &block)
-      node.send(method, *args, &block)
+      begin
+        node.send(method, *args, &block)
+      rescue
+        super
+      end
     end
 
-    def respond_to?(method)
+    def respond_to?(method, *args, &block)
       super || node.respond_to?(method)
     end
   end
 end
-
-
-
-
-if __FILE__ == $0
-
-  ENV['RO_ROOT'] = '../sample_ro_data'
-
-  class Person < Ro::Model
-
-    #field(:first_name, :type => :string)
-    
-  end
-
-  p Person.collection
-  p Person.all
-  p Person.find(:ara).attributes
-  ara = Person.find(:ara)
-
-  p ara.url_for(:ara_glacier)
-
-  p Person.paginate(:per => 2, :page => 1)
-  p Person.name
-
-  p Person.prefix
-  p ara.id
-  p ara.first_name
-
-require 'pry'
-binding.pry
-
-end