document_mapper 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010 Ralph von der Heyden
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,120 @@
+h1. Document Mapper
+
+Document mapper is an object mapper for plain text documents. The documents look like the ones used in "jekyll":http://github.com/mojombo/jekyll, "toto":http://github.com/cloudhead/toto or "Serious":http://github.com/colszowka/serious. They consist of a preambel written in YAML (also called YAML front matter), and some content in the format you prefer, e.g. Textile. This enables you to write documents in your favorite editor and access the content and metadata in your Ruby scripts.
+
+
+h2. Step-by-step tutorial
+
+Documents look somehow like this. The part between the @---@s is the YAML front matter. After the second @---@, there is one blank line, followed by the content of the file. All items in the YAML front matter and the content are accessible by Document Mapper.
+
+<pre><code>---
+id: 1
+title: Ruby is great
+tags: [programming, software]
+number_of_foos: 42
+status: published
+---
+
+I like Ruby.
+</code></pre>
+
+
+In order to access the values in the front matter, you have to create a class that includes @DocumentMapper@. 
+
+<pre><code>require 'document_mapper'
+class MyDocument
+  include DocumentMapper::Document
+end
+</code></pre>
+
+
+h3. Initializing single documents
+
+<pre><code>doc = MyDocument.from_file('./documents/document-file.textile')
+</code></pre>
+
+
+h3. Accessing the attributes of single documents
+
+<pre><code>doc.title                    # => "Ruby is great"
+doc.tags                     # => ["programming", "software"]
+doc.content                  # => "I like Ruby."
+</code></pre>
+
+
+h3. Date recognition
+
+You can either set the date of a document in the YAML front matter, or you can use the file name, if you want to. A file named @2010-08-07-test-document-file.textile@ will return a date like this:
+
+<pre><code>doc.date                     # => #<Date: 2010-08-08 (4910833/2,0,2299161)>
+doc.date.to_s                # => "2010-08-08"
+doc.year                     # => 2010
+doc.month                    # => 08
+doc.day                      # => 07
+</code></pre>
+
+
+h3. Working with directories
+
+As an example let's assume we have a directory called "documents" containing the following files:
+
+<pre><code>documents/
+|-foo.textile
+|-bar.textile
+</code></pre>
+
+
+In order to work with a whole directory of files, we have to use the @directory@ method:
+
+<pre><code>require 'document_mapper'
+class MyDocument
+  include DocumentMapper::Document
+  self.directory = 'documents'
+end
+</code></pre>
+
+Now we can receive all available documents or filter like that:
+
+<pre><code>MyDocument.all
+MyDocument.first
+MyDocument.last
+MyDocument.limit(2)
+MyDocument.offset(2)
+MyDocument.where(:title => 'Some title').first
+MyDocument.where(:status => 'published').all
+MyDocument.where(:year => 2010).all
+</code></pre>
+
+Not all of the documents in the directory need to have all of the attributes. You can add single attributes to single documents, and the queries will only return those documents where the attributes match.
+
+The document queries do support more operators than just equality. The following operators are available:
+
+<pre><code>MyDocument.where(:year.gt => 2010)
+MyDocument.where(:year.gte => 2010)
+MyDocument.where(:year.in => [2010,2011])
+MyDocument.where(:year.lt => 2010)
+MyDocument.where(:year.lte => 2010)
+</code></pre>
+
+
+h3. Chaining
+
+Chaining works with all available query methods, e.g.:
+
+<pre><code>MyDocument.where(:status => 'published').where(:title => 'Some title').limit(2).all
+</code></pre>
+
+
+h3. Reloading
+
+If any of the files change, you must manually reload them:
+
+<pre><code>MyDocument.reload
+</code></pre>
+
+
+h2. Author
+
+Written by "Ralph von der Heyden":http://rvdh.de. Don't hesitate to contact me if you have any further questions.
+
+Follow me on "Twitter":http://twitter.com/ralph!

data/lib/document_mapper.rb

