ro 0.0.1 → 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Y2M5NmE2YmY3ZDgyYWFhNzZhMzE3MzFmOTgzNmJkNGE4YmM1M2U3Ng==
+  data.tar.gz: !binary |-
+    ZWMxMzRkMWJhNmZlYmJkMTk4ODAzNjRhOTgxZGIxNWZhMjFkNjE0NQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MTgyNDczMDY4ZjY1YTE0Nzg2MmZjN2RlYzU1NzdhNjVjNzY1YzE0NjA1ZGNl
+    OTNlMjQyODc1MGQyZGViMDA4MWFkN2ViNzRiM2ViODdiODYwY2ZiNTZhN2Vh
+    ZGUxOTU0YzZkMGUxNWFmNmY2ZTBiOWY3YWQxODg5OWFmZWE1NmE=
+  data.tar.gz: !binary |-
+    N2JlYmYwOGJhYTlhYzY2YWI4ZDJkNzQ4MWY2OWE1NmE0YWVlMjllODZiNjEx
+    ZTI0OTQyNjkxNDVjMTBiZjc3ZmFhZDYyMjllMzkwYmU4OTQzNTY3NDVkMjQ4
+    MTJmNjM4ZThiOTQ4Mzk5MTliNTdmOGUxN2E5OTcxMzBiOTgyODQ=

data/:

@@ -0,0 +1,9 @@
+module Ro
+  class Template
+    fattr :path
+
+    def initialize(path)
+      @path = Ro.realpath(path)
+    end
+  end
+end

data/:w

@@ -0,0 +1,29 @@
+module Ro
+  class Db
+    fattr :root
+
+    def initialize(*args, &block)
+      options = Map.options_for!(args)
+
+      @root = String(args.shift || options[:root] || Ro.root)
+    end
+
+    def collections
+    end
+
+    def glob
+    end
+
+    def nodes
+      42
+    end
+
+    class Collection
+      fattr :basename
+
+      def initialize(basename)
+        @basename = basename.to_s
+      end
+    end
+  end
+end

data/README.md

@@ -0,0 +1,30 @@
+NAME
+----
+
+ro
+
+
+SYNOPSIS
+--------
+
+RTFC
+
+
+DESCRIPTION
+-----------
+
+ro is library for managing your site's content in git, as god intended.
+
+more details coming soon...
+
+
+INSTALL
+-------
+
+gem install ro (coming soon)
+
+
+DOCS
+----
+
+RTFC

data/Rakefile

@@ -59,8 +59,8 @@ end
 
 task :gemspec do
   ignore_extensions = ['git', 'svn', 'tmp', /sw./, 'bak', 'gem']
-  ignore_directories = ['pkg']
-  ignore_files = ['test/log', 'a.rb'] + Dir['db/*'] + %w'db'
+  ignore_directories = ['pkg', 'db']
+  ignore_files = ['test/log', 'test/db.yml', 'a.rb', 'b.rb'] + Dir['db/*'] + %w'db'
 
   shiteless = 
     lambda do |list|
@@ -90,6 +90,16 @@ task :gemspec do
   test_files  = test(?e, "test/#{ lib }.rb") ? "test/#{ lib }.rb" : nil
   summary     = object.respond_to?(:summary) ? object.summary : "summary: #{ lib } kicks the ass"
   description = object.respond_to?(:description) ? object.description : "description: #{ lib } kicks the ass"
+  license = object.respond_to?(:license) ? object.license : nil
+
+  if license.nil?
+    license =
+      begin
+        IO.binread('LICENSE')
+      rescue
+        "Same As Ruby's"
+      end
+  end
 
   if This.extensions.nil?
     This.extensions = []
@@ -127,6 +137,7 @@ task :gemspec do
             spec.platform = Gem::Platform::RUBY
             spec.summary = <%= lib.inspect %>
             spec.description = <%= description.inspect %>
+            spec.license = <%= license.inspect %>
 
             spec.files =\n<%= files.sort.pretty_inspect %>
             spec.executables = <%= executables.inspect %>
