jadof 0.1.0

data/lib/jadof/page.rb

@@ -0,0 +1,250 @@
+module JADOF #:nodoc:
+
+  # This is the class interface for {Page}.
+  #
+  # This is split out into a separate module so we can 
+  # extend other classes (that inherit from Page) with 
+  # this.
+  #
+  # Actually, if you inherit from Page, you automatically 
+  # get this module extended into your class.
+  module PageAPI
+
+    # @return [String] The root directory that pages are loaded from.  Defaults to "./pages/"
+    attr_accessor :dir
+
+    attr_accessor :formatters
+
+    # This can be set to a standard cache object and, if it is set, 
+    # all pages will be cached so they don't have to be re-opened 
+    # and we don't have to look for the files.
+    #
+    # Any cache object that supports these standard methods is supported:
+    #   
+    #   get(key)
+    #   set(key, value)
+    #   clear
+    #
+    # @return [#get, #set, #clear]
+    attr_accessor :cache
+
+    def dir
+      @dir ||= File.expand_path DEFAULT_DIR
+    end
+
+    # When dir is set, we save it as an expanded path.
+    # We also clear the cache (if it's enabled)
+    def dir= value
+      cache.clear if cache
+      @dir = File.expand_path value
+    end
+
+    # A Hash of available formatters.  The key is used to match 
+    # a given file extension and the value should be something 
+    # that you can #call (like a lambda) with text which returns 
+    # the formatted text.
+    # @return [Hash{String => #call}]
+    def formatters
+      @formatters ||= DEFAULT_FORMATTERS
+    end
+
+    # @return [Page] Get a Page by name
+    def get name
+      first :full_name => name.to_s
+    end
+
+    # @return [Page] Alias for Page.get
+    def [] name
+      get name
+    end
+
+    # @return [Array(Page)] Get all Pages in Page.dir
+    def all
+      cache_for 'all' do
+        Dir[ File.join(dir, "**/*") ].reject {|path| File.directory?(path) }.map {|path| from_path(path) }
+      end
+    end
+
+    # @return [Fixnum] Returns the count of all Pages
+    def count
+      all.length
+    end
+
+    # @return [Page, nil] Returns the last Page
+    def last
+      all.last
+    end
+
+    # @return [Array(Page)] Gets pages given some simple conditions (only == equality is supported)
+    def where conditions
+      all.select { |page| matches_conditions? page, conditions }
+    end
+
+    # @return [Page, nil] Gets a page given some simple conditions
+    def first conditions = nil
+      if conditions
+        all.find { |page| matches_conditions? page, conditions }
+      else
+        all.first
+      end
+    end
+
+    # @return [Page] Loads a Page from a given path to a file
+    def from_path path
+      path      = File.expand_path path
+      filename  = File.basename path
+      name      = filename[/^[^\.]+/] # get everything before a .
+      body      = File.read path
+
+      # Remove YAML from top of body and get the YAML variables from it.
+      # Then we can merge in the name, path, etc, and use it to inialize a page
+      body.sub! /^---(.*)\n---\n/m, ''
+      variables = $1 ? YAML.load($1) : {}
+      variables.merge! :name => name, :path => path, :filename => filename, :body => body
+
+      # If the file is in a subdirectory, get the name of the subdirectory[ies] 
+      # and set it as :parent, so it's easily accessible from the Page.
+      # Also, we strip the first and last '/' characters off of it.
+      variables[:parent] = File.dirname(path).sub(dir, '').sub(/^\//, '')
+
+      new variables
+    end
+
+    # @return [String] Using the #filename of the page given and available 
+    # Page.formatters, we render and return the page #body.
+    def to_html page
+      html = page.body
+
+      page.filename.scan(/\.([^\.]+)/).reverse.each do |match| # [ ["markdown"], ["erb"] ]
+        if formatter = formatters[ match.first ]
+          html = formatter.call(html)
+        end
+      end
+
+      html
+    end
+
+    # @private
+    # Helper for caching.  Will check to see if the {Page.cache} 
+    # contains the given key and, if not, it will set the cache by calling
+    # the block given
+    def cache_for key, &block
+      return block.call unless cache
+
+      from_cache = cache.get(key)
+      unless from_cache
+        from_cache = block.call
+        cache.set(key, from_cache)
+      end
+      from_cache
+    end
+
+    # @private 
+    # @return [true, false] Helper for #where and #first
+    def matches_conditions? page, conditions
+      matches = true
+      conditions.each {|k,v| matches = false unless page.send(k) == v }
+      matches
+    end
+
+    # @private
+    # When a class inheritcs from Page (or from any class that inherits page), 
+    # we extend that class with {PageAPI} so it will get methods like `Page.all`.
+    def inherited base
+      base.extend PageAPI
+    end
+  end
+
+  # A {Page} wraps a file on the filesystem.
+  #
+  # If you set `Page.dir` to a directory, `Page.all` will 
+  # give you all of the files inside that directory as {Page} 
+  # objects.
+  #
+  # For all of the available class methods, see {PageAPI}.
+  #
+  class Page
+    extend  PageAPI
+    include IndifferentVariableHash
+
+    DEFAULT_DIR = './pages/'
+
+    DEFAULT_FORMATTERS = {
+      'markdown' => lambda { |text| require 'maruku'; Maruku.new(text).to_html },
+      'erb'      => lambda { |text| require 'erb';    ERB.new(text).result     }
+    }
+
+    # @return [String] A simple name for this {Page}.
+    #
+    # If the filename is `foo.markdown`, the name will be `foo`
+    # 
+    # If the file is in a subdirectory below `Page.dir`, eg. 
+    # `foo/bar.markdown`, the name will be `bar` but the 
+    # #full_name will be `foo/bar`.
+    attr_accessor :name
+
+    # @return [String] The full system path to this file
+    attr_accessor :path
+
+    # @return [String] The filename (without a directory), eg. `foo.markdown`
+    attr_accessor :filename
+
+    # @return [String] The body of the file, *without* the YAML at 
+    # the top of the file (if YAML was included).
+    #
+    # We strip out the YAML and use it to set variables on 
+    # the Page.  If you need the *full* text from the file, 
+    # you should `File.read(@page.path)`.
+    attr_accessor :body
+
+    # @return [String] The parent directory of this file, if this file is 
+    # in a subdirectory below `Page.dir`.  This will be `""` if 
+    # it is in `Page.dir` or it will be `"sub/directories"` if
+    # it is in subdirectories.
+    attr_accessor :parent
+
+    # A page is a dumb object and doesn't know how to load itself from 
+    # a file on the filesystem.  See `Page.from_path` to load a {Page} 
+    # from a file.
+    #
+    # @param [Hash] of attributes
+    def initialize options = nil
+      options.each {|attribute, value| send "#{attribute}=", value } if options
+    end
+
+    # @return [String] combines {#name} with {#parent}
+    def full_name
+      parent == '' ? name : File.join(parent, name)
+    end
+
+    # Returns the formatted {#body} of this {Page} using `Page.formatters`.
+    #
+    # The file extensions from the {#filename} are used to match formatters.
+    #
+    # For `foo.markdown`, `Page.formatters['markdown']` will be used.
+    # For `foo.markdown.erb`, `Page.formatters['erb']` and `Page.formatters['markdown']` will be used.
+    #
+    # With multiple extensions, the *last* extension is used first, and then the second-to-last, etc.
+    def to_html
+      self.class.to_html self
+    end
+
+    # @return [true, false] If 2 pages have the same system path, they're the same.
+    def == other_page
+      return false unless other_page.is_a? Page
+      return other_page.path == path
+    end
+
+    # @return [String] This page as a string.  Defaults to {#full_name}.
+    def to_s
+      full_name
+    end
+
+    # @return [String] A param representation of this page for us in web applications.  Defaults to {#full_name}.
+    def to_param
+      full_name
+    end
+
+  end
+
+end

data/lib/jadof/post.rb

@@ -0,0 +1,26 @@
+require 'time'
+
+module JADOF #:nodoc:
+
+  # Represents a blog post.  Has the same functionality as {Page} 
+  # but with a {#date} added (which makes {#to_param}) include 
+  # a date, in the conventional way: `2010/01/31/name-of-post`
+  class Post < Page
+
+    # @return [Time] the date that this post was created.
+    # If a [String] is passed in, it will be parsed as a time.
+    attr_accessor :date
+
+    def date= value
+      @date = Time.parse value.to_s
+    end
+
+    # @return [String] The conventional way to display blog 
+    # post urls, eg. `2010/01/31/name-of-post`
+    def to_param
+      date ? "#{ date.strftime('%Y/%m/%d') }/#{ full_name }" : super
+    end
+
+  end
+
+end

data/lib/jadof/spec/examples_for_page.rb

@@ -0,0 +1,324 @@
+shared_examples_for "JADOF Page" do
+
+  describe ':: Behaves like JADOF Page' do
+
+    before do
+      @jadof_page_class ||= JADOF::Page # override this in your specs to test a different class!
+
+      @root_page_directory ||= './jadof_spec_pages/'
+      @jadof_page_class.dir = File.join(@root_page_directory, 'pages')
+      delete_root_page_directory
+    end
+
+    after :all do
+      delete_root_page_directory
+    end
+
+    it '#create_page works as expected for creating fake pages for these specs' do
+      path = File.join(@jadof_page_class.dir, '/foo.markdown')
+      File.file?(path).should be_false
+
+      create_page 'foo.markdown'
+
+      File.file?(path).should be_true
+      @jadof_page_class[:foo].body.should == ''
+
+      create_page 'foo.markdown', %{
+        it should fix
+          the spaces
+        for me
+      }
+
+      @jadof_page_class[:foo].body.should == "it should fix\n  the spaces\nfor me"
+    end
+
+    it 'can set the @jadof_page_class.dir to specify the directory to fetch pages from' do
+      dir1, dir2 = @jadof_page_class.dir, File.join(@root_page_directory, '/more_pages')
+
+      create_page 'foo.markdown', 'hello world', dir1
+      create_page 'bar.markdown', 'hello world', dir2
+
+      @jadof_page_class[:foo].should_not be_nil
+      @jadof_page_class[:bar].should     be_nil
+
+      @jadof_page_class.dir = dir2
+
+      @jadof_page_class[:foo].should     be_nil
+      @jadof_page_class[:bar].should_not be_nil
+    end
+
+    it 'has a filename (the actual filename, without a path)' do
+      create_page 'foo.markdown'
+
+      @jadof_page_class[:foo].should_not be_nil
+      @jadof_page_class[:foo].filename.should == 'foo.markdown'
+    end
+
+    it 'has a path (the full system path to the file)' do
+      create_page 'foo.markdown'
+
+      @jadof_page_class[:foo].should_not be_nil
+      @jadof_page_class[:foo].path.should == File.expand_path(File.join(@jadof_page_class.dir, '/foo.markdown'))
+    end
+
+    it 'has a name (the name of the file, without extensions)' do
+      create_page 'foo.markdown'
+
+      @jadof_page_class[:foo].should_not be_nil
+      @jadof_page_class[:foo].name.should == 'foo'
+    end
+
+    it 'has a body (the content of the file)' do
+      create_page 'foo.markdown'
+      @jadof_page_class[:foo].body.should == ''
+
+      create_page 'foo.markdown', %{
+        Hello World!
+      }
+
+      @jadof_page_class[:foo].body.strip.should == 'Hello World!'
+    end
+
+    it 'can return all pages' do
+      @jadof_page_class.count.should      == 0
+      @jadof_page_class.all.length.should == 0
+
+      create_page 'foo.markdown'
+      
+      @jadof_page_class.count.should      == 1
+      @jadof_page_class.all.length.should == 1
+    end
+
+    it 'can return #first and #last page' do
+      create_page 'foo.markdown'
+      create_page 'bar.markdown'
+      
+      @jadof_page_class.first.should == @jadof_page_class.all.first
+      @jadof_page_class.last.should  == @jadof_page_class.all.last
+
+      @jadof_page_class.first.should_not == @jadof_page_class.last
+    end
+
+    it 'can get a page by name' do
+      @jadof_page_class.get(:foo).should be_nil
+      @jadof_page_class[:foo].should     be_nil
+
+      create_page 'foo.markdown'
+
+      @jadof_page_class.get(:foo).should_not be_nil
+      @jadof_page_class[:foo].should_not     be_nil
+    end
+
+    it 'supports 1 level of sub-directories' do
+      create_page 'hi.markdown'
+      @jadof_page_class['hi'].parent.should == ''
+
+      create_page 'foo/bar.markdown'
+
+      @jadof_page_class['foo/bar'].name.should      == 'bar'
+      @jadof_page_class['foo/bar'].full_name.should == 'foo/bar'
+      @jadof_page_class['foo/bar'].parent.should    == 'foo'
+      @jadof_page_class['foo/bar'].filename.should  == 'bar.markdown'
+      @jadof_page_class['foo/bar'].path.should include('foo/bar.markdown')
+      
+      @jadof_page_class.first(:name => 'bar').name.should     == 'bar'
+      @jadof_page_class.first(:name => 'bar').filename.should == 'bar.markdown'
+      @jadof_page_class.first(:name => 'bar').path.should include('foo/bar.markdown')
+    end
+
+    it 'supports n levels of sub-directories' do
+      create_page 'foo/bar/hello/there/crazy/person-123.markdown'
+
+      @jadof_page_class['foo/bar/hello/there/crazy/person-123'].name.should      == 'person-123'
+      @jadof_page_class['foo/bar/hello/there/crazy/person-123'].full_name.should == 'foo/bar/hello/there/crazy/person-123'
+      @jadof_page_class['foo/bar/hello/there/crazy/person-123'].parent.should    == 'foo/bar/hello/there/crazy'
+      @jadof_page_class['foo/bar/hello/there/crazy/person-123'].filename.should  == 'person-123.markdown'
+      @jadof_page_class['foo/bar/hello/there/crazy/person-123'].path.should include('/crazy/person-123.markdown')
+      
+      @jadof_page_class.first(:name => 'person-123').name.should     == 'person-123'
+      @jadof_page_class.first(:name => 'person-123').filename.should == 'person-123.markdown'
+      @jadof_page_class.first(:name => 'person-123').path.should include('/crazy/person-123.markdown')
+    end
+
+    it 'implements #to_s (defaults to #full_name)' do
+      create_page 'hi.markdown'
+      create_page 'foo/bar/hello/there/crazy/person-123.markdown'
+      
+      @jadof_page_class[:hi].to_s.should == 'hi'
+      @jadof_page_class.first(:name => 'person-123').to_s.should == 'foo/bar/hello/there/crazy/person-123'
+    end
+
+    it 'implements #to_param (defaults to #full_name)' do
+      create_page 'hi.markdown'
+      create_page 'foo/bar/hello/there/crazy/person-123.markdown'
+
+      @jadof_page_class[:hi].to_param.should == 'hi'
+      @jadof_page_class.first(:name => 'person-123').to_param.should == 'foo/bar/hello/there/crazy/person-123'
+    end
+
+    describe ':: YAML header' do
+
+      it 'can add any kind of arbitrary data to a page via YAML' do
+        create_page 'foo.markdown'
+        @jadof_page_class[:foo].foo.should be_nil # @jadof_page_class's don't raise NoMethodError's
+
+        create_page 'foo.markdown', %{
+          ---
+          foo: bar
+          ---
+          Hello World!
+        }
+
+        @jadof_page_class[:foo].foo.should == 'bar' # got value from YAML
+      end
+
+      it 'can get a page by the value of any arbitrary data (from the YAML)' do
+        create_page 'foo.markdown', %{
+          ---
+          foo: bar
+          ---
+          Hello World!
+        }
+
+        @jadof_page_class.first(:foo => 'not bar').should     be_nil
+        @jadof_page_class.first(:foo => 'bar'    ).should_not be_nil
+        @jadof_page_class.first(:foo => 'bar'    ).foo.should == 'bar'
+      end
+
+      it 'can get a page by *multiple* arbitrary conditions' do
+        create_page 'foo.markdown', %{
+          ---
+          foo: bar
+          ---
+          Hello World!
+        }
+
+        @jadof_page_class.where(:foo => 'bar', :name => 'not foo').should be_empty
+        @jadof_page_class.where(:foo => 'not bar', :name => 'foo').should be_empty
+        @jadof_page_class.where(:foo => 'bar', :name => 'foo').should_not be_empty
+        @jadof_page_class.where(:foo => 'bar', :name => 'foo').first.name.should == 'foo'
+      end
+
+    end
+
+    describe ':: Rendering' do
+
+      before do
+        @jadof_page_class.formatters = {}
+      end
+
+      it 'should render plain text if formatter not found for file extension' do
+        create_page 'foo.markdown', %{
+          **Hello World!**
+        }
+
+        @jadof_page_class[:foo].to_html.should == '**Hello World!**'
+      end
+      
+      it 'should render using formatter if found for file extension' do
+        @jadof_page_class.formatters['markdown'] = lambda {|text| Maruku.new(text).to_html }
+
+        create_page 'foo.markdown', %{
+          **Hello World!**
+        }
+
+        @jadof_page_class[:foo].to_html.should == '<p><strong>Hello World!</strong></p>'
+      end
+
+      it 'should support multiple file extensions, eg. foo.markdown.erb (erb renders first, then markdown)' do
+        @jadof_page_class.formatters['markdown'] = lambda {|text| Maruku.new(text).to_html }
+
+        create_page 'foo.markdown.erb', %{
+          <%= '*' * 2 %>Hello World!<%= '*' * 2 %>
+        }
+
+        @jadof_page_class[:foo].to_html.should == 
+          '<p>&lt;%= &#8217;<em>&#8217;</em> 2 %&gt;Hello World!&lt;%= &#8217;<em>&#8217;</em> 2 %&gt;</p>'
+
+
+        @jadof_page_class.formatters['erb'] = lambda {|text| ERB.new(text).result }
+        @jadof_page_class[:foo].to_html.should == '<p><strong>Hello World!</strong></p>'
+      end
+
+      it 'should have markdown and erb out of the box' do
+        create_page 'foo.markdown.erb', %{
+          <%= '*' * 2 %>Hello World!<%= '*' * 2 %>
+        }
+
+        @jadof_page_class.formatters = @jadof_page_class::DEFAULT_FORMATTERS
+        @jadof_page_class[:foo].to_html.should == '<p><strong>Hello World!</strong></p>'
+      end
+
+    end
+
+    describe ':: Caching' do
+
+      before do
+        @jadof_page_class.cache = Hash::Cache.new # Hash that has #get(k) and #set(k,v) methods and #clear
+      end
+
+      it 'with the cache enabled, files should only be #read once' do
+        create_page 'foo.markdown'
+        path = File.join @jadof_page_class.dir, 'foo.markdown'
+
+        File.should_receive(:read).with(File.expand_path(path)).once.and_return('') # only once!
+
+        @jadof_page_class[:foo]
+        @jadof_page_class[:foo]
+      end
+
+      it 'with the cache enabled, Dir[] should only look for files once' do
+        create_page 'foo.markdown'
+        create_page 'bar.markdown'
+
+        dir = @root_page_directory
+        Dir.should_receive(:[]).once.and_return([File.join(dir, '/pages/bar.markdown'), File.join(dir, '/pages/foo.markdown')])
+        File.should_receive(:read).twice.and_return('')
+
+        @jadof_page_class.all
+        @jadof_page_class.all # calls everyhing again if caching is disabled (@jadof_page_class.cache is nil or false)
+      end
+
+      it 'with the cache disabled, Dir[] should only look for files more than once' do
+        @jadof_page_class.cache = false
+
+        create_page 'foo.markdown'
+        create_page 'bar.markdown'
+
+        dir = @root_page_directory
+        Dir.should_receive(:[]).twice.and_return([File.join(dir, '/pages/bar.markdown'), File.join(dir, '/pages/foo.markdown')])
+        File.should_receive(:read).exactly(4).times.and_return('')
+
+        @jadof_page_class.all
+        @jadof_page_class.all # calls everyhing again if caching is disabled (@jadof_page_class.cache is nil or false)
+      end
+
+      it 'should be able to clear the cache' do
+        @jadof_page_class.cache.get('all').should be_nil
+        @jadof_page_class.all
+        @jadof_page_class.cache.get('all').should_not be_nil
+        
+        @jadof_page_class.cache.clear
+
+        @jadof_page_class.cache.get('all').should be_nil
+        @jadof_page_class.all
+        @jadof_page_class.cache.get('all').should_not be_nil
+      end
+
+      it 'should clear the cache when the @jadof_page_class.dir is changed' do
+        @jadof_page_class.cache.get('all').should be_nil
+        @jadof_page_class.all
+        @jadof_page_class.cache.get('all').should_not be_nil
+        
+        @jadof_page_class.dir = File.join(@root_page_directory, 'different-directory')
+
+        @jadof_page_class.cache.get('all').should be_nil
+        @jadof_page_class.all
+        @jadof_page_class.cache.get('all').should_not be_nil
+      end
+
+    end
+
+  end
+
+end

data/lib/jadof/spec/examples_for_post.rb

@@ -0,0 +1,33 @@
+shared_examples_for "JADOF Post" do
+
+  describe ':: Behaves like JADOF Post' do
+
+    before do
+      @jadof_post_class ||= JADOF::Post # override this in your specs to test a different class!
+
+      @root_page_directory ||= './jadof_spec_pages/'
+      @jadof_post_class.dir = File.join(@root_page_directory, 'posts')
+      delete_root_page_directory
+    end
+
+    after :all do
+      delete_root_page_directory
+    end
+
+    it 'it should have a date (which is used in to_param)' do
+      create_page 'foo.markdown', %{
+        ---
+        date: 01/31/2010
+        ---
+        
+        hello world
+      }, @jadof_post_class.dir
+
+      @jadof_post_class.first.name.should     == 'foo'
+      @jadof_post_class.first.to_s.should     == 'foo'
+      @jadof_post_class.first.to_param.should == '2010/01/31/foo'
+    end
+
+  end
+
+end

data/lib/jadof/spec/helpers.rb

@@ -0,0 +1,34 @@
+# Helper for creating page files in the specs, at spec/pages/
+#
+#   create_page 'foo.markdown'
+#
+#   create_page 'foo.markdown', %{
+#     This is the body
+#     of the page that will
+#     be created.
+#   }
+#
+#   create_page 'foo.markdown', 'body',  './directory/to/create/page/in/'
+#
+def create_page filename, body = '', page_dir = @jadof_page_class.dir
+  body.sub!("\n", '')     if body.lines.first == "\n" # get rid of first empty line
+  body.sub!(/\n\s+$/, '') if body.lines.count > 0     # get rid of last  empty line
+
+  # grab the spaces (if any) from the 1st line and remove that
+  # many spaces from the rest of the lines so our specs look clean
+  if body.lines.first
+    spaces = body.lines.first[/^[ ]+/]
+    body.gsub!(/^#{spaces}/, '') if spaces
+  end
+
+  body ||= '' # if it's nil for some reason, make it an empty string
+
+  path = File.join(page_dir, filename)
+  FileUtils.mkdir_p File.dirname(path)
+  File.open(path, 'w'){|f| f << body }
+end
+
+# Deletes the root directory that we create pages in
+def delete_root_page_directory
+  FileUtils.rm_rf @root_page_directory
+end

data/lib/jadof/spec.rb

@@ -0,0 +1,32 @@
+# If you want to extend JADOF, you'll probably want to 
+# create specs to make sure that your functionality works.
+#
+# You'll probably also want to run the JADOF specs, as 
+# regression tests, so you know if you break any of the 
+# core functionality.
+#
+# For that, we use RSpec shared examples so, in your specs, 
+# you can require 'jadof/test' and then add this to your specs:
+#
+#   it_should_behave_like "JADOF Page"
+#
+# The shared examples use a few instance variables which you 
+# can override.
+#
+# @root_page_directory
+# : the directory to save fake pages in while the 
+#   tests run.  these are cleaned up by the tests.
+#   default: './jadof_spec_pages/'.  we delete this 
+#   directory when running specs do don't use a 
+#   directory with things you care about!
+#
+require 'rubygems'
+require 'spec'
+require 'fileutils'  # for creating/deleting directories for fake pages
+require 'hash-cache' # for testing caching
+require 'maruku'     # for testing rendering
+require 'erb'        # for testing rendering
+require File.dirname(__FILE__) + '/../jadof' unless defined? JADOF
+require File.dirname(__FILE__) + '/spec/helpers'
+require File.dirname(__FILE__) + '/spec/examples_for_page'
+require File.dirname(__FILE__) + '/spec/examples_for_post'

data/lib/jadof.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'indifferent-variable-hash'
+
+# Just A Directory Of Files
+#
+# See {JADOF::Page} and {JADOF::Post}
+#
+module JADOF
+end
+
+require 'jadof/page'
+require 'jadof/post'

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: jadof
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- remi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-10 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: remi@remitaylor.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/jadof/spec/examples_for_post.rb
+- lib/jadof/spec/examples_for_page.rb
+- lib/jadof/spec/helpers.rb
+- lib/jadof/post.rb
+- lib/jadof/spec.rb
+- lib/jadof/page.rb
+- lib/jadof.rb
+has_rdoc: true
+homepage: http://github.com/remi/jadof
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Just A Directory Of Files (JADOF)
+test_files: []
+