spandex 0.0.1 → 0.0.2

data/.gitignore

@@ -0,0 +1,12 @@
+.bundle
+db/*.sqlite3
+log/*.log
+tmp/**/*
+*~
+*flymake*
+*#
+#*
+.#*
+bin/**
+.sass-cache/**
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,85 @@
+#Spandex is a simple content engine for Ruby, made chiefly from orangutan fur#
+
+Spandex manages a bucket of text files written in your favorite markup (Markdown, Textile, or even Haml). You mark those files up with metadata (like date and tags), and Spandex gives you access to them. This is perfect for building a simple git-based blog or content site.
+
+Spandex is largely extracted from [Nesta](http://nestacms.com/), a Ruby CMS. The markup is rendered using [Tilt](http://github.com/rtomayko/tilt).
+
+##It's super freaking easy##
+
+Make a directory called "content".
+
+In that directory, create a file called `things.md`:
+
+```
+Title: I have an affinity for goats
+Date: 2011/9/25
+Tags: gerrymandering, hyperbolic geometry
+
+No, really goats are *awesome*.
+```
+
+Then use Spandex to do the work:
+
+```ruby
+spandex = Spandex.new(File.expand_path('content', File.dirname(__FILE__))
+
+page = spandex.get('things') 
+page.title                   #=> "I have an affinity for goats"
+page.tags                    #=> ["gerrymandering", "hyperbolic geometry"]
+page.body                    #=> <p>No, really goats are <em>awesome</em>.</p>\n
+
+spandex.all_pages            #=> all pages under content
+spandex.all_articles         #=> all pages with dates (e.g. blog posts)
+spandex.tags                 #=> ["gerrymandering", "hyperbolic geometry"]
+spandex.atom_feed            #=> a bunch of XML, only finds posts with dates
+
+spandex.find_articles(:tag => "gerrymandering")
+```
+
+The spandex object caches the pages and does all of the right last-mod-time checking. Your application should just keep the object around.
+
+##Build things!##
+
+Blog engines are great, and there are, like, three thousand of them. Sometimes, though, you just want to build a website with the tools you know. Spandex lets you do that while taking care of all the grody work of keeping track of posts. A barebones example of a Spandex-based blog is the [tinyblogofdoom](http://github.com/icambron/tinyblogofdoom).
+
+But wait! There's more! Spandex can also implement the core functionality for a blog engine or CMS. Spandex brings the post rendering and you bring the themes, UI chrome, and plugins.
+
+##Some more cool stuff##
+
+Paths can be deep:
+
+```ruby
+page = spandex.get('subfolder/deeper/things') 
+```
+
+You can pass options through to Tilt at initialization:
+
+```ruby
+spandex = Spandex.new(path, :fenced_code_blocks => true) #special option for Redcarpet
+```
+
+##The content is just Tilt##
+
+The markup is processed using [Tilt](https://github.com/rtomayko/tilt). That means it can read a lot of different markup formats, and gives you access to all of Tilt's configuration options. You can change what extensions get bound to what template engines, and that sort of thing
+
+You can also customize rendering by customizing Tilt. Here's how you might customize Spandex to hightlight code with Pygments:
+
+```ruby
+require 'redcarpet'
+require 'pygments'
+
+class Syntactical < Redcarpet::Render::HTML
+  include Pygments
+  def block_code(code, language)
+    highlight code, :lexer => lexer_name_for(:lexer => language)
+  end
+end
+
+class SyntacticalTemplate < Tilt::RedcarpetTemplate::Redcarpet2
+  def generate_renderer
+    Syntactical
+  end
+end
+
+Tilt::register SyntacticalTemplate, 'some_file_extension'
+```

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+Bundler::GemHelper.install_tasks
+
+task :default => :spec

data/lib/spandex.rb

@@ -0,0 +1,21 @@
+require 'spandex/page'
+require 'spandex/finder'
+
+module Spandex
+  class << self
+
+    def new(base_path, render_options = {})
+      Spandex::Finder.new(base_path, render_options)
+    end
+
+    def method_missing(method, *args, &block)
+      return super unless new.respond_to?(method)
+      new.send(method, *args, &block)
+    end
+
+    def respond_to?(method, include_private = false)
+      new.respond_to?(method, include_private) || super(method, include_private)
+    end
+
+  end
+end

data/lib/spandex/finder.rb

@@ -0,0 +1,92 @@
+require 'pathname'
+require 'atom'
+
+module Spandex
+  class Finder
+
+    class CaseInsensitiveHash < Hash
+      def [](key)
+        super(key.to_s.downcase)
+      end
+    end
+
+    def initialize(base_dir, render_options = {})
+      @base_dir = base_dir
+      @render_options = render_options
+    end
+
+    def get(path)
+      load(Page.file_from_path(path, @base_dir), path)
+    end
+
+    def get_by_filename(filename)
+      load(filename)
+    end
+
+    def all_pages
+      roots = []
+      @pages ||= CaseInsensitiveHash.new
+      Dir.glob(File.join(@base_dir, "**/*"))
+        .map{|path| Pathname.new(path)}
+        .select{|path| Page.registered?(path)}
+        .each{|path| load(path)}
+      @pages.values
+    end
+
+    def all_articles
+      all_pages
+        .select{|page| page.date}
+        .sort {|x, y| y.date <=> x.date }
+    end
+
+    def find_articles(conditions)
+      find_inside(all_articles, conditions)
+    end
+
+    def tags
+      @tags ||= all_pages.map{|p| p.tags}.flatten.uniq
+    end
+
+    def atom_feed(count, author, root, path_to_xml)
+      articles = all_articles.take(count)
+      Atom::Feed.new do |f|
+        f.id = root
+        f.links << Atom::Link.new(:href => "http://#{root}#{path_to_xml}", :rel => "self")
+        f.links << Atom::Link.new(:href => "http://#{root}", :rel => "alternate")
+        f.authors << Atom::Person.new(:name => author)
+        f.updated = articles[0].date if articles[0]
+        articles.each do |post|
+          f.entries << post.to_atom_entry(root)
+        end  
+      end.to_xml
+    end
+
+    private
+
+    def load(filename, key = Page.path_from_file(filename, @base_dir))
+      return nil unless filename && key && File.exists?(filename)
+      if @pages && @pages[key] && File.mtime(filename) < @pages[key].mtime
+        @pages[key]
+      else
+        @pages ||= CaseInsensitiveHash.new
+        page = Page.from_filename(filename, @base_dir, @render_options)
+        @pages[key] = page
+        page
+      end
+    end
+
+    def find_inside(xs, conditions = {}) 
+      output = xs
+      conditions.each do |k, v|
+        next unless v
+        cond = case k
+               when :tag then lambda {|p| p.tags.include?(v) }
+               else lambda{|p| true}
+               end
+        output = output.select(&cond)
+      end
+      output
+    end
+    
+  end
+end