@@ -293,7 +304,7 @@ BEGIN {
 
 # discover full path to this ruby executable
 #
-  c = RbConfig::CONFIG
+  c = Config::CONFIG
   bindir = c["bindir"] || c['BINDIR']
   ruby_install_name = c['ruby_install_name'] || c['RUBY_INSTALL_NAME'] || 'ruby'
   ruby_ext = c['EXEEXT'] || ''

data/lib/co/db.rb

@@ -0,0 +1,4 @@
+module Co
+  class Db
+  end
+end

data/lib/co/node.rb

@@ -0,0 +1,4 @@
+module Co
+  class Node
+  end
+end

data/lib/co/node/list.rb

@@ -0,0 +1,16 @@
+module Co
+  class Node
+    class List < ::Array
+      def method_missing(method, *args, &block)
+      end
+
+      def [](*args)
+        case args.first
+          when Symbol, String
+          else
+            super
+        end
+      end
+    end
+  end
+end

data/lib/co/util.rb

@@ -0,0 +1,5 @@
+module Co
+  module Util
+    extend(Util)
+  end
+end

data/lib/ro.rb

@@ -1,5 +1,184 @@
-module Ro
-  def Ro.version
-    '0.0.1'
+# -*- encoding : utf-8 -*-
+
+  require 'fileutils'
+  require 'pathname'
+  require 'yaml'
+  require 'digest/md5'
+  require 'logger'
+
+#
+  module Ro
+    Version = '1.0.0' unless defined?(Version)
+
+    def version
+      Ro::Version
+    end
+
+    def dependencies
+      {
+        'map'               => [ 'map'               , ' >= 6.5.1' ] ,
+        'fattr'             => [ 'fattr'             , ' >= 2.2.1' ] ,
+        'tilt'              => [ 'tilt'              , ' >= 1.4.1' ] ,
+        'pygments'          => [ 'pygments.rb'       , ' >= 0.5.0' ] ,
+        'coerce'            => [ 'coerce'            , ' >= 0.0.4' ] ,
+        'stringex'          => [ 'stringex'          , ' >= 2.1.0' ] ,
+      # 'rails'             => [ 'rails'             , ' >= 3.1'   ] ,
+      # 'tagz'              => [ 'tagz'              , ' >= 9.9.2' ] ,
+      # 'multi_json'        => [ 'multi_json'        , ' >= 1.0.3' ] ,
+      # 'uuidtools'         => [ 'uuidtools'         , ' >= 2.1.2' ] ,
+      # 'wrap'              => [ 'wrap'              , ' >= 1.5.0' ] ,
+      # 'rails_current'     => [ 'rails_current'     , ' >= 1.8.0' ] ,
+      # 'rails_errors2html' => [ 'rails_errors2html' , ' >= 1.3.0' ] ,
+      }
+    end
+
+    def libdir(*args, &block)
+      @libdir ||= File.expand_path(__FILE__).sub(/\.rb$/,'')
+      args.empty? ? @libdir : File.join(@libdir, *args)
+    ensure
+      if block
+        begin
+          $LOAD_PATH.unshift(@libdir)
+          block.call()
+        ensure
+          $LOAD_PATH.shift()
+        end
+      end
+    end
+
+    def load(*libs)
+      libs = libs.join(' ').scan(/[^\s+]+/)
+      Ro.libdir{ libs.each{|lib| Kernel.load(lib) } }
+    end
+
+    extend(Ro)
   end
-end
+
+#
+  begin
+    require 'rubygems'
+  rescue LoadError
+    nil
+  end
+
+  if defined?(gem)
+    Ro.dependencies.each do |lib, dependency|
+      gem(*dependency)
+      require(lib)
+    end
+  end
+
+  %w[
+    fileutils
+    yaml
+  ].each do |lib|
+    require lib
+  end
+
+#
+
+  module Ro
+    Fattr(:root){
+      Root.new(
+        case
+          when defined?(Rails.root)
+            Rails.root.to_s
+
+          when defined?(Middleman::Application)
+            Middleman::Application.server.root.to_s
+
+          else
+            "./ro"
+        end
+      )
+    }
+
+    Fattr(:cache){
+      Cache.new
+    }
+
+    Fattr(:logger){
+      nil
+    }
+
+    def Ro.nodes(*args, &block)
+      root.nodes(*args, &block)
+    end
+
+    def Ro.relative_path(path, *args)
+      options = Map.options_for!(args)
+      path = File.expand_path(String(path))
+      relative = File.expand_path(String(args.shift || options[:relative] || options[:to]))
+      Pathname.new(path).relative_path_from(Pathname.new(relative)).to_s
+    end
+
+    def Ro.realpath(path)
+      Pathname.new(path.to_s).realpath
+    end
+
+    def Ro.md5(string)
+      Digest::MD5.hexdigest(string)
+    end
+
+    def Ro.debug!
+      @logger ||= (
+        logger = ::Logger.new(STDERR)
+        logger.level = ::Logger::DEBUG
+        logger
+      )
+    end
+
+    def Ro.log(*args, &block)
+      return if @logger.nil?
+
+      level =
+        if args.size == 1
+          :debug
+        else
+          args.shift
+        end
+
+      @logger.send(level, *args, &block)
+    end
+
+    def Ro.slug_for(*args, &block)
+      options = Map.options_for!(args)
+      options[:join] = '-'
+      args.push(options)
+      Slug.for(*args, &block)
+    end
+
+    def Ro.name_for(*args, &block)
+      options = Map.options_for!(args)
+      options[:join] = '_'
+      args.push(options)
+      Slug.for(*args, &block)
+    end
+  end
+
+#
+  module Kernel
+    def ro(*args, &block)
+      Ro.nodes(*args, &block)
+    end
+  end
+
+#
+  Ro.load %w[
+
+    initializers/tilt.rb
+    initializers/env.rb
+                
+    slug.rb
+    blankslate.rb
+    util.rb
+
+    root.rb
+
+    cache.rb
+
+    template.rb
+    node.rb
+    node/list.rb
+
+  ]

data/lib/ro/blankslate.rb

@@ -0,0 +1,7 @@
+# -*- encoding : utf-8 -*-
+
+module Ro
+  class BlankSlate
+    instance_methods.each{|m| undef_method(m) unless m.to_s =~ /(^__)|object_id/}
+  end
+end

data/lib/ro/cache.rb

@@ -0,0 +1,20 @@
+module Ro
+  class Cache < ::Hash
+    def write(key, value)
+      self[key] = value
+    end
+
+    def read(key, &block)
+      if has_key?(key)
+        self[key]
+      else
+        if block
+          value = block.call
+          write(key, value)
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ro/db.rb

@@ -0,0 +1,29 @@
+module Ro
+  class Db
+    fattr :root
+
+    def initialize(*args, &block)
+      options = Map.options_for!(args)
+
+      @root = String(args.shift || options[:root] || Ro.root)
+    end
+
+    def collections
+      @collections ||= Collection::List.new
+
+      Dir.glob(glob){|path| @collections.add(path)}
+
+      @collections
+    end
+
+    def glob
+      File.join(root, '*')
+    end
+
+    def nodes(*args, &block)
+      collections.map do |collection|
+        collection.nodes(*args, &block)
+      end.flatten
+    end
+  end
+end

data/lib/ro/db/collection.rb

@@ -0,0 +1,46 @@
+module Ro
+  class Db
+    class Collection
+      class List < ::Array
+        def add(path)
+          name = File.basename(path.to_s)
+
+          unless any?{|c| c.name == name }
+            collection = Collection.new(path)
+            push(collection)
+            sort!{|a,b| a.name <=> b.name}
+          end
+        end
+      end
+
+      fattr :path
+
+      def initialize(path)
+        @path = Util.realpath(path)
+      end
+
+      def basename
+        File.basename(@path)
+      end
+
+      def name
+        basename
+      end
+
+      def dirname
+        File.dirname(@path)
+      end
+
+      def glob
+        File.join(@path, '*')
+      end
+
+      def nodes
+        Dir.glob(glob).map do |path|
+          next unless test(?d, path)
+          Ro::Node.new(path)
+        end
+      end
+    end
+  end
+end

data/lib/ro/initializers/env.rb

@@ -0,0 +1,5 @@
+module Ro
+  if ENV['RO_DEBUG']
+    Ro.debug!
+  end
+end

data/lib/ro/initializers/tilt.rb

@@ -0,0 +1,97 @@
+require 'tilt'
+
+module Tilt
+  class SyntaxHighlightingRedcarpetTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      defined?(::Redcarpet) && defined?(::Pygments) && defined?(::ERB)
+    end
+
+    def initialize_engine
+      require_template_library('redcarpet')
+      require_template_library('pygments')
+      require_template_library('erb')
+    end
+
+    def prepare
+      @engine =
+        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
+        )
+
+      @output = nil
+    end
+
+    def syntax_highlighting_renderer
+      Class.new(Redcarpet::Render::HTML) do
+        def block_code(code, language)
+          language = 'ruby' if language.to_s.strip.empty?
+          ::Pygments.highlight(code, :lexer => language, :options => {:encoding => 'utf-8'})
+        end
+      end
+    end
+
+    def evaluate(scope, locals, &block)
+      binding =
+        if scope.is_a?(::Binding)
+          scope
+        else
+          scope.instance_eval{ ::Kernel.binding }
+        end
+
+      @engine.render(erb(data, binding))
+    end
+    
+    def erb(string, binding)
+      string
+    end
+
+    def allows_script?
+      true
+    end
+  end
+
+  class ERBSyntaxHighlightingRedcarpetTemplate < SyntaxHighlightingRedcarpetTemplate
+    def erb(string, binding)
+      ::ERB.new(string).result(binding)
+    end
+  end
+end
+
+Tilt.prefer(Tilt::SyntaxHighlightingRedcarpetTemplate, 'md')
+Tilt.prefer(Tilt::SyntaxHighlightingRedcarpetTemplate, 'markdown')
+Tilt.prefer(Tilt::ERBSyntaxHighlightingRedcarpetTemplate, 'md.erb')
+Tilt.prefer(Tilt::ERBSyntaxHighlightingRedcarpetTemplate, 'markdown.erb')
+
+
+if $0 == __FILE__
+
+markdown = <<-__
+* one
+* two
+* <%= :three %>
+* <%= @x %>
+
+```rb
+@a = 42
+yield
+```
+__
+
+template = Tilt['md.erb'].new{ markdown  }
+
+object = Object.new.instance_eval{ @x = :four; self }
+
+puts template.render(object)
+
+end