@@ -0,0 +1,14 @@
+require 'active_support/core_ext/class'
+require 'active_support/concern'
+require 'yaml'
+
+require 'document_mapper/constants'
+require 'document_mapper/errors'
+require 'document_mapper/attribute_methods'
+require 'document_mapper/yaml_parsing'
+require 'document_mapper/document'
+require 'document_mapper/query'
+require 'document_mapper/selector'
+require 'document_mapper/version'
+
+require 'document_mapper/core_ext/symbol'

data/lib/document_mapper/attribute_methods.rb

@@ -0,0 +1,25 @@
+module DocumentMapper
+  module AttributeMethods
+    module Read
+      extend ActiveSupport::Concern
+
+      included do
+        # Undefine id so it can be used as an attribute name
+        undef_method(:id) if method_defined?(:id)
+      end
+
+      module ClassMethods
+        def define_read_method(attr_name)
+          access_code = "attributes['#{attr_name}']"
+          generated_attribute_methods.module_eval("def #{attr_name}; #{access_code}; end", __FILE__, __LINE__)
+
+          %w(year month day).each do |attr_name|
+            access_code = "date.#{attr_name} if date"
+            generated_attribute_methods.module_eval("def #{attr_name}; #{access_code}; end", __FILE__, __LINE__)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/document_mapper/constants.rb

@@ -0,0 +1,12 @@
+module DocumentMapper
+  REVERSE_OPERATOR_MAPPING = {
+    'equal' => :==,
+    'gt'    => :<,
+    'gte'   => :<=,
+    'in'    => :include?,
+    'lt'    => :>,
+    'lte'   => :>=
+  }
+
+  VALID_OPERATORS = REVERSE_OPERATOR_MAPPING.keys
+end

data/lib/document_mapper/core_ext/symbol.rb

@@ -0,0 +1,9 @@
+class Symbol
+  DocumentMapper::VALID_OPERATORS.each do |operator|
+    class_eval <<-OPERATORS
+      def #{operator}
+        Selector.new(:attribute => self, :operator => '#{operator}')
+      end
+    OPERATORS
+  end
+end

data/lib/document_mapper/document.rb

@@ -0,0 +1,94 @@
+require 'active_model'
+
+module DocumentMapper
+  module Document
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+    include AttributeMethods::Read
+    include YamlParsing
+
+    attr_accessor :attributes, :content, :directory, :file_path
+
+    included do
+      @@documents = []
+    end
+
+    def ==(other_document)
+      return false unless other_document.is_a? Document
+      self.file_path == other_document.file_path
+    end
+
+    module ClassMethods
+      def reset
+        @@documents = []
+      end
+
+      def reload
+        self.reset
+        self.directory = @@directory
+      end
+
+      def from_file(file_path)
+        if !File.exist? file_path
+          raise FileNotFoundError
+        end
+        self.new.tap do |document|
+          document.file_path = File.expand_path(file_path)
+          document.read_yaml
+          @@documents << document
+        end
+      end
+
+      def directory=(new_directory)
+        raise FileNotFoundError unless File.directory?(new_directory)
+        self.reset
+        @@directory = Dir.new File.expand_path(new_directory)
+        @@directory.each do |file|
+          next if ['.', '..'].include? file
+          self.from_file [@@directory.path, file].join('/')
+        end
+      end
+
+      def select(options = {})
+        documents = @@documents.dup
+        options[:where].each do |selector, selector_value|
+          documents.select! do |document|
+            next unless document.respond_to? selector.attribute
+            document_value = document.send(selector.attribute)
+            operator = REVERSE_OPERATOR_MAPPING[selector.operator]
+            selector_value.send operator, document_value
+          end
+        end
+        documents
+      end
+
+      def where(hash)
+        Query.new(self).where(hash)
+      end
+
+      def sort(field)
+        Query.new(self).sort(field)
+      end
+
+      def offset(number)
+        Query.new(self).offset(number)
+      end
+
+      def limit(number)
+        Query.new(self).limit(number)
+      end
+
+      def all
+        @@documents
+      end
+
+      def first
+        @@documents.first
+      end
+
+      def last
+        @@documents.last
+      end
+    end
+  end
+end