data/lib/spandex/page.rb

@@ -0,0 +1,131 @@
+require 'time'
+require 'pathname'
+require 'tilt'
+require 'atom'
+
+module Spandex
+  class Page
+    attr_reader :path, :mtime, :extension, :render_options
+
+    def self.from_path(path, base_path, render_options = {})
+      path = fix_path path
+      filename = file_from_path(path, base_path)
+      if filename
+        metadata, content = parse_file(filename)
+        Page.new(path, content, filename.extname, metadata, render_options)
+      else nil
+      end
+    end
+
+    def self.from_filename(filename, base_path, render_options = {})
+      pathname = Pathname.new(filename)
+      return nil unless pathname.exist?
+
+      path = path_from_file(pathname, base_path)
+      metadata, content = parse_file(filename)
+
+      Page.new(path, content, pathname.extname, metadata, render_options)
+    end
+
+    def self.mtime(path, base_path)
+      file = file_from_path(path, base_path)
+      if File.exists?(path)
+        File.mtime(file) 
+      else nil
+      end
+    end
+
+    def self.file_from_path(path, base_path)
+      path = fix_path path
+      paths = Pathname.glob(File.join(base_path, "#{path}.*"))
+      pathname = paths.select{|path| registered?(path)}.first
+    end
+
+    def self.path_from_file(pathname, base_path)
+      pathname = pathify(pathname)
+      pathname.relative_path_from(pathify(base_path)).sub_ext('')
+    end
+
+    def self.registered?(pathname)
+      pathname = pathify(pathname)
+      Tilt.registered?(pathname.extname.sub(/^./, ''))
+    end
+
+    
+    def title
+      metadata("title") || "(Unknown Title)"
+    end
+    
+    def date
+      @date ||= metadata("date") ? DateTime.parse(metadata("date")) : nil
+    end
+    
+    def body
+      @rendered_body ||= Tilt[@extension].new(nil, 1, @render_options){@content}.render
+    end
+    
+    def tags
+      @tags ||= metadata("tags", "categories") ? metadata("tags", "categories").split(",").map{|tag| tag.strip} : []
+    end
+    
+    def to_atom_entry(root)
+      unless date
+        raise "Must have a date"
+      end
+
+      Atom::Entry.new do |entry|
+        entry.title = title
+        entry.updated = date
+        entry.id = "#{root},#{@path}"
+        entry.links << Atom::Link.new(:href => "http://#{root}/#{@path}")
+        entry.content = Atom::Content::Html.new(body)
+      end
+    end
+    
+    private
+
+    def initialize(path, content, extension, metadata, render_options = {})
+      @path = path
+      @content = content
+      @metadata = metadata
+      @extension = extension.sub(/^./, '')
+      @mtime = Time.now
+      @render_options = render_options
+    end
+  
+    def metadata(*keys)
+      keys.each do |key|
+        return @metadata[key] if @metadata.has_key? key
+      end
+      nil
+    end
+
+    def self.pathify(path_or_string)
+      path_or_string.is_a?(String) ? Pathname.new(path_or_string) : path_or_string
+    end
+    
+    def self.parse_file(filename)
+      def self.metadata?(text)
+        text.split("\n").first =~ /^[\w ]+:/
+      end
+
+      contents = File.open(filename).read
+      
+      first_paragraph, remaining = contents.split(/\r?\n\r?\n/, 2)
+      metadata = {}
+      if metadata?(first_paragraph)
+        first_paragraph.split("\n").each do |line|
+          key, value = line.split(/\s*:\s*/, 2)
+          metadata[key.downcase] = value.chomp
+        end
+      end
+      markup = metadata?(first_paragraph) ? remaining : contents
+      return metadata, markup
+    end
+
+    def self.fix_path(path)
+      path.sub(/\/$/, '')
+    end
+
+  end
+end