data/lib/ro/node.rb

@@ -0,0 +1,215 @@
+module Ro
+  class Node
+    fattr :root
+    fattr :path
+    fattr :name
+    fattr :type
+    fattr :loaded
+
+    def initialize(path)
+      @path = Ro.realpath(path.to_s)
+      @name = File.basename(@path)
+      @type = File.basename(File.dirname(@path))
+      @root = Ro::Root.new(File.dirname(File.dirname(@path)))
+      @loaded = false
+      @attributes = nil
+      @in_method_missing = false
+    end
+
+    def id
+      @name
+    end
+
+    def identifier
+      "#{ type }/#{ name }"
+    end
+
+    def inspect
+      #"#{ self.class.name }(#{ type }/#{ name })"
+      identifier
+    end
+
+    def to_s
+      inpsect
+    end
+
+    def basename
+      name
+    end
+
+    def method_missing(method, *args, &block)
+      Ro.log "Ro::Node(#{ identifier })#method_missing(#{ method.inspect }, #{ args.inspect })"
+
+      in_method_missing = !!@in_method_missing
+
+      return super if in_method_missing
+
+      @in_method_missing = true
+
+      _load do
+        key = method.to_s
+
+        return(
+          if @attributes.has_key?(key)
+            @attributes[key]
+          else
+            super
+          end
+        )
+      end
+    ensure
+      @in_method_missing = in_method_missing
+    end
+
+    def attributes
+      _load{ @attributes }
+    end
+
+    def instance_eval(*args, &block)
+      _load{ super }
+    end
+
+    def related(*args, &block)
+      _load{
+        related = @attributes.get(:related) || Map.new
+        nodes = List.new(root)
+        list = root.nodes
+        which = Coerce.list_of_strings(args) 
+
+        related.each do |relationship, value|
+          unless which.empty?
+            next unless which.include?(relationship.to_s)
+          end
+
+          type, names =
+            case value
+              when Hash
+                value.to_a.first
+              else
+                [relationship, value]
+            end
+
+          names = Coerce.list_of_strings(names)
+
+          names.each do |name|
+            identifier = "#{ type }/#{ name }"
+            node = list.index[identifier]
+            node._load{ nodes.add(node) }
+          end
+        end
+
+        case
+          when block.nil?
+            nodes
+
+          when block
+            nodes.where(&block)
+        end
+      }
+    end
+
+    class Related
+      fattr :attributes
+
+      def initialize(attributes)
+        @attributes = attributes
+      end
+
+      def all
+        related = @attributes.get(:related) || Map.new
+        names = related.keys
+        self[names]
+      end
+
+      def [](name)
+        name = File.basename(name.to_s)
+
+        value = @attributes.get(:related, name)
+        
+        type, names =
+          case value
+            when Hash
+              value.to_a.first
+            else
+              [name, value]
+          end
+
+        names = Array(names).flatten.compact.uniq
+
+        list = ro[type]
+
+        list.where(*names)
+      end
+    end
+
+    def _load(&block)
+      unless @loaded
+        @loaded = _load_from_cache_or_disk
+      end
+
+      block ? block.call : @loaded
+    end
+
+    def _load_from_cache_or_disk
+      cache_key = _cache_key
+
+      cached = Ro.cache.read(cache_key)
+
+      if cached
+        Ro.log "loading #{ identifier } from cache"
+        @attributes = Map.new.update(cached)
+        :cache
+      else
+        Ro.log "loading #{ identifier } from disk"
+        @attributes = Map.new
+        _load_attributes_yml
+        #_load_attribute_templates
+        #_load_sources
+        Ro.cache.write(cache_key, @attributes)
+        :disk
+      end
+    end
+
+    def _load_attributes_yml
+      if test(?s, _attributes_yml)
+        buf = IO.binread(_attributes_yml)
+        data = YAML.load(buf)
+        data = data.is_a?(Hash) ? data : {'_' => data}
+        @attributes.update(data)
+      end
+    end
+
+    def _cache_key
+      glob = File.join(@path, '**/**')
+
+      entries = []
+
+      Dir.glob(glob) do |entry|
+        stat =
+          begin
+            File.stat(entry)
+          rescue
+            next
+          end
+
+        timestamp = [stat.ctime, stat.mtime].max
+        relative_path = Ro.relative_path(entry, :to => @path)
+        entries.push([relative_path, timestamp.iso8601(2)]) 
+      end
+
+      signature = entries.map{|pair| pair.join('@')}.join(', ')
+
+      md5 = Ro.md5(signature)
+
+      "#{ @path }-#{ md5 }"
+    end
+
+    def _load_from_cache
+      false
+    end
+
+    def _attributes_yml
+      File.join(@path, 'attributes.yml')
+    end
+  end
+end

