silly 0.0.1

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+gemspec
+
+group :test do
+  gem 'cucumber'
+  gem 'capybara'
+  gem 'rspec'
+end

data/README.md

@@ -0,0 +1,200 @@
+[![Build Status](https://travis-ci.org/ruhoh/silly.png?branch=master)](https://travis-ci.org/ruhoh/silly)
+
+Silly is a filesystem based Object Document Mapper.  
+Use it to query a directory like you would a database -- useful for static websites.
+
+## Installation
+
+Silly is in alpha which means the API is unstable and still under development. Silly is/will-be used to power [ruhoh](http://ruhoh.com) 3.0. You can contribute and help stablize Silly by playing with it and providing feedback!
+
+Install and run the development (head) version:
+
+    $ git@github.com:ruhoh/silly.git
+
+Take note of where you downloaded the gem.
+
+Navigate to a directory you want to query.
+
+Create a file named `Gemfile` with the contents:
+
+    gem 'silly', :path => '/Users/jade/Dropbox/gems/silly'
+
+Make sure to replace the path with where you downloaded the gem.
+
+Install the bundle:
+
+    $ bundle install
+
+## Usage
+
+We can test the query API by loading an irb session loading Silly:
+
+Load irb:
+
+    $ bundle exec irb
+
+Load and instantiate silly relative to the current directory:
+
+    > require 'silly'
+    > query = Silly::Query.new
+    > query.append_path(Dir.pwd)
+
+
+## Data
+
+### Cascade
+
+Append an arbitrary number of paths to enable a logical cascade where files overload one another of the same name.
+
+```ruby
+query = Silly::Query.new
+query.append_path(Dir.pwd)
+query.append_path(File.join(Dir.pwd, "theme-folder"))
+```
+
+### Data Files
+
+Data files are automatically parsed and merged down the cascade:
+
+    Given:
+      ./data.yml
+      ./theme-folder/data.json
+
+    query = Silly::Query.new
+    query.append_path(Dir.pwd)
+    query.append_path("theme-folder")
+
+    query.where("$shortname" => "data").first
+
+### File metadata
+
+Files have inherit metadata such as path, filename, extension etc.
+Files can also define arbitrary in-file "top metadata" or FrontMatter made popular by static site generators like Jekyll.
+
+**page.html**
+
+    ---
+    title: "A custom title"
+    date: "2013/12/12"
+    tags: 
+      - opinion
+      - tech
+    ---
+
+    ... content ...
+
+
+## Query API
+
+All queries return a [Silly::Collection](https://github.com/ruhoh/silly/blob/master/lib/silly/collection.rb) of [Silly::Item](https://github.com/ruhoh/silly/blob/master/lib/silly/item.rb)s.
+
+`Silly::Item` represents a file. 
+
+`@item.data` lazily generates any metadata in the file.
+
+`@item.content` lazily generates the raw content of the file.
+
+
+### Path
+
+**Return all files in the base directory (unnested)**
+
+```ruby
+query = Silly::Query.new
+query.append_path(Dir.pwd)
+
+query.to_a
+```
+
+**Return files in the base directory and all sub-directories.**
+
+```ruby
+query = Silly::Query.new
+query.append_path(Dir.pwd)
+
+query.path_all("").to_a 
+```
+
+### Filter
+
+**Return files with specific extension**
+
+```ruby
+query = Silly::Query.new
+query.append_path(Dir.pwd)
+
+query.where("$ext" => ".md").to_a
+```
+
+**Return files contained in a given directory (can be any nesting level)**
+
+```ruby
+query = Silly::Query.new
+query.append_path(Dir.pwd)
+
+query.where("$directories" => "drafts").to_a
+```
+
+**Return files where an attribute is a given value**
+
+```ruby
+query = Silly::Query.new
+query.append_path(Dir.pwd)
+
+query.where("size" => "med").to_a
+```
+
+**Return files where an attribute is not a given value**
+
+```ruby
+query = Silly::Query.new
+query.append_path(Dir.pwd)
+
+query.where("size" => {"$ne" => "med"}).to_a
+```
+
+**Return files where an attribute exists**
+
+```ruby
+query = Silly::Query.new
+query.append_path(Dir.pwd)
+
+query.where("size" => {"$exists" => true}).to_a
+```
+
+
+### Sort
+
+**Return files sorted by a given attribute**
+
+```ruby
+query = Silly::Query.new
+query.append_path(Dir.pwd)
+
+query.sort([:date, :desc]).to_a
+```
+
+
+### Chaining
+
+```ruby
+query = Silly::Query.new
+query.append_path(Dir.pwd)
+
+query
+  .path("posts")
+  .where("$directories" => { "drafts" => { "$ne" => "drafts" } })
+  .sort([:date, :desc])
+  .to_a
+```
+
+## Why
+
+Silly has no dependencies so it's a great engine to build custom static site generators on top of.
+
+I really like the idea of a static website generator but it's really hard to get people to adopt your philosphy of how thing's should work so rather than do that why not empower anyone to build a static generator however they want! That's the idea anyway and this is a very early release so we'll see.
+Also I am really inspired by projects like [Tire](https://github.com/karmi/retire) and [Mongoid](https://github.com/mongoid/mongoid) of which I've taken heavy inspiration from. Silly is a way to level up my gem skills B).
+
+## License 
+
+[MIT](http://www.opensource.org/licenses/mit-license.html)

data/Rakefile

@@ -0,0 +1,23 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), *%w[lib]))
+require 'rubygems'
+require 'rake'
+require 'bundler'
+require 'ruhoh/version'
+
+name = Dir['*.gemspec'].first.split('.').first
+gemspec_file = "#{name}.gemspec"
+gem_file = "#{name}-#{Silly::VERSION}.gem"
+
+task :release => :build do
+  sh "git commit --allow-empty -m 'Release #{Silly::VERSION}'"
+  sh "git tag v#{Silly::VERSION}"
+  sh "git push origin master --tags"
+  sh "git push origin v#{Silly::VERSION}"
+  sh "gem push pkg/#{name}-#{Silly::VERSION}.gem"
+end
+
+task :build do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end

data/features/data_file.feature

@@ -0,0 +1,82 @@
+Feature: Data File
+  I want to natively access the data in data files so I can use the data in my content
+
+  Scenario: Query data file
+    Given the file "person.yml" with body:
+      """
+      ---
+      name: "jade"
+      address:
+        city: "alhambra"
+      fruits:
+        - mango
+        - kiwi
+      """
+    When I query the path ""
+      Then this query's first result should have the data:
+      """
+      {
+          "name": "jade",
+          "address": {
+              "city": "alhambra"
+          },
+          "fruits": [
+              "mango",
+              "kiwi"
+          ]
+      }
+      """
+
+  Scenario: Query a merged data file
+    Given the file "person.yml" with body:
+      """
+      ---
+      name: "jade"
+      address:
+        city: "alhambra"
+      fruits:
+        - mango
+        - kiwi
+      """
+      And the file "cascade/person.yml" with body:
+        """
+        ---
+        name: "Bob"
+        greeting: "Hai!"
+        """
+      And I append the path "cascade" to the query
+    When I query the path ""
+    Then this query's first result should have the data:
+      """
+      {
+          "name": "Bob",
+          "greeting" : "Hai!",
+          "address": {
+              "city": "alhambra"
+          },
+          "fruits": [
+              "mango",
+              "kiwi"
+          ]
+      }
+      """
+
+  Scenario: Query a merged data file with different formats
+    Given the file "person.json" with body:
+      """
+        { "name" : "Bob" }
+      """
+      And the file "cascade/person.yml" with body:
+        """
+        ---
+        greeting: "Hai!"
+        """
+      And I append the path "cascade" to the query
+    When I query the path ""
+    Then this query's first result should have the data:
+      """
+      {
+          "name": "Bob",
+          "greeting" : "Hai!"
+      }
+      """

data/features/path.feature

@@ -0,0 +1,38 @@
+Feature: Query Path
+  I want to scope a query to a path so I can better arrange my content for optimized user experience.
+
+  Scenario: Query with empty path (base path)
+  Given some files with values:
+    | file           |
+    | apple.html     |
+    | banana.html    |
+    | cranberry.html |
+  When I query the path ""
+  Then this query returns the ordered results "apple.html, banana.html, cranberry.html"
+
+  Scenario: Query with path
+  Given some files with values:
+    | file                |
+    | food/apple.html     |
+    | food/banana.html    |
+    | food/cranberry.html |
+  When I query the path "food"
+  Then this query returns the ordered results "food/apple.html, food/banana.html, food/cranberry.html"
+
+  Scenario: Query with path and nested files
+  Given some files with values:
+    | file                |
+    | food/apple.html     |
+    | food/cool/banana.html    |
+    | food/cool/cranberry.html |
+  When I query the path "food"
+  Then this query returns the ordered results "food/apple.html"
+
+  Scenario: Query with path_all and nested files
+  Given some files with values:
+    | file                |
+    | food/apple.html     |
+    | food/cool/banana.html    |
+    | food/cool/cranberry.html |
+  When I query the path_all "food"
+  Then this query returns the ordered results "food/apple.html, food/cool/banana.html, food/cool/cranberry.html"

data/features/sort.feature

@@ -0,0 +1,42 @@
+Feature: Query Sort
+  I want to sort a query so I can better arrange my content for optimized user experience.
+
+  Scenario: Query with sort
+    Given some files with values:
+      | file                |
+      | food/apple.html     |
+      | food/banana.html    |
+      | food/cranberry.html |
+    When I query the path "food"
+      And I sort the query by "id" "desc"
+    Then this query returns the ordered results "food/cranberry.html, food/banana.html, food/apple.html"
+
+  Scenario: Query with sort by metadata attribute
+    Given some files with values:
+      | file                | order |
+      | food/apple.html     | 2     |
+      | food/banana.html    | 3     |
+      | food/cranberry.html | 1     |
+    When I query the path "food"
+      And I sort the query by "order" "asc"
+    Then this query returns the ordered results "food/cranberry.html, food/apple.html, food/banana.html"
+
+  Scenario: Query with sort by date attribute ascending
+    Given some files with values:
+      | file            | date        |
+      | essays/hello.md | 2013-12-01  |
+      | essays/zebra.md | 2013-12-10  |
+      | essays/apple.md | 2013-12-25  |
+    When I query the path "essays"
+      And I sort the query by "date" "asc"
+    Then this query returns the ordered results "essays/hello.md, essays/zebra.md, essays/apple.md"
+
+  Scenario: Query with sort by date attribute descending
+    Given some files with values:
+      | file            | date        |
+      | essays/hello.md | 2013-12-01  |
+      | essays/zebra.md | 2013-12-10  |
+      | essays/apple.md | 2013-12-25  |
+    When I query the path "essays"
+      And I sort the query by "date" "desc"
+    Then this query returns the ordered results "essays/apple.md, essays/zebra.md, essays/hello.md"

data/features/step_defs.rb

@@ -0,0 +1,57 @@
+Transform(/^(should|should NOT)$/) do |matcher|
+  matcher.downcase.gsub(' ', '_')
+end
+
+When(/^I query the path "(.*?)"$/) do |term|
+  query.path(term)
+end
+
+When(/^I query the path_all "(.*?)"$/) do |term|
+  query.path_all(term)
+end
+
+When(/^I sort the query by "(.*?)" "(.*?)"$/) do |attribute, order|
+  query.sort([attribute, order])
+end
+
+When(/^I filter the query with:$/) do |json|
+  query.where(JSON.parse(json))
+end
+
+When(/^this query returns the ordered results "(.*?)"$/) do |results|
+  results = results.split(/[\s,]+/).map(&:strip)
+  query.map{ |a| a["id"] }.should == results
+end
+
+When(/^this query's first result should have the data:$/) do |json|
+  data = JSON.parse(json)
+  result = query.first
+  result.data.should == data
+end
+
+When(/^I append the path "(.*?)" to the query$/) do |path|
+  query.append_path(File.join(SampleSitePath, path))
+end
+
+Given(/^a config file with value:$/) do |string|
+  make_config(JSON.parse(string))
+end
+
+Given(/^a config file with values:$/) do |table|
+  data = table.rows_hash
+  data.each{ |key, value| data[key] = JSON.parse(value) }
+  make_config(data)
+end
+
+Given(/^the file "(.*)" with body:$/) do |file, body|
+  make_file(path: file, body: body)
+end
+
+Given(/^some files with values:$/) do |table|
+  table.hashes.each do |row|
+    file = row['file'] ; row.delete('file')
+    body = row['body'] ; row.delete('body')
+
+    make_file(path: file, data: row, body: body)
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,9 @@
+require 'fileutils'
+require 'rspec/expectations'
+#require 'capybara/cucumber'
+World(RSpec::Matchers)
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'silly'

data/features/support/helpers.rb

@@ -0,0 +1,59 @@
+SampleSitePath = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '__tmp'))
+
+def query
+  @query ||= new_query
+end
+
+def new_query
+  query = Silly::Query.new
+  query.append_path(SampleSitePath)
+  query
+end
+
+def make_config(data)
+  path = File.join(SampleSitePath, "config.yml")
+  File.open(path, "w+") { |file|
+    file.puts data.to_yaml
+  }
+end
+
+def make_file(opts)
+  path = File.join(SampleSitePath, opts[:path])
+  FileUtils.mkdir_p(File.dirname(path))
+
+  data = opts[:data] || {}
+  if data['categories']
+    data['categories'] = data['categories'].to_s.split(',').map(&:strip)
+  end
+  if data['tags']
+    data['tags'] = data['tags'].to_s.split(',').map(&:strip)
+    puts "tags #{data['tags']}"
+  end
+  data.delete('layout') if data['layout'].to_s.strip.empty?
+
+  metadata = data.empty? ? '' : data.to_yaml.to_s + "\n---\n"
+
+  File.open(path, "w+") { |file|
+    if metadata.empty?
+      file.puts <<-TEXT
+#{ opts[:body] }
+TEXT
+    else
+      file.puts <<-TEXT
+#{ metadata }
+
+#{ opts[:body] }
+TEXT
+    end
+  }
+end
+
+Before do
+  remove_instance_variable(:@query) if (instance_variable_defined?(:@query))
+  FileUtils.remove_dir(SampleSitePath,1) if Dir.exists? SampleSitePath
+  Dir.mkdir SampleSitePath
+end
+
+After do
+  FileUtils.remove_dir(SampleSitePath,1) if Dir.exists? SampleSitePath
+end

data/features/where.feature

@@ -0,0 +1,56 @@
+Feature: Query filter
+  I want to filter a query so I can better arrange my content for optimized user experience.
+
+  Scenario: Query with filter by metadata attribute
+    Given some files with values:
+      | file                | type  |
+      | food/apple.html     | fruit |
+      | food/banana.html    | fruit |
+      | food/cranberry.html | fruit |
+      | food/peanuts.html   | nuts  |
+    When I query the path "food"
+      And I filter the query with:
+        """
+        {"type" : "nuts"}
+        """
+    Then this query returns the ordered results "food/peanuts.html"
+
+  Scenario: Query with filter by 2 different metadata attributes
+    Given some files with values:
+      | file                | type  | size  |
+      | food/apple.html     | fruit | small |
+      | food/banana.html    | fruit | small |
+      | food/cranberry.html | fruit | small |
+      | food/peanuts.html   | nuts  | small |
+      | food/walnuts.html   | nuts  | med   |
+    When I query the path "food"
+      And I filter the query with:
+        """
+        { "type" : "nuts" }
+        """
+      And I filter the query with:
+        """
+        { "size" : "med" }
+        """
+    Then this query returns the ordered results "food/walnuts.html"
+
+  Scenario: Query with filter by 2 of the same metadata attributes
+    Given some files with values:
+      | file                | type  | size  |
+      | food/cranberry.html | fruit | med   |
+      | food/peanuts.html   | nuts  | small |
+      | food/walnuts.html   | nuts  | med   |
+    When I query the path "food"
+      And I filter the query with:
+        """
+        { "size" : "med" }
+        """
+      And I filter the query with:
+        """
+        { "type" : "nuts" }
+        """
+      And I filter the query with:
+        """
+        { "type" : {"$exists" : true } }
+        """
+    Then this query returns the ordered results "food/walnuts.html"

data/features/where_file.feature

@@ -0,0 +1,72 @@
+Feature: Query filter by file attributes
+  I want to filter a query so I can better arrange my content for optimized user experience.
+
+  Scenario: Query with filter by extension
+    Given some files with values:
+      | file                |
+      | food/apple.html     |
+      | food/banana.md      |
+      | food/cranberry.html |
+      | food/peanuts.md     |
+    When I query the path "food"
+      And I filter the query with:
+        """
+        { "$ext" : ".md" }
+        """
+    Then this query returns the ordered results "food/banana.md, food/peanuts.md"
+
+  Scenario: Query with filter by filename
+    Given some files with values:
+      | file                |
+      | food/apple.html     |
+      | food/banana.md      |
+      | food/cranberry.html |
+      | food/peanuts.md     |
+    When I query the path "food"
+      And I filter the query with:
+        """
+        { "$filename" : "food/peanuts" }
+        """
+    Then this query returns the ordered results "food/peanuts.md"
+
+  Scenario: Query with filter by filename nested
+    Given some files with values:
+      | file                  |
+      | food/fruit/apple.html |
+      | food/fruit/banana.md  |
+      | food/banana.html      |
+      | food/peanuts.md       |
+    When I query the path_all "food"
+      And I filter the query with:
+        """
+        { "$filename" : "food/fruit/banana" }
+        """
+    Then this query returns the ordered results "food/fruit/banana.md"
+
+  Scenario: Query with filter by directories
+    Given some files with values:
+      | file                  |
+      | food/fruit/apple.html |
+      | food/fruit/banana.md  |
+      | food/cranberry.html   |
+      | food/peanuts.md       |
+    When I query the path_all "food"
+      And I filter the query with:
+        """
+        { "$directories" : "fruit" }
+        """
+    Then this query returns the ordered results "food/fruit/apple.html, food/fruit/banana.md"
+
+  Scenario: Query with filter by shortname
+    Given some files with values:
+      | file                  |
+      | food/fruit/apple.html |
+      | food/fruit/banana.md  |
+      | food/banana.html      |
+      | food/peanuts.md       |
+    When I query the path_all "food"
+      And I filter the query with:
+        """
+        { "$shortname" : "banana" }
+        """
+    Then this query returns the ordered results "food/banana.html food/fruit/banana.md"

data/lib/silly.rb

@@ -0,0 +1,174 @@
+# encoding: UTF-8
+Encoding.default_internal = 'UTF-8'
+
+require 'json'
+require 'time'
+require 'fileutils'
+require 'delegate'
+require 'observer'
+require 'set'
+
+FileUtils.cd(path = File.join(File.dirname(__FILE__), 'silly')) do
+  Dir[File.join('**', '*.rb')].each { |f| require File.join(path, f) }
+end
+
+module Silly
+  FileSeparator = File::ALT_SEPARATOR ?
+                    %r{#{ File::SEPARATOR }|#{ File::ALT_SEPARATOR }} :
+                    File::SEPARATOR
+
+  class Query
+    include Enumerable
+    attr_accessor :paths
+
+    def initialize
+      @criteria = {
+        "path" => nil,
+        "sort" => ["id", "asc"],
+        "where" => [],
+      }
+      @paths = Set.new
+    end
+
+    def append_path(path)
+      @paths << path
+    end
+
+    BlackList = ["", "~", "/"]
+    def path(path)
+      @criteria["path"] = BlackList.include?(path.to_s) ? "*" : File.join(path, "*")
+      self
+    end
+
+    def path_all(path)
+      @criteria["path"] = File.join(path, "**", "**")
+      self
+    end
+
+    def sort(conditions=[])
+      @criteria["sort"] = conditions
+      self
+    end
+
+    def where(conditions)
+      @criteria["where"] << conditions
+      self
+    end
+
+    def each
+      block_given? ?
+        execute.each { |a| yield(a) } :
+        execute
+    end
+
+    def execute
+      @criteria["path"] ||= "*"
+      puts "EXECUTE:\n #{ @criteria.pretty_inspect }"
+      data = files(@criteria["path"])
+
+      unless @criteria["where"].empty?
+        data = data.keep_if { |id, pointer| filter_function(pointer) }
+      end
+
+      data = data.values.sort { |a,b| sorting_function(a,b) }
+
+      Silly::Collection.new(data)
+    end
+
+    def list
+      results = Set.new
+
+      paths.each do |path|
+        FileUtils.cd(path) {
+          results += Dir['*'].select { |x| File.directory?(x) }
+        }
+      end
+
+      results.to_a
+    end
+
+    def inspect
+      "#{ self.class.name }\n criteria:\n #{ @criteria.inspect }"
+    end
+
+    private
+
+    # Collect all files for the given @collection["path"].
+    # Each item can have 3 file references, one per each cascade level.
+    # The file hashes are collected in order so they will overwrite eachother.
+    # but references to all found items on the cascade are recorded.
+    # @return[Hash] dictionary of Items.
+    def files(glob)
+      dict = {}
+
+      paths.each do |path|
+        FileUtils.cd(path) {
+          Dir[glob].each { |id|
+            next unless File.exist?(id) && FileTest.file?(id)
+
+            filename = id.gsub(Regexp.new("#{ File.extname(id) }$"), '')
+
+            if dict[filename]
+              dict[filename]["cascade"] << File.realpath(id)
+            else
+              dict[filename] = Silly::Item.new({
+                "id" => id,
+                "cascade" => [File.realpath(id)]
+              })
+            end
+          }
+        }
+      end
+
+      dict
+    end
+
+    FileAttributes = %{ id filename shortname directories ext }
+
+    def filter_function(item)
+      @criteria["where"].each do |condition|
+        condition.each do |attribute_name, value|
+          attribute_name = attribute_name.to_s
+          attribute = attribute_name[0] == "$" ?
+                        item.__send__(attribute_name[1, attribute_name.size]) :
+                        item.data[attribute_name]
+
+          valid = Silly::QueryOperators.execute(attribute, value)
+
+          return false unless valid
+        end
+      end
+    end
+
+    def sorting_function(a, b)
+      attribute = @criteria["sort"][0].to_s
+      direction = @criteria["sort"][1].to_s
+
+      # Optmization to omit parsing internal metadata when unecessary.
+      if FileAttributes.include?(attribute)
+        this_data = a.__send__(attribute)
+        other_data = b.__send__(attribute)
+      else
+        this_data = a.data[attribute]
+        other_data = b.data[attribute]
+      end
+
+      if attribute == "date"
+        if this_data.nil? || other_data.nil?
+          raise(
+            "ArgumentError:" +
+            " The query is sorting on 'date'" +
+            " but '#{ this_data['id'] }' or '#{ other_data['id'] }' has no parseable date in its metadata." +
+            " Add date: 'YYYY-MM-DD' to its metadata."
+          )
+        end
+      end
+
+      if direction == "asc"
+        this_data <=> other_data
+      else
+        other_data <=> this_data
+      end
+    end
+  end
+end

data/lib/silly/base_model.rb

@@ -0,0 +1,10 @@
+module Silly
+  class BaseModel < SimpleDelegator
+    def process
+      {
+        "data" => {},
+        "content" => File.open(realpath, 'r:UTF-8') { |f| f.read }
+      }
+    end
+  end
+end

data/lib/silly/collection.rb

@@ -0,0 +1,9 @@
+module Silly
+  class Collection < SimpleDelegator
+    attr_accessor :collection_name
+
+    def initialize(data)
+      super(data)
+    end
+  end
+end

data/lib/silly/data_model.rb

@@ -0,0 +1,15 @@
+module Silly
+  class DataModel < SimpleDelegator
+    def process
+      data = {}
+      cascade.each do |path|
+        data = Silly::Utils.deep_merge(data, (Silly::Parse.data_file(path) || {}))
+      end
+
+      { 
+        "data" => data,
+        "content" => Silly::Parse.page_file(realpath)
+      }
+    end
+  end
+end

data/lib/silly/item.rb

@@ -0,0 +1,73 @@
+module Silly
+  class Item
+    include Observable
+    attr_reader :pointer
+    attr_accessor :content, :collection
+
+    def initialize(hash)
+      @pointer = hash
+    end
+
+    def [](key)
+      respond_to?(key) ? __send__(key) : nil
+    end
+
+    def id
+      @pointer["id"]
+    end
+
+    def realpath
+      @pointer["cascade"].last
+    end
+
+    def cascade
+      @pointer["cascade"]
+    end
+
+    def filename
+      @filename ||= id.gsub(Regexp.new("#{ ext }$"), '')
+    end
+
+    def shortname
+      File.basename(id, ext)
+    end
+
+    def directories
+      File.dirname(id).split(Silly::FileSeparator)
+    end
+
+    def model
+      %w{ .json .yaml .yml }.include?(ext) ? 
+        "data" :
+        "page"
+    end
+
+    def ext
+      File.extname(id)
+    end
+
+    # @returns[Hash Object] Top page metadata
+    def data
+      @data ||= (_model.process["data"] || {})
+    end
+
+    # @returns[String] Raw page content
+    def content
+      @content ||= (_model.process["content"] || "")
+    end
+
+    private
+
+    def _model
+      return @_model if @_model
+
+      klass = if model == "data"
+                Silly::DataModel
+              else
+                Silly::PageModel
+              end
+
+      @_model = klass.new(self)
+    end
+  end
+end

data/lib/silly/page_model.rb

@@ -0,0 +1,79 @@
+module Silly
+  class PageModel < SimpleDelegator
+    DateMatcher = /^(.+\/)*(\d+-\d+-\d+)-(.*)(\.[^.]+)$/
+    Matcher = /^(.+\/)*(.*)(\.[^.]+)$/
+
+    # Process this file. See #parse_page_file
+    # @return[Hash] the processed data from the file.
+    #   ex:
+    #   { "content" => "..", "data" => { "key" => "value" } }
+    def process
+      return {} unless file?
+
+      parsed_page = Silly::Parse.page_file(realpath)
+      data = parsed_page['data']
+
+      filename_data = parse_page_filename(id)
+
+      data['pointer'] = pointer.dup
+      data['id'] = id
+
+      data['title'] = data['title'] || filename_data['title']
+      data['date'] ||= filename_data['date']
+
+      # Parse and store date as an object
+      begin
+        data['date'] = Time.parse(data['date']) unless data['date'].nil? || data['date'].is_a?(Time)
+      rescue
+        raise(
+          "ArgumentError: The date '#{data['date']}' specified in '#{ id }' is unparsable."
+        )
+        data['date'] = nil
+      end
+
+      parsed_page['data'] = data
+
+      parsed_page
+    end
+
+    private
+
+    # Is the item backed by a physical file in the filesystem?
+    # @return[Boolean]
+    def file?
+      !!realpath
+    end
+
+    def parse_page_filename(filename)
+      data = *filename.match(DateMatcher)
+      data = *filename.match(Matcher) if data.empty?
+      return {} if data.empty?
+
+      if filename =~ DateMatcher
+        {
+          "path" => data[1],
+          "date" => data[2],
+          "slug" => data[3],
+          "title" => to_title(data[3]),
+          "extension" => data[4]
+        }
+      else
+        {
+          "path" => data[1],
+          "slug" => data[2],
+          "title" => to_title(data[2]),
+          "extension" => data[3]
+        }
+      end
+    end
+
+    # my-post-title ===> My Post Title
+    def to_title(file_slug)
+      if file_slug == 'index' && !id.index('/').nil?
+        file_slug = id.split('/')[-2]
+      end
+
+      file_slug
+    end
+  end
+end

data/lib/silly/parse.rb

@@ -0,0 +1,88 @@
+module Silly
+  module Parse
+    TopYAMLregex = /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+    TopJSONregex = /^({\s*\n.*?\n?)^(}\s*$\n?)/m
+
+    # Primary method to parse the file as a page-like object.
+    # File API is currently defines:
+    #   1. Top meta-data
+    #   2. Page Body
+    #
+    # @returns[Hash Object] processed top meta-data, raw (unconverted) content body
+    def self.page_file(filepath)
+      result = {}
+      front_matter = nil
+      format = nil
+      page = File.open(filepath, 'r:UTF-8') { |f| f.read }
+      first_line = page.lines.first.to_s
+
+      begin
+        if (first_line.strip == '---')
+          front_matter = page.match(TopYAMLregex)
+          format = 'yaml'
+       elsif (first_line.strip == '{')
+          front_matter = page.match(TopJSONregex)
+          format = 'json'
+        end
+      rescue => e
+        raise "Error trying to read meta-data from #{ filepath }.
+              It's probably a non text-based file like an image.
+              Please remove it or omit it from your query. Error details: #{ e }"
+      end
+
+      if format == 'yaml'
+        data = yaml_for_pages(front_matter, filepath)
+        result["content"] = page.gsub(TopYAMLregex, '')
+      else
+        data = json_for_pages(front_matter, filepath)
+        result["content"] = page.gsub(TopJSONregex, '')
+      end
+
+      result["data"] = data
+      result
+    end
+
+    def self.data_file(*args)
+      filepath = File.__send__(:join, args)
+      if File.extname(filepath).to_s.empty?
+        path = nil
+        ["#{ filepath }.json", "#{ filepath }.yml", "#{ filepath }.yaml"].each do |result|
+          filepath = path = result and break if File.exist?(result)
+        end
+
+        return nil unless path
+      end
+
+      file = File.open(filepath, 'r:UTF-8') { |f| f.read }
+
+      File.extname(filepath) == ".json" ? json(file) : yaml(file)
+    end
+
+    def self.yaml(file)
+      YAML.load(file) || {}
+    rescue Psych::SyntaxError => e
+      raise("ERROR in #{filepath}: #{e.message}")
+      nil
+    end
+
+    def self.json(file)
+      JSON.load(file) || {}
+    end
+
+    def self.yaml_for_pages(front_matter, filepath)
+      return {} unless front_matter
+      YAML.load(front_matter[0].gsub(/---\n/, "")) || {}
+    rescue Psych::SyntaxError => e
+      raise("Psych::SyntaxError while parsing top YAML Metadata in #{ filepath }\n" +
+        "#{ e.message }\n" +
+        "Try validating the YAML metadata using http://yamllint.com"
+      )
+      nil
+    end
+
+    def self.json_for_pages(front_matter, filepath)
+      return {} unless front_matter
+      JSON.load(front_matter[0]) || {}
+    end
+  end
+end

data/lib/silly/query_operators.rb

@@ -0,0 +1,47 @@
+module Silly
+  module QueryOperators
+    def self.execute(attribute, value)
+      if value.is_a?(Hash)
+        type, value = value.to_a.first
+      else
+        type = "$equals"
+        value = value.is_a?(Symbol) ? value.to_s : value
+      end
+
+      command = type[1, type.size]
+
+      __send__(command, attribute, value)
+    end
+
+    def self.exists(attribute, value)
+      !!attribute == !!value
+    end
+
+    def self.equals(attribute, value)
+      case attribute
+      when Array
+        attribute.include?(value)
+      else
+        attribute == value
+      end
+    end
+
+    def self.ne(attribute, value)
+      case attribute
+      when Array
+        !attribute.include?(value)
+      else
+        attribute != value
+      end
+    end
+
+    def self.exclude(attribute, value)
+      case attribute
+      when Array
+        attribute.each{ |a| return false if (a =~ value) }
+      else
+        !(attribute =~ value)
+      end
+    end
+  end
+end

data/lib/silly/utils.rb

@@ -0,0 +1,22 @@
+module Silly
+  module Utils
+    # Merges hash with another hash, recursively.
+    #
+    # Adapted from Jekyll which got it from some gem whose link is now broken.
+    # Thanks to whoever made it.
+    def self.deep_merge(hash1, hash2)
+      target = hash1.dup
+
+      hash2.keys.each do |key|
+        if hash2[key].is_a?(Hash) && hash1[key].is_a?(Hash)
+          target[key] = deep_merge(target[key], hash2[key])
+          next
+        end
+
+        target[key] = hash2[key]
+      end
+
+      target
+    end
+  end
+end

data/lib/silly/version.rb

@@ -0,0 +1,3 @@
+module Silly
+  Version = VERSION = '0.0.1'
+end

data/silly.gemspec

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift 'lib'
+require 'silly/version'
+
+Gem::Specification.new do |s|
+  s.name              = "silly"
+  s.version           = Silly::Version
+  s.date              = Time.now.strftime('%Y-%m-%d')
+  s.license           = "http://www.opensource.org/licenses/MIT"
+  s.summary           = 'Silly is a filesystem based Object Document Mapper.'
+  s.homepage          = "http://github.com/ruhoh/silly"
+  s.email             = "plusjade@gmail.com"
+  s.authors           = ['Jade Dominguez']
+  s.description       = 'Silly is an ODM for parsing and querying a directory like you would a database -- useful for static websites.'
+
+
+  s.add_development_dependency 'cucumber'
+  s.add_development_dependency 'capybara'
+  s.add_development_dependency 'rspec'
+
+  s.files = `git ls-files`.
+              split("\n").
+              sort.
+              reject { |file| file =~ /^(\.|rdoc|pkg|coverage)/ }
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: silly
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jade Dominguez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Silly is an ODM for parsing and querying a directory like you would a
+  database -- useful for static websites.
+email: plusjade@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- features/cascade.feature
+- features/data_file.feature
+- features/path.feature
+- features/sort.feature
+- features/step_defs.rb
+- features/support/env.rb
+- features/support/helpers.rb
+- features/where.feature
+- features/where_file.feature
+- lib/silly.rb
+- lib/silly/base_model.rb
+- lib/silly/collection.rb
+- lib/silly/data_model.rb
+- lib/silly/item.rb
+- lib/silly/page_model.rb
+- lib/silly/parse.rb
+- lib/silly/query_operators.rb
+- lib/silly/utils.rb
+- lib/silly/version.rb
+- silly.gemspec
+homepage: http://github.com/ruhoh/silly
+licenses:
+- http://www.opensource.org/licenses/MIT
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Silly is a filesystem based Object Document Mapper.
+test_files: []