ro 1.1.1 → 1.2.0

data/lib/ro/initializers/tilt.rb

@@ -19,14 +19,21 @@ module Tilt
         Redcarpet::Markdown.new(
           syntax_highlighting_renderer,
       
-          :no_intra_emphasis   => true,
-          :tables              => true,
-          :fenced_code_blocks  => true,
-          :autolink            => true,
-          :strikethrough       => true,
-          :lax_html_blocks     => true,
-          :space_after_headers => true,
-          :superscript         => true
+          :no_intra_emphasis            => true,
+          :tables                       => true,
+          :fenced_code_blocks           => true,
+          :autolink                     => true,
+          :disable_indented_code_blocks => true,
+          :strikethrough                => true,
+          :lax_spacing                  => true,
+          :space_after_headers          => false,
+          :superscript                  => true,
+          :underline                    => true,
+          :highlight                    => true,
+          :quote                        => true,
+
+          :with_toc_data                => true,
+          :hard_wrap                    => true,
         )
 
       @output = nil

data/lib/ro/lock.rb

@@ -0,0 +1,53 @@
+module Ro
+  class Lock
+    def initialize(path)
+      @path = path.to_s
+      @fd = false
+    end
+
+    def lock(&block)
+      open!
+
+      if block
+        begin
+          lock!
+          block.call
+        ensure
+          unlock!
+        end
+      else
+        self
+      end
+    end
+
+    def open!
+      @fd ||= (
+        fd =
+          begin
+            open(@path, 'ab+')
+          rescue
+            unless test(?e, @path)
+              FileUtils.mkdir_p(@path)
+              FileUtils.touch(@path)
+            end
+
+            open(@path, 'ab+')
+          end
+
+        fd.close_on_exec = true
+
+        fd
+      )
+    end
+
+    def lock!
+      open!
+      @fd.flock File::LOCK_EX
+    end
+
+    def unlock!
+      open!
+      @fd.flock File::LOCK_UN
+    end
+  end
+end

data/lib/ro/model.rb

@@ -0,0 +1,150 @@
+begin
+  require 'active_model'
+  require 'active_support'
+  require 'active_support/core_ext/string/inflections.rb'
+rescue LoadError => e
+  abort "you need to add the 'active_model' and 'active_support' gems to use Ro::Model"
+end
+
+module Ro
+  class Model
+  #
+    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) }
+
+    def Model.nodes(*args, &block)
+      root.nodes.send(collection)
+    end
+
+    def Model.all(*args, &block)
+      models_for(nodes)
+    end
+
+    def Model.select(*args, &block)
+      all.select(*args, &block)
+    end
+
+    def Model.detect(*args, &block)
+      all.detect(*args, &block)
+    end
+
+    def Model.count(*args, &block)
+      if args.empty? and block.nil?
+        all.size
+      else
+        where(*args, &block).size
+      end
+    end
+
+    def Model.where(*args, &block)
+      all.select do |model|
+        !!model.instance_eval(&block)
+      end
+    end
+
+    def Model.first
+      all.first
+    end
+
+    def Model.last
+      all.last
+    end
+
+    def Model.find(*args, &block)
+      models_for(nodes.find(*args, &block))
+    end
+
+    def Model.paginate(*args, &block)
+      models_for(nodes.paginate(*args, &block))
+    end
+
+    def Model.models_for(result)
+      case result
+        when Array
+          Array(result).flatten.compact.map{|element| new(element)}
+        else
+          new(result)
+      end
+    end
+
+  #
+    attr_accessor(:node)
+
+    def initialize(*args, &block)
+      attributes = Map.options_for!(args)
+
+      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
+
+      if node
+        @node = node
+      else
+        path = File.join(prefix, ':new')
+        node = Node.new(path)
+        @node = node
+      end
+    end
+
+    def attributes
+      @node.attributes
+    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)
+    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

data/lib/ro/node.rb

@@ -5,6 +5,7 @@ module Ro
     fattr :name
     fattr :type
     fattr :loaded