data/lib/ro/node/list.rb

@@ -0,0 +1,130 @@
+module Ro
+  class Node
+    class List < ::Array
+      fattr :root
+      fattr :type
+      fattr :index
+
+      def initialize(*args, &block)
+        options = Map.options_for!(args)
+
+        root = args.shift || options[:root]
+        type = args.shift || options[:type]
+
+        @root = Root.new(root)
+        @type = type.nil? ? nil : String(type)
+        @index = {}
+
+        block.call(self) if block
+      end
+
+      def load(path)
+        add( node = Node.new(path) )
+      end
+
+      def add(node)
+        return nil if node.nil?
+
+        unless index.has_key?(node.identifier)
+          push(node)
+          index[node.identifier] = node
+          node
+        else
+          false
+        end
+      end
+
+      def related(*args, &block)
+        related = List.new(root)
+
+        each do |node|
+          node.related(*args, &block).each do |related_node|
+            related.add(related_node)
+          end
+        end
+        
+        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}
+        end
+      end
+
+      def select(*args, &block)
+        List.new(root){|list| list.replace(super)}
+      end
+
+      def where(*args, &block)
+        case
+          when !args.empty? && block
+            raise ArgumentError.new
+
+          when args.empty? && block
+            select{|node| node.instance_eval(&block)}
+
+          when !args.empty?
+            names = args.flatten.compact.uniq.map{|arg| arg.to_s}
+            index = names.inject(Hash.new){|h,name| h.update(name => name)}
+            select{|node| index[node.name]}
+
+          else
+            raise ArgumentError.new
+        end
+      end
+
+      def find(*args, &block)
+        case
+          when !args.empty? && block
+            raise ArgumentError.new
+          when args.empty? && block
+            detect{|node| node.instance_eval(&block)}
+
+          when args.size == 1
+            name = args.first.to_s
+            detect{|node| node.name == name}
+
+          when args.size > 1
+            where(*args, &block)
+
+          else
+            raise ArgumentError.new
+        end
+      end
+
+      def identifier
+        [root, type].compact.join('/')
+      end
+
+      def method_missing(method, *args, &block)
+        Ro.log "Ro::List(#{ identifier })#method_missing(#{ method.inspect }, #{ args.inspect })"
+
+        in_method_missing = !!@in_method_missing
+
+        return super if in_method_missing
+
+        @in_method_missing = true
+
+        if @scope.nil?
+          type = method.to_s
+          list = self[type]
+          super unless list
+          list.empty? ? super : list
+        else
+          name = Ro.slug_for(method)
+          node = self[name]
+          node.nil? ? super : node
+        end
+      ensure
+        @in_method_missing = in_method_missing
+      end
+    end
+  end
+end