data/lib/spandex/version.rb

@@ -0,0 +1,3 @@
+module Spandex
+  VERSION = "0.0.2"
+end

data/spandex.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "spandex/version"
+
+Gem::Specification.new do |s|
+  s.name        = "spandex"
+  s.version     = Spandex::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Isaac Cambron"]
+  s.email       = ["icambron@alum.mit.edu"]
+  s.homepage    = ""
+  s.summary     = "A simple content engine"
+  s.description = "Spandex manages a store of markup files and their metadata, useful in building blogs or blog engines"
+
+  s.add_dependency "tilt"
+  s.add_dependency "ratom"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "redcarpet", "2.0.0b5"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/finder_spec.rb

@@ -0,0 +1,215 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+require 'spandex'
+require 'atom'
+
+describe Spandex::Finder do
+  include PageFactory
+  include TempFileHelper
+
+  context "when getting all pages" do
+  
+    it "can find files" do
+      create_file("lasers.md", "You know it's 18 when you throw your dice.")
+      create_file("cheese.textile", "You've climbed that mountain not only once but twice.")
+      make_finder.all_pages.size.should == 2
+    end
+    
+    it "won't find repeated files roots" do
+      create_file("stuff.md", "Some say you're a loner but I know your kind.")
+      create_file("stuff.textile", "It's sad to see that's why I fake that I'm blind.")
+      
+      make_finder.all_pages.size.should == 1
+    end
+
+    it "finds thing with populated attributes" do
+      create_file("stuff.md", "Some say you're a loner but I know your kind.", :title => "The")
+      create_file("more_stuff.textile", "It's sad to see that's why I fake that I'm blind.", :title => "Sounds")
+
+      make_finder.all_pages.map{|p| p.title}.should == ["The", "Sounds"]
+    end
+  
+  end
+
+  context "when getting all articles" do
+
+    it "works fine when there are no articles" do
+      make_finder.all_articles.should be_empty
+    end
+    
+    it "only finds pages with dates" do
+      create_file("stuff.md", "You don't float like butterfly or fight like Ali.", :date => "2011/5/25")
+      create_file("more_stuff.md", "Dress like Prince but to the lowest degree.")
+      
+      results = make_finder.all_articles
+      results.size.should == 1
+      results[0].date.should == Date.civil(2011, 5, 25)
+    end
+
+    it "sorts by date descending" do
+      create_file("stuff.md", "I like that you can't slow down.", :date => "1986/5/25")
+      create_file("more_stuff.md", "Step back! 'Cause you ain't no one.", :date => "1982/5/25") 
+      create_file("even_more_stuff.md", "You're living in a lie.", :date => "2011/5/25")
+
+      results = make_finder.all_articles
+
+      results.size.should == 3
+      [Date.civil(2011,5,25), Date.civil(1986,5,25), Date.civil(1982,5,25)].each_with_index do |date, i|
+        results[i].date.should == date
+      end
+    end
+
+    it "ignores stray files" do
+      create_file("stuff.md~", "I like that you can't slow down.", :date => "1986/5/25")
+      make_finder.all_articles.should be_empty
+    end
+    
+  end
+
+  context "when generating an atom feed" do
+    
+    it "generates real atom content" do
+      create_file("stuff.md", "You ain't nothing but a BFI", :date => "1986/5/25", :title => "BFI")
+      create_file("more_stuff.md", "Leaving town on a two wheeler while your kids are home", :date => "1982/5/25")
+
+      #generate and then reparse
+      feed = make_finder.atom_feed(3, "The Sounds", "sounds.test.org", "articles.xml")
+      ratom = Atom::Feed.load_feed(feed)
+
+      ratom.entries.size.should == 2
+      ratom.authors.first.name.should == "The Sounds"
+      ratom.links.size.should == 2
+
+      e = ratom.entries.first
+      e.title.should == "BFI"
+    
+    end 
+
+    it "should only show the top n articles" do
+      create_file("stuff.md", "Giving up your love and life for some silver chrome", :date => "1986/5/25")
+      create_file("more_stuff.md", "You're acting like a fool so take my advice.", :date => "1986/5/25")
+      create_file("even_more_stuff.md", "It's not so hard to keep your eyes on the price.", :date => "1986/5/25")
+
+      feed = make_finder.atom_feed(2, "The Sounds", "sounds.test.org", "articles.xml")
+      ratom = Atom::Feed.load_feed(feed)
+
+      ratom.entries.size.should == 2
+    end
+
+    it "only includes pages with dates" do
+      create_file("stuff.md", "You don't float like butterfly or fight like Ali.", :date => "2011/5/25")
+      create_file("more_stuff.md", "Dress like Prince but to the lowest degree.")
+
+      feed = make_finder.atom_feed(2, "The Sounds", "sounds.test.org", "articles.xml")
+      ratom = Atom::Feed.load_feed(feed)
+
+      ratom.entries.size.should == 1
+    end
+    
+  end
+
+  context "when listing tags" do
+    
+    it "can list tags" do
+      create_file("stuff.md",  "Excuses are all I ever get from you", :tags => "Sweedish, New Wave")
+      create_file("more_stuff.md", "And we both know it's true", :tags => "Indie Rock") 
+      
+      tags = make_finder.tags
+      tags.should == ["Sweedish", "New Wave", "Indie Rock"]
+    end
+
+    it "has unique tags" do
+      create_file("stuff.md", "It's not me, it is you", :tags => "Sweedish, Indie Rock")
+      create_file("more_stuff.md", "And nothing matters at all", :tags => "Indie Rock") 
+      
+      tags = make_finder.tags
+      tags.should == ["Sweedish", "Indie Rock"]
+    end
+  end
+
+  context "loading a specific page" do
+
+    it "does in fact load it" do
+      create_file("stuff.md", "It felt so right at the time")
+      page = make_finder.get("stuff")
+      page.should_not be_nil
+    end
+
+    it "finds the first file tilt knows" do
+      create_file("stuff.snoogledoobers", "But we lost it all")
+      create_file("stuff.md", "You committed a crime")
+      page = make_finder.get("stuff")
+      page.extension.should == "md"
+    end
+
+    it "doesn't have to exist" do
+      page = make_finder.get("this/is/not/a/real/file")
+      page.should be_nil
+    end
+
+    it "caches individual files" do
+      finder = make_finder
+
+      create_file("stuff.md", "And did it matter to you", :tags => "yeah")
+      finder.get("stuff").tags.should == ["yeah"]
+
+      create_file("stuff.md", "Now you lost it all", :tags => "nah")
+      finder.get("stuff").tags.should == ["yeah"]
+    end
+
+    it "ignores trailing slashes" do
+      create_file("stuff.md", "Well, you're not so bright")
+      make_finder.get("stuff/").should_not be_nil
+    end
+
+  end
+
+  context "when loading by filename" do
+    it "does in fact load something" do
+      create_file("stuff.md", "You don't have to say you're sorry")
+      page = make_finder.get_by_filename(File.join(TEMP_DIR, "stuff.md"))
+      page.should_not be_nil
+    end
+
+    it "doesn't have to exist" do
+      page = make_finder.get_by_filename(File.join(TEMP_DIR, "this_is_not_a_file.md"))
+      page.should be_nil
+    end
+
+  end
+
+  context "when finding articles" do
+    it "can find them by tag" do
+      create_file("no.md", "You never mean it when you say you're sorry", :tags => "nono", :date => "2011/5/25")
+      create_file("yeah.md", "No guts, no glory, no time to worry", :tags => "yeahyeah", :date => "2011/5/26", :title => "Yeah Yeah Yeah")
+      
+      
+      results = make_finder.find_articles(:tag => "yeahyeah")
+      results.size.should == 1
+      results.first.title == "Yeah Yeah Yeah"
+    end
+
+    it "only finds articles" do
+      create_file("no.md", "No happy ending to your story", :tags => "yeahyeah")
+      create_file("yeah.md", "In moments like this, don't give a fuck about you", :tags => "yeahyeah", :date => "2011/5/26", :title => "Yeah Yeah Yeah")
+      
+      
+      results = make_finder.find_articles(:tag => "yeahyeah")
+      results.size.should == 1
+      results.first.title == "Yeah Yeah Yeah"
+    end
+
+  end
+
+  before(:each) do
+    create_temp_directory
+  end
+  
+  after(:each) do
+    remove_temp_directory
+  end
+
+  def make_finder
+    Spandex::Finder.new(TEMP_DIR)
+  end
+  
+end