data/lib/document_mapper/errors.rb

@@ -0,0 +1,4 @@
+module DocumentMapper
+  FileNotFoundError = Class.new StandardError
+  OperatorNotSupportedError = Class.new StandardError
+end

data/lib/document_mapper/query.rb

@@ -0,0 +1,54 @@
+module DocumentMapper
+  class Query
+    def initialize(model)
+      @model = model
+      @where = {}
+    end
+
+    def where(constraints_hash)
+      differentiator = ->(key, value){ key.is_a? Selector }
+      selector_hash = constraints_hash.select &differentiator
+      symbol_hash = constraints_hash.reject &differentiator
+      symbol_hash.each do |attribute, value|
+        selector = Selector.new(:attribute => attribute, :operator => 'equal')
+        selector_hash.update({ selector => value })
+      end
+      @where.merge! selector_hash
+      self
+    end
+
+    def sort(field)
+      @sort = field
+      self
+    end
+
+    def offset(number)
+      @offset = number
+      self
+    end
+
+    def limit(number)
+      @limit = number
+      self
+    end
+
+    def first
+      self.all.first
+    end
+
+    def last
+      self.all.last
+    end
+
+    def all
+      result = @model.select(:where => @where, :sort => @sort)
+      if @offset.present?
+        result = result.last(result.size - @offset)
+      end
+      if @limit.present?
+        result = result.first(@limit)
+      end
+      result
+    end
+  end
+end

data/lib/document_mapper/selector.rb

@@ -0,0 +1,12 @@
+module DocumentMapper
+  class Selector
+    attr_reader :attribute, :operator
+
+    def initialize(opts = {})
+      unless VALID_OPERATORS.include? opts[:operator]
+        raise OperatorNotSupportedError
+      end
+      @attribute, @operator = opts[:attribute], opts[:operator]
+    end
+  end
+end

data/lib/document_mapper/version.rb

@@ -0,0 +1,3 @@
+module DocumentMapper
+  VERSION = '0.1.0'
+end

data/lib/document_mapper/yaml_parsing.rb

@@ -0,0 +1,24 @@
+module DocumentMapper
+  module YamlParsing
+    def read_yaml
+      @content = File.read(file_path)
+
+      if @content =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+        @content = @content[($1.size + $2.size)..-1]
+        self.attributes = YAML.load($1)
+      end
+
+      self.attributes ||= {}
+      if !self.attributes.has_key? 'date'
+        begin
+          match = File.basename(@file_path).match(/(\d{4})-(\d{1,2})-(\d{1,2}).*/)
+          self.attributes['date'] = Date.new(match[1].to_i, match[2].to_i, match[3].to_i)
+        rescue NoMethodError => err
+        end
+      end
+
+      self.class.define_attribute_methods self.attributes.keys
+      self.attributes.keys.each { |attr| self.class.define_read_method attr }
+    end
+  end
+end

data/test/document_mapper/core_ext/symbol_test.rb

@@ -0,0 +1,29 @@
+require File.join(File.expand_path(__FILE__), '..', '..', '..', 'test_base')
+include DocumentMapper
+
+describe Symbol do
+  it 'should create a selector from a valid operator' do
+    selector = :my_attribute.gte
+    assert_equal 'gte', selector.operator
+    assert_equal :my_attribute, selector.attribute
+  end
+
+  it 'should not raise an error on valid operators' do
+    begin
+      :my_attribute.equal
+      :my_attribute.gt
+      :my_attribute.gte
+      :my_attribute.in
+      :my_attribute.lt
+      :my_attribute.lte
+    rescue StandardError => e
+      assert false, 'Calling operator on symbol raised error'
+    end
+  end
+
+  it 'should raise an error on invalid operators' do
+    assert_raises NoMethodError do
+      :my_attribute.not_supported
+    end
+  end
+end