data/lib/ro/root.rb

@@ -0,0 +1,30 @@
+module Ro
+  class Root < ::String
+    def initialize(root)
+      super(Util.realpath(root.to_s))
+    ensure
+      raise ArgumentError.new("root=#{ root.inspect }") if root.nil?
+      raise ArgumentError.new("root=#{ root.inpsect }") unless test(?d, root)
+    end
+
+    def root
+      self
+    end
+
+    def nodes
+      Node::List.new(root) do |list|
+        node_directories do |path|
+          list.load(path)
+        end
+      end
+    end
+
+    def directories(&block)
+      Dir.glob(File.join(root, '*/'), &block)
+    end
+
+    def node_directories(&block)
+      Dir.glob(File.join(root, '*/*/'), &block)
+    end
+  end
+end

data/lib/ro/slug.rb

@@ -0,0 +1,26 @@
+module Ro
+  class Slug < ::String
+    Join = '-'
+
+    def Slug.for(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      join = (options[:join]||options['join']||Join).to_s
+      string = args.flatten.compact.join(join)
+      string = unidecode(string)
+      words = string.to_s.scan(%r|[/\w]+|)
+      words.map!{|word| word.gsub %r|[^/0-9a-zA-Z_-]|, ''}
+      words.delete_if{|word| word.nil? or word.strip.empty?}
+      new(words.join(join).downcase.gsub('/', (join * 2)))
+    end
+
+    unless defined?(Stringex::Unidecoder)
+      def Slug.unidecode(string)
+        string
+      end
+    else
+      def Slug.unidecode(string)
+        Stringex::Unidecoder.decode(string)
+      end
+    end
+  end
+end

data/lib/ro/template.rb

@@ -0,0 +1,9 @@
+module Ro
+  class Template
+    fattr :path
+
+    def initialize(path)
+      @path = Ro.realpath(path)
+    end
+  end
+end

data/lib/ro/util.rb

@@ -0,0 +1,13 @@
+module Ro
+  module Util
+    def realpath(path)
+      begin
+        Pathname.new(path.to_s).expand_path.realpath.to_s
+      rescue Object
+        File.expand_path(path.to_s)
+      end
+    end
+
+    extend(self)
+  end
+end

data/notes/ara.txt

@@ -0,0 +1,84 @@
+todo:
+  - need source file loading
+
+  - need asset/url_for management
+
+  - ./bin/ro shell
+    - binding of all nodes?
+
+  - a real live test suite
+
+
+
+
+done:
+  - need relationships
+    - ro.posts.related
+    - ro.posts.related.tags
+    - ro.posts.related[:tags]
+    - ro.posts.first.related.tags
+    - ro.posts.first.related[:tags]
+  - to_ary should not cause loading to fire
+  - node_sets
+    - ro -> node_set
+    - ro.posts -> node_set
+    - ro.posts
+  - should rollection be 'directory.ls'
+  - basic lib structure
+  - awesome tilt methods
+  - an extremely clever cache
+  - instrument logging/debugging
+
+
+
+
+
+
+
+
+
+
+ro # all nodes
+
+ro.posts  #=> set of all post nodes
+
+ro.posts.tags #=> set of all tags related to any post
+
+ro.tags.posts #=> set of all posts related to any tag
+
+ro.posts{ name == 'foobar' }
+
+ro.posts.first.tags
+
+ro.posts.page(10, :per => 10)
+
+ro.posts.first.url_for(:foobar)
+
+ro/people/foo-bar/attributes.yaml
+ro/people/foo-bar/attributes.yml
+ro/people/foo-bar/bio.md
+ro/people/foo-bar/source/a.rb
+ro/people/foo-bar/assets/mugshot.png
+
+
+
+
+
+require 'ro/model'
+
+
+
+
+----
+
+class People < Ro::Model
+  root :people
+end
+
+Ro.root
+
+Ro.nodes
+
+def ro(*args, &block)
+  Ro.nodes(*args, &block)
+end

data/ro.gemspec

@@ -3,13 +3,55 @@
 
 Gem::Specification::new do |spec|
   spec.name = "ro"
-  spec.version = "0.0.1"
+  spec.version = "1.0.0"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "ro"
   spec.description = "description: ro kicks the ass"
+  spec.license = "Same As Ruby's"
 
   spec.files =
-["Rakefile", "lib", "lib/ro.rb", "ro.gemspec"]
+[":",
+ ":w",
+ "=p",
+ "README.md",
+ "Rakefile",
+ "lib",
+ "lib/co",
+ "lib/co/db.rb",
+ "lib/co/node",
+ "lib/co/node.rb",
+ "lib/co/node/list.rb",
+ "lib/co/util.rb",
+ "lib/lib",
+ "lib/ro",
+ "lib/ro.rb",
+ "lib/ro/blankslate.rb",
+ "lib/ro/cache.rb",
+ "lib/ro/db",
+ "lib/ro/db.rb",
+ "lib/ro/db/collection",
+ "lib/ro/db/collection.rb",
+ "lib/ro/initializers",
+ "lib/ro/initializers/env.rb",
+ "lib/ro/initializers/tilt.rb",
+ "lib/ro/node",
+ "lib/ro/node.rb",
+ "lib/ro/node/list.rb",
+ "lib/ro/root.rb",
+ "lib/ro/slug.rb",
+ "lib/ro/template.rb",
+ "lib/ro/util.rb",
+ "notes",
+ "notes/ara.txt",
+ "ro",
+ "ro.gemspec",
+ "ro/people",
+ "ro/people/ara",
+ "ro/people/ara/attributes.yml",
+ "ro/posts",
+ "ro/posts/foobar",
+ "ro/posts/hello-world",
+ "ro/posts/hello-world/attributes.yml"]
 
   spec.executables = []
   
@@ -18,6 +60,18 @@ Gem::Specification::new do |spec|
   spec.test_files = nil
 
   
+    spec.add_dependency(*["map", " >= 6.5.1"])
+  
+    spec.add_dependency(*["fattr", " >= 2.2.1"])
+  
+    spec.add_dependency(*["tilt", " >= 1.4.1"])
+  
+    spec.add_dependency(*["pygments.rb", " >= 0.5.0"])
+  
+    spec.add_dependency(*["coerce", " >= 0.0.4"])
+  
+    spec.add_dependency(*["stringex", " >= 2.1.0"])
+  
 
   spec.extensions.push(*[])
 

data/ro/people/ara/attributes.yml

@@ -0,0 +1,11 @@
+first_name: Ara
+
+last_name: Howard
+
+related:
+  posts:
+    - hello-world
+
+  sample_posts:
+    posts:
+      - hello-world

data/ro/posts/hello-world/attributes.yml

@@ -0,0 +1,3 @@
+title: Hello World
+
+published_at: 2013-10-31T00:00:00

metadata

@@ -1,47 +1,153 @@
 --- !ruby/object:Gem::Specification
 name: ro
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - Ara T. Howard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-07 00:00:00.000000000 Z
-dependencies: []
+date: 2013-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: map
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 6.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 6.5.1
+- !ruby/object:Gem::Dependency
+  name: fattr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+- !ruby/object:Gem::Dependency
+  name: pygments.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: coerce
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+- !ruby/object:Gem::Dependency
+  name: stringex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
 description: ! 'description: ro kicks the ass'
 email: ara.t.howard@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ! ':'
+- ':w'
+- README.md
 - Rakefile
+- lib/co/db.rb
+- lib/co/node.rb
+- lib/co/node/list.rb
+- lib/co/util.rb
 - lib/ro.rb
+- lib/ro/blankslate.rb
+- lib/ro/cache.rb
+- lib/ro/db.rb
+- lib/ro/db/collection.rb
+- lib/ro/initializers/env.rb
+- lib/ro/initializers/tilt.rb
+- lib/ro/node.rb
+- lib/ro/node/list.rb
+- lib/ro/root.rb
+- lib/ro/slug.rb
+- lib/ro/template.rb
+- lib/ro/util.rb
+- notes/ara.txt
 - ro.gemspec
+- ro/people/ara/attributes.yml
+- ro/posts/foobar
+- ro/posts/hello-world/attributes.yml
 homepage: https://github.com/ahoward/ro
-licenses: []
+licenses:
+- Same As Ruby's
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: codeforpeople
-rubygems_version: 1.8.11
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: ro
 test_files: []