+    fattr :fields
 
     def initialize(path)
       @path = Ro.realpath(path.to_s)
@@ -14,12 +15,17 @@ module Ro
       @loaded = false
       @loading = false
       @attributes = Map.new
+      @fields = Map.new
     end
 
     def id
       @name
     end
 
+    def slug
+      attributes[:slug] || id
+    end
+
     def identifier
       "#{ type }/#{ name }"
     end
@@ -52,6 +58,24 @@ module Ro
       File.join(relative_path, 'assets')
     end
 
+    def asset_dir
+      File.join(path, 'assets')
+    end
+
+    def asset_paths
+      Dir.glob("#{ asset_dir }/**/**").select{|entry| test(?f, entry)}
+    end
+
+    def assets
+      asset_paths.map do |asset|
+        asset.sub(asset_dir + "/", "")
+      end
+    end
+
+    def asset_urls
+      asset_names.map{|asset_name| url_for(asset_name)}
+    end
+
     def url_for(*args, &block)
       options = Map.options_for!(args)
 
@@ -61,11 +85,13 @@ module Ro
 
       path = File.join(@path.to_s, 'assets', path_info)
 
+      glob = path_info.gsub(/[_-]/, '[_-]')
+
       globs = 
         [
-          File.join(@path.to_s, 'assets', "#{ path_info }"),
-          File.join(@path.to_s, 'assets', "#{ path_info }*"),
-          File.join(@path.to_s, 'assets', "**/#{ path_info }")
+          File.join(@path.to_s, 'assets', "#{ glob }"),
+          File.join(@path.to_s, 'assets', "#{ glob }*"),
+          File.join(@path.to_s, 'assets', "**/#{ glob }")
         ]
 
       candidates = globs.map{|glob| Dir.glob(glob)}.flatten.compact.uniq
@@ -79,14 +105,15 @@ module Ro
           path_info = path.gsub(/^#{ Regexp.escape(Ro.root) }/, '')
 
           if cache_buster
-            timestamp = File.stat(path).mtime.to_i
+            #options['_'] = Ro.md5(IO.binread(path))
+            timestamp = File.stat(path).mtime.utc.to_i
             options['_'] = timestamp
           end
         else
           raise ArgumentError.new("too many assets (#{ candidates.inspect }) matching #{ globs.inspect }")
       end
 
-      url = File.join(Ro.mount, path_info)
+      url = File.join(Ro.route, path_info)
 
       if options.empty?
         url
@@ -96,13 +123,21 @@ module Ro
       end
     end
 
+    def url_for?(*args, &block)
+      begin
+        url_for(*args, &block)
+      rescue
+        nil
+      end
+    end
+
     def source_for(*args)
       key = Ro.relative_path_for(:assets, :source, args).split('/')
       get(key)
     end
 
-    def mount(*args)
-      path_info = Ro.absolute_path_for(Ro.mount, relative_path)
+    def route(*args)
+      path_info = Ro.absolute_path_for(Ro.route, relative_path)
       [Ro.asset_host, path_info].compact.join('/')
     end
 
@@ -180,6 +215,15 @@ module Ro
       }
     end
 
+    def reload(&block)
+      @loaded = false
+      _load(&block)
+    end
+
+    def loaded
+      attributes
+    end
+
     def _load(&block)
       unless @loaded
         if @loading
@@ -213,7 +257,7 @@ module Ro
         _load_attributes_yml
         _load_attribute_files
         _load_sources
-        _load_urls
+        _load_assets
 
         Ro.cache.write(cache_key, @attributes)
 
@@ -238,19 +282,24 @@ module Ro
     end
 
     def _load_attribute_files
-      glob = File.join(@path, '*')
+      glob = File.join(@path, '**/**')
       node = self
 
       Dir.glob(glob) do |path|
         next if test(?d, path)
 
         basename = File.basename(path)
-        key, ext = basename.split('.', 2)
-
         next if basename == 'attributes.yml'
 