data/test/document_mapper/document_mapper_test.rb

@@ -0,0 +1,253 @@
+require File.join(File.expand_path(__FILE__), '..', '..', 'test_base')
+include DocumentMapper
+
+describe MyDocument do
+  before do
+    MyDocument.reset
+  end
+
+  describe 'loading a document from file' do
+    before do
+      @file_path = sample_file_path_1
+      @document = MyDocument.from_file(@file_path)
+    end
+
+    it 'should load the document from a yaml file' do
+      assert_equal 1, @document.attributes['id']
+      assert_equal 'Some fancy title', @document.attributes['title']
+      assert_equal ['ruby'], @document.attributes['tags']
+      assert_equal :published, @document.attributes['status']
+    end
+
+    it 'should specify attributes from the YAML header' do
+      assert_equal 1, @document.id
+      assert_equal 'Some fancy title', @document.title
+      assert_equal ['ruby'], @document.tags
+      assert_equal :published, @document.status
+      assert_equal File.expand_path(@file_path), @document.file_path
+    end
+
+    describe 'specifying the date of the document' do
+      it 'should get the date from the filename' do
+        assert_equal '2010-08-08', @document.date.to_s
+        assert_equal 2010, @document.date.year
+        assert_equal 8, @document.date.month
+        assert_equal 8, @document.date.day
+      end
+
+      it 'should delegate the day method to date' do
+        assert_equal 2010, @document.year
+        assert_equal 8, @document.month
+        assert_equal 8, @document.day
+      end
+
+      it 'should get the date from the yaml front matter if there is one' do
+        @document = sample_document_with_date_in_yaml
+        assert_equal 2011, @document.year
+        assert_equal 4, @document.month
+        assert_equal 5, @document.day
+      end
+
+      it 'should not freak out if there is no date' do
+        @document = sample_document_without_date
+        assert_equal nil, @document.date
+        assert_equal nil, @document.year
+        assert_equal nil, @document.month
+        assert_equal nil, @document.day
+      end
+    end
+
+    describe 'loading a documents directory' do
+      it 'should load all the documents in that directory' do
+        MyDocument.directory = 'test/documents'
+        assert_equal [1,2,3,4], MyDocument.all.map(&:id)
+      end
+    end
+  end
+
+  describe 'getting all/the first/the last MyDocument(s)' do
+    before do
+      @all_documents = [sample_document_1, sample_document_2]
+    end
+
+    it 'should return all documents' do
+      assert_equal @all_documents, MyDocument.all
+    end
+
+    it 'should return the first document' do
+      assert_equal @all_documents.first, MyDocument.first
+    end
+
+    it 'should return the last document' do
+      assert_equal @all_documents.last, MyDocument.last
+    end
+  end
+
+  describe 'using offset and limit' do
+    before do
+      MyDocument.directory = 'test/documents'
+    end
+
+    it 'should limit the documents to the number specified' do
+      assert_equal [1,2], MyDocument.limit(2).all.map(&:id)
+    end
+
+    it 'should offset the documents by the number specified' do
+      assert_equal [3,4], MyDocument.offset(2).all.map(&:id)
+    end
+
+    it 'should support offset and limit at the same time' do
+      assert_equal [2,3], MyDocument.offset(1).limit(2).all.map(&:id)
+    end
+  end
+
+  describe 'resetting the MyDocument class' do
+    it 'should clear all documents' do
+      one_document = sample_document_1
+      assert_equal [one_document], MyDocument.all
+      MyDocument.reset
+      assert_equal [], MyDocument.all
+    end
+  end
+
+  describe 'using where queries' do
+    before do
+      @document_1 = sample_document_1
+      @document_2 = sample_document_2
+      MyDocument.directory = 'test/documents'
+    end
+
+    describe 'with an equal operator' do
+      it 'should return the right documents' do
+        found_document = MyDocument.where(:title => @document_1.title).first
+        assert_equal @document_1, found_document
+        found_document = MyDocument.where(:title => @document_2.title).first
+        assert_equal @document_2, found_document
+      end
+
+      it 'should be chainable' do
+        document_proxy = MyDocument.where(:title => @document_1.title)
+        document_proxy.where(:id => @document_1.id)
+        assert_equal @document_1, document_proxy.first
+      end
+
+      it 'should work with dates' do
+        found_documents = MyDocument.where(:year => 2010).all
+        expected_documents = [sample_document_1, sample_document_2]
+        assert_equal expected_documents.map(&:id), found_documents.map(&:id)
+      end
+
+      it 'should not be confused by attributes not present in all documents' do
+        MyDocument.directory = 'test/documents'
+        result = MyDocument.where(:seldom_attribute => 'is seldom').all
+        assert_equal [4], result.map(&:id)
+      end
+    end
+
+    describe 'with a gt operator' do
+      it 'should return the right documents' do
+        selector = Selector.new :attribute => 'id', :operator => 'gt'
+        found_documents = MyDocument.where(selector => 2).all
+        assert_equal [3,4], found_documents.map(&:id)
+      end
+    end
+
+    describe 'with a gte operator' do
+      it 'should return the right documents' do
+        selector = Selector.new :attribute => 'id', :operator => 'gte'
+        found_documents = MyDocument.where(selector => 2).all
+        assert_equal [2,3,4], found_documents.map(&:id)
+      end
+    end
+
+    describe 'with an in operator' do
+      it 'should return the right documents' do
+        selector = Selector.new :attribute => 'id', :operator => 'in'
+        found_documents = MyDocument.where(selector => [2,3]).all
+        assert_equal [2,3], found_documents.map(&:id)
+      end
+    end
+
+    describe 'with an lt operator' do
+      it 'should return the right documents' do
+        selector = Selector.new :attribute => 'id', :operator => 'lt'
+        found_documents = MyDocument.where(selector => 2).all
+        assert_equal [1], found_documents.map(&:id)
+      end
+    end
+
+    describe 'with an lte operator' do
+      it 'should return the right documents' do
+        selector = Selector.new :attribute => 'id', :operator => 'lte'
+        found_documents = MyDocument.where(selector => 2).all
+        assert_equal [1,2], found_documents.map(&:id)
+      end
+    end
+
+    describe 'with mixed operators' do
+      it 'should return the right documents' do
+        in_selector = Selector.new :attribute => 'id', :operator => 'in'
+        gt_selector = Selector.new :attribute => 'id', :operator => 'gt'
+        documents_proxy = MyDocument.where(in_selector => [2,3])
+        found_documents = documents_proxy.where(gt_selector => 2).all
+        assert_equal [3], found_documents.map(&:id)
+      end
+    end
+
+    describe 'using multiple constrains in one where' do
+      it 'should return the right documents' do
+        selector = Selector.new :attribute => 'id', :operator => 'lte'
+        found_documents = MyDocument.where(selector => 2, :status => :published).all
+        assert_equal [1,2], found_documents.map(&:id)
+      end
+    end
+  end
+
+  describe 'reloading the Document class' do
+    it 'should discover new documents' do
+      @file_path = 'test/documents/2011-04-26-new-stuff.textile'
+      File.open(@file_path, 'w') do |f|
+        f.write <<-EOS
+---
+id: 5
+title: Some brand new document
+---
+
+Very new stuff.
+EOS
+      end
+      MyDocument.reload
+      assert_equal [1,2,3,4,5].sort, MyDocument.all.map(&:id).sort
+    end
+
+    def teardown
+      File.delete @file_path
+    end
+  end
+
+  def sample_file_path_1
+    'test/documents/2010-08-08-test-document-file.textile'
+  end
+
+  def sample_file_path_2
+    'test/documents/2010-08-09-another-test-document.textile'
+  end
+
+  def sample_document_1
+    MyDocument.from_file(sample_file_path_1)
+  end
+
+  def sample_document_2
+    MyDocument.from_file(sample_file_path_2)
+  end
+
+  def sample_document_with_date_in_yaml
+    file_path = 'test/documents/document_with_date_in_yaml.textile'
+    MyDocument.from_file(file_path)
+  end
+
+  def sample_document_without_date
+    file_path = 'test/documents/document_without_date.textile'
+    MyDocument.from_file(file_path)
+  end
+end