data/spec/page_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+require 'spandex'
+require 'atom'
+require 'redcarpet'
+
+describe Spandex::Page do
+  include PageFactory
+  include TempFileHelper
+
+  context "when parsing a file" do
+    it "determines the extension" do 
+      page = create_page("test.md", "Oh my love we gotta save ourselves")
+      page.extension.should=="md"
+    end
+    
+    it "can have a title" do
+      page = create_page("test.md", "If we wanna safe the world", :title => "The Best of Me")
+      page.title.should == "The Best of Me"
+    end
+
+    it "can have a tag" do
+      page = create_page("test.md", "Don't give in to your hate", :tags => "sappy")
+      page.tags.should have(1).tags
+      page.tags.should == ["sappy"]
+    end
+    
+    it "can have multiple tags" do
+      page = create_page("test.md", "When you know you can change", :tags => "sappy,slightly trite")
+      page.tags.should == ['sappy', 'slightly trite']
+    end
+
+    it "can have multiple tags with weird spacing" do
+      page = create_page("test.md", "It's hitting home when you feel so strange", :tags => " sappy  , slightly trite ")
+      page.tags.should == ['sappy', 'slightly trite']
+    end
+    
+    it "can also have tags called 'categories'" do
+      page = create_page("test.md", "I wanna say those words", :categories => "sappy,slightly trite")
+      page.tags.should have(2).tags
+    end
+
+    it "can parse the body" do
+      page = create_page("test.md", "But it's not that easy")
+      page.body.should == Redcarpet::Markdown.new(Redcarpet::Render::HTML).render("But it's not that easy")
+    end
+
+    it "pass in rendering options" do
+      text = "```\nI smile but it doesn't make things right```"
+      create_file("test.md", text)
+      page = Spandex::Page.from_filename(File.join(TEMP_DIR, "test.md"), TEMP_DIR, :fenced_code_blocks => true) 
+      page.render_options.should have_key(:fenced_code_blocks)
+      markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML, :fenced_code_blocks => true)
+      page.body.should == markdown.render(text)
+    end
+
+    it "can have a date" do
+      page = create_page("test.md", "test_content", :date => "2011/5/25")
+      page.date.should == Date.civil(2011, 5, 25)
+    end
+
+    it "can omit the date" do
+      page = create_page("test.md", "test_content")
+      page.date.should be_nil
+    end
+
+    it "produces good atom output" do
+      page = create_page("test.md", "test_content", :title => "hello!", :date => "2011/5/25")
+      entry = page.to_atom_entry("http://test.org")
+      entry.title.should == "hello!"
+    end
+  end
+
+  before(:each) do
+    create_temp_directory
+  end
+  
+  after(:each) do
+    remove_temp_directory
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+module TempFileHelper
+  TEMP_DIR = File.expand_path('content', File.dirname(__FILE__))
+
+  def create_temp_directory
+    FileUtils.mkdir_p(TempFileHelper::TEMP_DIR)
+  end
+
+  def remove_temp_directory
+    FileUtils.rm_r(TempFileHelper::TEMP_DIR, :force => true)
+  end
+  
+  def temp_path(base)
+    File.join(TempFileHelper::TEMP_DIR, base)
+  end
+end
+
+module PageFactory
+  include TempFileHelper
+
+  def create_file(name, content, metadata = {})
+    full_name = File.join(TEMP_DIR, name)
+    metatext = metadata.map { |key, value| "#{key}: #{value}" }.join("\n")
+    contents =<<-EOF
+#{metatext}
+
+#{content}
+EOF
+    File.open(full_name, 'w') { |file| file.write(contents) }
+    full_name
+  end
+
+  def create_page(name, content, metadata = {})
+    full_name = create_file(name, content, metadata)
+    Spandex::Page.from_filename(full_name, TEMP_DIR)
+  end
+
+end

data/spec/wrapper_spec.rb

@@ -0,0 +1,5 @@
+describe Spandex do
+  it "is a finder" do
+    Spandex.new("somepath").is_a? Spandex::Finder
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: spandex
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Isaac Cambron
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-25 00:00:00 -04:00
+date: 2011-09-27 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,9 +52,9 @@ dependencies:
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 2.0.0b5
   type: :development
   version_requirements: *id004
 description: Spandex manages a store of markup files and their metadata, useful in building blogs or blog engines
@@ -66,8 +66,20 @@ extensions: []
 
 extra_rdoc_files: []
 
-files: []
-
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/spandex.rb
+- lib/spandex/finder.rb
+- lib/spandex/page.rb
+- lib/spandex/version.rb
+- spandex.gemspec
+- spec/finder_spec.rb
+- spec/page_spec.rb
+- spec/spec_helper.rb
+- spec/wrapper_spec.rb
 has_rdoc: true
 homepage: ""
 licenses: []