-        value = Ro.render(path, node)
-        @attributes.set(key => value)
+        relative_path = Ro.relative_path(path, :to => @path)
+        next if relative_path =~ /^assets\//
+
+        key = relative_path.split('.', 2).first.split('/')
+
+        html = Ro.render(path, node)
+        html = Ro.expand_asset_urls(html, node)
+
+        @attributes.set(key => html)
       end
     end
 
@@ -271,7 +320,7 @@ module Ro
       end
     end
 
-    def _load_urls
+    def _load_assets
       glob = File.join(@path, 'assets/**/**')
       node = self
 
@@ -311,11 +360,11 @@ module Ro
         entries.push([relative_path, timestamp.iso8601(2)]) 
       end
 
-      signature = entries.map{|pair| pair.join('@')}.join(', ')
+      fingerprint = entries.map{|pair| pair.join('@')}.join(', ')
 
-      md5 = Ro.md5(signature)
+      md5 = Ro.md5(fingerprint)
 
-      "#{ @path }-#{ md5 }"
+      [@path, md5]
     end
 
     def _load_from_cache

data/lib/ro/node/list.rb

@@ -18,6 +18,10 @@ module Ro
         block.call(self) if block
       end
 
+      def nodes
+        self
+      end
+
       def load(path)
         add( node = Node.new(path) )
       end
@@ -46,15 +50,22 @@ module Ro
         related
       end
 
-      def [](key)
-        if @type.nil?
-          type = key.to_s
-          list = select{|node| type == node.type}
-          list.type = type
-          list
-        else
-          name = key.to_s
-          detect{|node| name == node.name}
+      def [](*args, &block)
+        key = args.first
+
+        case key
+          when String, Symbol
+            if @type.nil?
+              type = key.to_s
+              list = select{|node| type == node.type}
+              list.type = type
+              list
+            else
+              name = Slug.for(key.to_s)
+              detect{|node| name == node.name}
+            end
+          else
+            super(*args, &block)
         end
       end
 
@@ -103,6 +114,72 @@ module Ro
         [root, type].compact.join('/')
       end
 
+      def paginate(*args)
+        options = Map.options_for!(args)
+
+        ensure_pagination_state!
+
+        page = Integer(args.shift || options[:page] || @page)
+        per = Integer(args.shift || options[:per] || options[:size] || @per)
+
+        @page = [page.abs, 1].max
+        @per = [per.abs, 1].max
+
+        offset = (@page - 1) * @per
+        length = @per 
+
+        replace(self.slice(offset, length))
+
+        self
+      end
+
+      def page(*args)
+        ensure_pagination_state!
+
+        if args.empty?
+          return @page
+        else
+          options = Map.options_for!(args)
+          page = args.shift || options[:page]
+          options[:page] = page
+          paginate(options)
+        end
+      end
+
+      alias_method(:current_page, :page)
+
+      def per(*args)
+        ensure_pagination_state!
+
+        if args.empty?
+          return @per
+        else
+          options = Map.options_for!(args)
+          per = args.shift || options[:per]
+          options[:per] = per
+          paginate(options)
+        end
+      end
+
+      def num_pages
+        (size.to_f / per).ceil
+      end
+
+      def total_pages
+        num_pages
+      end
+
+      def ensure_pagination_state!
+        unless defined?(@page)
+          @page = 1
+        end
+        unless defined?(@per)
+          @per = size
+        end
+        [@page, @per]
+      end
+
+
       def method_missing(method, *args, &block)
         Ro.log "Ro::List(#{ identifier })#method_missing(#{ method.inspect }, #{ args.inspect })"
 
@@ -112,8 +189,7 @@ module Ro
           super unless list
           list.empty? ? super : list
         else
-          name = Ro.slug_for(method)
-          node = self[name]
+          node = self[Slug.for(method, :join => '-')] || self[Slug.for(method, :join => '_')]
           node.nil? ? super : node
         end
       end