data/test/document_mapper/selector_test.rb

@@ -0,0 +1,16 @@
+require File.join(File.expand_path(__FILE__), '..', '..', 'test_base')
+include DocumentMapper
+
+describe Selector do
+  it 'should initialize with an attribute and an operator' do
+    selector = Selector.new :attribute => 'author', :operator => 'equal'
+    assert_equal 'author', selector.attribute
+    assert_equal 'equal', selector.operator
+  end
+
+  it 'should raise an exception if the operator is not supported' do
+    assert_raises OperatorNotSupportedError do
+      selector = Selector.new :attribute => 'author', :operator => 'zomg'
+    end
+  end
+end

data/test/documents/2010-08-08-test-document-file.textile

@@ -0,0 +1,8 @@
+---
+id: 1
+title: Some fancy title
+tags: [ruby]
+status: :published
+---
+
+I like being the demo text.

data/test/documents/2010-08-09-another-test-document.textile

@@ -0,0 +1,10 @@
+---
+id: 2
+title: Another title, that's for sure
+tags: [ruby, rails]
+special_attribute: Yes!
+friends: [Anton, Paul]
+status: :published
+---
+
+The body copy.

data/test/documents/document_with_date_in_yaml.textile

@@ -0,0 +1,7 @@
+---
+id: 3
+title: Document with date in YAML
+date: 2011-04-05
+---
+
+This document has no date in the filename, but in the YAML front matter.

