ro 1.4.6 → 4.2.0

data/lib/ro/config.rb

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

data/lib/ro/methods.rb

@@ -0,0 +1,238 @@
+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[:base] || options[:url] || Ro.config.url
+
+      path = Path.for(path, *args)
+
+      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 if fragment
+
+      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 = nil)
+      error = Error.new(message, context)
+
+      begin
+        raise error
+      rescue Error
+        backtrace = error.backtrace || []
+        error.set_backtrace(backtrace[1..-1])
+        raise
+      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)
+      last = expand_asset_url_strategies.size - 1
+
+      expand_asset_url_strategies.each_with_index do |strategy, i|
+        return send(strategy, html, node)
+      rescue Object => e
+        raise if i == last
+
+        Ro.log(e)
+      end
+
+      Ro.error! "could not expand assets via #{expand_asset_url_strategies.join(' | ')}"
+    end
+
+    def accurate_expand_asset_urls(html, node)
+      doc = REXML::Document.new('<__ro__>' + html + '</__ro__>')
+
+      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
+        end
+      end
+
+      doc.to_s.tap do |xml|
+        xml.sub!(/^\s*<.?__ro__>\s*/, '')
+        xml.sub!(/\s*<.?__ro__>\s*$/, '')
+        xml.strip!
+      end
+    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
+    end
+
+    def expand_asset_values(hash, node)
+      src = Map.for(hash)
+      dst = Map.new
+
+      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
+  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