data/test/documents/document_without_date.textile

@@ -0,0 +1,7 @@
+---
+id: 4
+title: This document has no date
+seldom_attribute: is seldom
+---
+
+This document has no date at all.

data/test/test_base.rb

@@ -0,0 +1,11 @@
+require 'minitest/spec'
+MiniTest::Unit.autorun
+
+lib_dir = File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH.unshift lib_dir unless $LOAD_PATH.include?(lib_dir)
+require 'document_mapper'
+TEST_DIR = File.dirname(__FILE__)
+
+class MyDocument
+  include DocumentMapper::Document
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: document_mapper
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ralph von der Heyden
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-30 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id002
+description: "  DocumentMapper is an object mapper for plain text documents. The documents look like the ones used in jekyll (http://github.com/mojombo/jekyll). They consist of a preambel written in YAML (also called YAML front matter), and some content in the format you prefer, e.g. Textile. This enables you to write documents in your favorite editor and access the content and metadata of these in your Ruby scripts.\n"
+email: ralph@rvdh.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README.textile
+- lib/document_mapper/attribute_methods.rb
+- lib/document_mapper/constants.rb
+- lib/document_mapper/core_ext/symbol.rb
+- lib/document_mapper/document.rb
+- lib/document_mapper/errors.rb
+- lib/document_mapper/query.rb
+- lib/document_mapper/selector.rb
+- lib/document_mapper/version.rb
+- lib/document_mapper/yaml_parsing.rb
+- lib/document_mapper.rb
+- test/document_mapper/core_ext/symbol_test.rb
+- test/document_mapper/document_mapper_test.rb
+- test/document_mapper/selector_test.rb
+- test/documents/2010-08-08-test-document-file.textile
+- test/documents/2010-08-09-another-test-document.textile
+- test/documents/document_with_date_in_yaml.textile
+- test/documents/document_without_date.textile
+- test/test_base.rb
+homepage: http://github.com/ralph/document_mapper
+licenses: []
+
+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.7.2
+signing_key: 
+specification_version: 3
+summary: DocumentMapper is an object mapper for plain text documents.
+test_files: []
+