specdown 0.0.0 → 0.0.1

data/README.markdown

@@ -0,0 +1 @@
+This library has not yet been implemented. See SPEC.markdown for info about what it might become.

data/SPEC.markdown

@@ -0,0 +1,122 @@
+# specdown
+
+Write your README in markdown, and execute it with specdown. Documentation == Specification == WINNING
+
+## Why?
+
+I love README DRIVEN DEVELOPMENT. I love the free-form nature of writing a README. I dislike the process of copying and transforming my README into cucumber. Gherkin works well for many types of requirements, but I dislike turning readable, natural prose into "Given/When/Then" Gherkin. I dislike turning my readable prose into RSpec even more.
+
+## How?
+
+Writing your tests with specdown is as simple as writing a README. I'll show you. 
+
+Let's imagine we're writing a README for a silly little ruby library called "Todo":
+
+    # Todo
+
+    A simple library for managing your todo list. 
+
+    ## Usage
+
+    Go into `irb`, then `require 'todo'`. Type `Todo.List` to see your current to do list:
+
+        Todo.List #==> []
+
+    If at any point, you want to completely reset your Todo.List, simply call `Todo!`:
+        
+        Todo!
+        Todo.List.should be_empty
+
+    ### Adding/Removing
+
+    Now, add an item to your to-do list by calling it as if it were a method on the `Todo` object:
+
+        Todo.shop_for_groceries
+    
+    This added the item to your `Todo.List`:
+
+        Todo.List.should == [:shop_for_groceries]
+
+    You can remove an item from your todo list by adding an exclamation point onto the end of it:
+        Todo.shop_for_groceries!
+        Todo.List.should be_empty
+    
+
+    ### Bulk operations
+
+    You can also perform bulk operations on your `Todo.List`:
+      
+        Todo.edit! do 
+          shop
+          dry_cleaning!
+          shave!
+          walk_dogs
+        end
+
+    The items "dry_cleaning" and "shave" were removed from your `Todo.List`, and the items "shop" and "walk_dogs" were added to your Todo.List.
+
+        Todo.List.should == [
+          :shop,
+          :walk_dogs
+        ]
+
+Let's call this file "README.markdown", and place it inside a "specdown/" directory:
+
+    $ ls -r
+      specdown/
+        README.markdown
+
+We can execute this markdown with specdown by simply the `specdown` command. If you'd like to have some code run before the markdown is executed, put it in a ruby file inside a "specdown" directory:
+
+    $ cat > specdown/support.rb
+      
+      $LOAD_PATH.unshift './lib'
+      require 'rspec/expectations' # for using "should" matchers in the README
+      require 'todo'
+
+## Trees and Leafs
+
+In the README that we wrote for `Todo`, we actually wrote two tests, or scenarios. 
+
+`specdown` creates a tree out of our markdown. In our case, the tree for our `Todo` README looks like this:
+
+
+                  #Todo
+                    |
+                  ##Usage
+                  /    \
+                 /      \
+                /        \
+               /          \
+              /            \
+             /              \
+            /                \
+    ###Adding/Removing       ###Bulk Operations
+
+`specdown` will then walk the path from the root to every leaf node in the tree, executing any code it finds along the way.
+
+Thus, the first "test" will look like this:
+
+    Todo.List #==> []
+    Todo!
+    Todo.List.should be_empty
+    Todo.shop_for_groceries
+    Todo.List.should == [:shop_for_groceries]
+    Todo.shop_for_groceries!
+    Todo.List.should be_empty
+
+The second "test" looks like this:
+
+    Todo.List
+    Todo!
+    Todo.List.should be_empty
+    Todo.edit! do 
+      shop
+      dry_cleaning!
+      shave!
+      walk_dogs
+    end
+    Todo.List.should == [
+      :shop,
+      :walk_dogs
+    ]

data/bin/specdown

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'specdown'
+
+Dir["specdown/**/*.rb"].each do |ruby_file|
+  require ruby_file
+end
+
+Specdown::Command.new.execute

data/features/command.feature

@@ -0,0 +1,93 @@
+Feature: `specdown` command
+
+  Specdown comes with a `specdown` command that allows you to run your tests from the command line.
+
+  By default, running `specdown` at a command prompt will cause specdown to look in the current working directory for a "specdown" directory. If it finds a directory called `specdown`, it will eval all code files it finds, then load all "markdown" files and run them, providing you with a report at the end.
+
+  Scenario: `specdown` with no arguments, and no specdown directory
+
+    When I run `specdown` from the command line in a directory that contains no 'specdown' directory
+    Then I should see the following output:
+      """
+        0 markdowns
+        0 tests
+        0 failures
+      """
+
+  Scenario: `specdown` with no arguments, and a specdown directory with a single test
+    
+    Given I have a specdown directory containing a single markdown file:
+      """
+      # Specdown Example
+
+      This is an example specdown file.
+
+      ## Child Node
+
+      This section is a child node. It contains some ruby code: 
+          
+          "simple code".should_not == nil
+
+      ### First Leaf
+
+      This section has a failure simulation:
+          
+          raise "specdown error simulation!"
+
+      ## Last Leaf
+
+      This section is a leaf node. It contains some ruby code:
+          
+          1.should == 1
+      """
+
+    When I run `specdown` with no arguments
+    Then I should see the following output:
+      """
+        1 markdown
+        2 tests
+        2 failures
+
+        undefined method `should_not' for "simple code":String
+        undefined method `should' for 1:Fixnum
+      """
+
+  Scenario: `specdown` with no arguments, and a specdown directory containing a single ruby file and a single markdown file
+    Given I have a specdown directory containing a markdown file:
+      """
+      # Specdown Example
+
+      This is an example specdown file.
+
+      ## Child Node
+
+      This section is a child node. It contains some ruby code: 
+          
+          "simple code".should_not == nil
+
+      ### First Leaf
+
+      This section has a failure simulation:
+          
+          raise "specdown error simulation!"
+
+      ## Last Leaf
+
+      This section is a leaf node. It contains some ruby code:
+          
+          1.should == 1
+      """
+    And a single ruby file:
+      """
+      require 'rubygems'
+      require 'rspec/expectations'
+      """
+    When I run `specdown` with no arguments
+    Then I should see the following output:
+      """
+        1 markdown
+        2 tests
+        1 failure
+
+        specdown error simulation!
+     """

data/features/fixtures/parser_example.markdown

@@ -0,0 +1,21 @@
+# Specdown Example
+
+This is an example specdown file.
+
+## Child Node
+
+This section is a child node. It contains some ruby code: 
+    
+    "simple code".should_not == nil
+
+### First Leaf
+
+This section has a failure simulation:
+    
+    raise "specdown error simulation!"
+
+## Last Leaf
+
+This section is a leaf node. It contains some ruby code:
+    
+    1.should == 1

data/features/parser.feature

@@ -0,0 +1,108 @@
+Feature: Specdown Parser
+
+  The default specdown parser will convert a markdown file into a tree, with the headings inside the markdown forming the nodes of the tree.
+
+  For example, imagine we are given following simple markdown file:
+
+      readme = <<-README
+      
+      \# Specdown Example
+
+      This is an example specdown file.
+
+      \## Child Node
+
+      This section is a child node. It contains some ruby code: 
+          
+          "simple code".should_not == nil
+
+      \### First Leaf
+
+      This section has a failure simulation:
+          
+          raise "specdown error simulation!"
+
+      \## Last Leaf
+
+      This section is a leaf node. It contains some ruby code:
+          
+          1.should == 1
+       README
+
+  As you can see, this forms a tree, with "# Specdown Example" at the root of the tree, and "## Leaf 1" and "## Leaf 2" as the children / leafs. 
+
+  then the Specdown::Parser would turn into the a tree data structure:
+
+      tree = Specdown::Parser.parse readme
+
+  You can ask for the root of the tree object via the `root` method:
+
+      tree.root
+
+  The root returned is a `Specdown::Parser::Node` object. A `Node` responds to four methods: `name`, `code`, `contents`, and `children`.
+
+      tree.root.name.should == "Specdown Example"
+      tree.root.code.should be(nil)
+      tree.root.contents.should == "# Specdown Example\n\nThis is an example specdown file."
+  
+  The `children` method is simply an array of `Specdown::Parser::Node` objects, each corresponding to the children (if any) of the current node. 
+
+      tree.root.children.first.name.should == "Leaf 1"
+      tree.root.children.first.code.should == "1.should == 1"
+
+
+  Scenario: Parsing a specdown file
+
+    Given the following specdown example file:
+      """
+      # Specdown Example
+
+      This is an example specdown file.
+
+      ## Child Node
+
+      This section is a child node. It contains some ruby code: 
+          
+          "simple code".should_not == nil
+
+      ### First Leaf
+
+      This section has a failure simulation:
+          
+          raise "specdown error simulation!"
+
+      ## Last Leaf
+
+      This section is a leaf node. It contains some ruby code:
+          
+          1.should == 1
+      """
+
+    When I parse it into a tree:
+      """
+        @tree = Specdown::Parser.parse @readme
+      """
+
+    Then the root should be the "h1" section:
+      """
+        @tree.root.name.should == "Specdown Example"
+        @tree.root.code.should be_empty
+      """
+
+    And the root should have two children:
+      """
+        @tree.root.children.length.should == 2
+        
+        child_node = @tree.root.children.first
+        first_leaf = child_node.children.first
+        last_leaf = @tree.root.children.last
+        
+        child_node.name.should  == "Child Node"
+        child_node.code.should  == '"simple code".should_not == nil'
+
+        first_leaf.name.should  == "First Leaf"
+        first_leaf.code.should  == 'raise "specdown error simulation!"'
+        
+        last_leaf.name.should   == "Last Leaf"
+        last_leaf.code.should   == "1.should == 1" 
+      """

data/features/report.feature

@@ -0,0 +1,58 @@
+Feature: Report
+  
+  Specdown comes with a generic reporting class. If you provide it with a runner's Specdown::Stats object (or an array of Specdown::Stats objects), then it will generate a report for you. 
+
+  For example, suppose we have the following Specdown::Stats instance:
+
+      stats = Specdown::Stats.new
+      stats.tests = 3
+      stats.exceptions = [StandardError.new("error simulation")]
+
+  We could then pass it off to our reporter class and receive the following report:
+
+      Specdown::Report.new(stats).generate.should == %{
+          1 markdown
+          3 tests
+          2 successes
+          1 failure
+
+          StandardError: error simulation
+      %}
+
+  
+  Scenario: A Specdown::Report instantiated with a single stats object
+    
+    Given the following Specdown::Stats instance:
+      """
+        @stats        = Specdown::Stats.new
+        @stats.tests  = 3
+        @stats.exceptions << StandardError.new("error simulation")
+      """
+
+    Then `Specdown::Report.new(@stats).generate` should include the following output:
+      """
+        1 markdown
+        3 tests
+        1 failure
+
+        error simulation
+      """
+
+  Scenario: A Specdown::Report instantiated with an array of stats
+
+    Given the following of Specdown::Stats instances:
+      """
+        @results = [
+          Specdown::Stats.new.tap {|s| s.tests = 3 },
+          Specdown::Stats.new.tap {|s| s.tests = 1; s.exceptions << StandardError.new("error simulation") }
+        ]
+      """
+    
+    Then `Specdown::Report.new(@results).generate` should include the following output:
+      """
+        2 markdowns
+        4 tests
+        1 failure
+
+        error simulation
+      """

data/features/runner.feature

@@ -0,0 +1,95 @@
+Feature: Runner
+
+  The `Specdown::Runner` class accepts a markdown parse tree, and runs the tests found within.
+
+  Imagine we start with this markdown file:
+
+      \# Specdown Example
+
+      This is an example specdown file.
+
+      \## Child Node
+
+      This section is a child node. It contains some ruby code: 
+          
+          "simple code".should_not == nil
+
+      \### First Leaf
+
+      This section has a failure simulation:
+          
+          raise "specdown error simulation!"
+
+      \## Last Leaf
+
+      This section is a leaf node. It contains some ruby code:
+          
+          1.should == 1
+  
+  We then parse it into a Specdown::Tree:
+      
+      parse_tree = Specdown::Parser.parse File.read("/path/to/markdown")
+  
+  We can now generate a new `Specdown::Runner` instance and run the tests:
+
+      runner = Specdown::Runner.new(parse_tree)
+      runner.run
+
+  While running, it will print results to STDOUT like "F." 
+
+  We can access statistics about the run programatically:
+      
+      runner.stats.tests                   #==> 2
+      runner.stats.failures                #==> 1
+      runner.stats.successes               #==> 1
+      runner.stats.exceptions.map(&:to_s)  #==> ['StandardError: "specdown error simulation"']
+
+  Scenario: Running tests
+
+    Given the following specdown example file:
+      """
+      # Specdown Example
+
+      This is an example specdown file.
+
+      ## Child Node
+
+      This section is a child node. It contains some ruby code: 
+          
+          "simple code".should_not == nil
+
+      ### First Leaf
+
+      This section has a failure simulation:
+          
+          raise "specdown error simulation!"
+
+      ## Last Leaf
+
+      This section is a leaf node. It contains some ruby code:
+          
+          1.should == 1
+      """
+
+    When I parse it into a tree:
+      """
+        @tree = Specdown::Parser.parse @readme
+      """
+    
+    And I generate a `Specdown::Runner` instance from it:
+      """
+        @runner = Specdown::Runner.new @tree
+      """
+
+    Then I should be able to run the tests:
+      """
+        @runner.run
+      """
+    
+    And I should be able to access the report data programatically:
+      """
+      @runner.stats.tests                   #==> 2
+      @runner.stats.failures                #==> 1
+      @runner.stats.successes               #==> 1
+      @runner.stats.exceptions.map(&:to_s)  #==> ['(eval):3:in `execute_test': specdown error simulation!']
+      """

data/features/specdown_examples/no_ruby/specdown/parser_example.markdown

@@ -0,0 +1,21 @@
+# Specdown Example
+
+This is an example specdown file.
+
+## Child Node
+
+This section is a child node. It contains some ruby code: 
+    
+    "simple code".should_not == nil
+
+### First Leaf
+
+This section has a failure simulation:
+    
+    raise "specdown error simulation!"
+
+## Last Leaf
+
+This section is a leaf node. It contains some ruby code:
+    
+    1.should == 1

data/features/specdown_examples/with_ruby/specdown/env.rb

@@ -0,0 +1,2 @@
+require 'rubygems'
+require 'rspec/expectations'

data/features/specdown_examples/with_ruby/specdown/parser_example.markdown

@@ -0,0 +1,21 @@
+# Specdown Example
+
+This is an example specdown file.
+
+## Child Node
+
+This section is a child node. It contains some ruby code: 
+    
+    "simple code".should_not == nil
+
+### First Leaf
+
+This section has a failure simulation:
+    
+    raise "specdown error simulation!"
+
+## Last Leaf
+
+This section is a leaf node. It contains some ruby code:
+    
+    1.should == 1

data/features/step_definitions/command.rb

@@ -0,0 +1,21 @@
+When /^I run `specdown` from the command line in a directory that contains no 'specdown' directory$/ do
+  @output = `bundle exec ruby -I ./lib ./bin/specdown`
+end
+
+Then /^I should see the following output:$/ do |string|
+  string.split("\n").each do |line|
+    @output.include?(line.strip).should be(true)
+  end
+end
+
+Given /^I have a specdown directory containing a (?:single )?markdown file:$/ do |string|
+  @directory = "features/specdown_examples/no_ruby/"
+end
+
+When /^I run `specdown` with no arguments$/ do
+  @output = `cd #{@directory} && bundle exec ruby -I ../../../lib ../../../bin/specdown`
+end
+
+Given /^a single ruby file:$/ do |string|
+  @directory = "features/specdown_examples/with_ruby/"
+end

data/features/step_definitions/parser.rb

@@ -0,0 +1,15 @@
+Given /^the following specdown example file:$/ do |string|
+  @readme = File.read "features/fixtures/parser_example.markdown"
+end
+
+When /^I parse it into a tree:$/ do |string|
+  eval string
+end
+
+Then /^the root should be the ".*" section:$/ do |string|
+  eval string
+end
+
+Then /^the root should have two children:$/ do |string|
+  eval string
+end

data/features/step_definitions/report.rb

@@ -0,0 +1,14 @@
+Given /^the following Specdown::Stats instance:$/ do |string|
+  eval string
+end
+
+Then /^`(.*)` should include the following output:$/ do |code, string|
+  output = eval code
+  string.split("\n").each do |line|
+    output.should include(line.strip)
+  end
+end
+
+Given /^the following of Specdown::Stats instances:$/ do |string|
+  eval string
+end

data/features/step_definitions/runner.rb

@@ -0,0 +1,15 @@
+When /^I generate a `Specdown::Runner` instance from it:$/ do |string|
+  eval string
+end
+
+Then /^I should be able to run the tests:$/ do |string|
+  eval string
+end
+
+Then /^I should be able to print a report:$/ do |string|
+  eval string
+end
+
+Then /^I should be able to access the report data programatically:$/ do |string|
+  eval string
+end

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift './lib'
+require 'specdown'
+require 'rspec/expectations'
+require 'rspec/matchers'

data/lib/specdown/command.rb

@@ -0,0 +1,28 @@
+module Specdown
+  class Command
+    def initialize
+      @markdowns = Dir["specdown/**/*.markdown"]
+    end
+
+    def execute
+      run
+      report
+    end
+    
+    private
+    def run
+      @results =
+        @markdowns.map {|markdown| 
+          Parser.parse(File.read(markdown))
+        }.map {|tree| 
+          Runner.new(tree)
+        }.map {|runner|
+          runner.run
+        }.collect &:stats
+    end
+
+    def report
+      puts Specdown::Report.new(@results).generate
+    end
+  end
+end

data/lib/specdown/node.rb

@@ -0,0 +1,15 @@
+module Specdown
+  class Node
+    attr_accessor :name, :code, :contents, :children, :parent
+
+    def initialize
+      @code = ''
+      @contents = ''
+      @children = []
+    end
+
+    def code
+      @code.strip
+    end
+  end
+end

data/lib/specdown/parser.rb

@@ -0,0 +1,59 @@
+module Specdown
+  module Parser
+    extend self
+
+    def parse(readme)
+      kramdown = Kramdown::Document.new readme, :input => :markdown
+      build_tree kramdown.root.children
+    end
+
+    private
+    def build_tree(parsed_elements)
+      tree = Tree.new
+      scan_for_root_node parsed_elements
+      tree.root = consume_section parsed_elements unless parsed_elements.empty?
+      consume_children parsed_elements, tree.root unless parsed_elements.empty?
+      tree
+    end
+
+    def consume_children(parsed_elements, current_parent)
+      current_level = parsed_elements.first.options[:level] 
+      raise "Specdown Parse Error: Detected multiple h1 headers in document." if current_level == 1
+
+      unless parsed_elements.empty?
+        current_parent.children << consume_section(parsed_elements, current_parent)
+      end
+
+      unless parsed_elements.empty?
+        next_section_level = parsed_elements.first.options[:level]
+        if next_section_level < current_level
+          consume_children parsed_elements, current_parent.parent
+        elsif next_section_level == current_level
+          consume_children parsed_elements, current_parent
+        else
+          consume_children parsed_elements, current_parent.children.last
+        end
+      end
+    end
+    
+    def consume_section(parsed_elements, parent=nil)
+      node = Specdown::Node.new
+      node.name = parsed_elements.shift.options[:raw_text]
+      node.parent = parent
+
+      while !parsed_elements.empty? && parsed_elements.first.type != :header
+        element        = parsed_elements.shift
+        node.code     += element.value if element.type == :codeblock
+        node.contents += element.value.to_s + element.children.map(&:value).join
+      end
+      node
+    end
+
+    def scan_for_root_node(parsed_elements)
+      until parsed_elements.empty? || (
+        parsed_elements.first.type == :header && parsed_elements.first.options[:level] == 1
+      )
+      end
+    end
+  end
+end

data/lib/specdown/runner/report.rb

@@ -0,0 +1,40 @@
+module Specdown
+  class Report
+    def initialize(stats)
+      if stats.kind_of? Array
+        @stats = stats
+      else
+        @stats = [stats]
+      end
+    end
+    
+    def generate
+      [
+        format_stat("markdown", markdowns), 
+        format_stat("test", tests), 
+        format_stat("failure", failures)
+      ].join("\n") + "\n\n" + exceptions.join("\n\n")
+    end
+    
+    private
+    def format_stat(word, number)
+      "#{number} #{number == 1 ? word : word + "s"}"
+    end
+
+    def tests
+      @tests ||= @stats.inject(0) {|sum, stat| sum += stat.tests}
+    end
+
+    def failures
+      @failures ||= @stats.inject(0) {|sum, stat| sum += stat.failures}
+    end
+
+    def markdowns
+      @stats.count
+    end
+   
+    def exceptions
+      @stats.collect(&:exceptions).flatten.map {|e| [e.to_s, e.backtrace].join "\n"}
+    end
+  end
+end

data/lib/specdown/runner/stats.rb

@@ -0,0 +1,18 @@
+module Specdown
+  class Stats
+    attr_accessor :tests, :exceptions
+
+    def initialize
+      @tests = 0
+      @exceptions = []
+    end
+
+    def successes
+      @tests - @exceptions.count
+    end
+
+    def failures
+      @exceptions.count
+    end
+  end
+end

data/lib/specdown/runner.rb

@@ -0,0 +1,44 @@
+module Specdown
+  class Runner
+    attr_reader :stats
+
+    def initialize(tree)
+      @tree   = tree
+      @stats  = Stats.new
+    end
+
+    def run
+      depth_first_search @tree.root
+      puts "\n\n"
+      self
+    end
+
+    private
+    def depth_first_search(node, code=[])
+      if node.children.empty?
+        execute_test(code + [node.code])
+      else
+        node.children.each do |child|
+          depth_first_search(child, (code + [node.code]))
+        end
+      end
+    end
+
+    def execute_test(code)
+      @stats.tests += 1
+      
+      begin
+        Sandbox.new.instance_eval do
+          eval code.join("\n")
+        end
+
+        print '.'
+
+      rescue Exception => e
+        @stats.exceptions << e
+
+        print 'F'
+      end
+    end
+  end
+end

data/lib/specdown/sandbox.rb

@@ -0,0 +1,4 @@
+module Specdown
+  class Sandbox
+  end
+end

data/lib/specdown/tree.rb

@@ -0,0 +1,8 @@
+module Specdown
+  class Tree
+    attr_accessor :root
+
+    def initialize
+    end
+  end
+end

data/lib/specdown.rb

@@ -0,0 +1,9 @@
+require 'kramdown'
+require 'specdown/parser'
+require 'specdown/node'
+require 'specdown/tree'
+require 'specdown/sandbox'
+require 'specdown/runner'
+require 'specdown/runner/report'
+require 'specdown/runner/stats'
+require 'specdown/command'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: specdown
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: 
   segments: 
   - 0
   - 0
-  - 0
-  version: 0.0.0
+  - 1
+  version: 0.0.1
 platform: ruby
 authors: 
 - Matt Parker
@@ -15,19 +15,87 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-16 00:00:00 Z
-dependencies: []
-
+date: 2011-12-30 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: kramdown
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 0
+        - 13
+        - 4
+        version: 0.13.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: 
 email: moonmaster9000@gmail.com
-executables: []
-
+executables: 
+- specdown
 extensions: []
 
-extra_rdoc_files: []
-
-files: []
-
+extra_rdoc_files: 
+- README.markdown
+- SPEC.markdown
+files: 
+- lib/specdown/command.rb
+- lib/specdown/node.rb
+- lib/specdown/parser.rb
+- lib/specdown/runner/report.rb
+- lib/specdown/runner/stats.rb
+- lib/specdown/runner.rb
+- lib/specdown/sandbox.rb
+- lib/specdown/tree.rb
+- lib/specdown.rb
+- bin/specdown
+- README.markdown
+- SPEC.markdown
+- features/command.feature
+- features/fixtures/parser_example.markdown
+- features/parser.feature
+- features/report.feature
+- features/runner.feature
+- features/specdown_examples/no_ruby/specdown/parser_example.markdown
+- features/specdown_examples/with_ruby/specdown/env.rb
+- features/specdown_examples/with_ruby/specdown/parser_example.markdown
+- features/step_definitions/command.rb
+- features/step_definitions/parser.rb
+- features/step_definitions/report.rb
+- features/step_definitions/runner.rb
+- features/support/env.rb
 homepage: http://github.com/moonmaster9000/specdown
 licenses: []
 
@@ -61,5 +129,17 @@ rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Write your specs as if they were a README, then EXECUTE them.
-test_files: []
-
+test_files: 
+- features/command.feature
+- features/fixtures/parser_example.markdown
+- features/parser.feature
+- features/report.feature
+- features/runner.feature
+- features/specdown_examples/no_ruby/specdown/parser_example.markdown
+- features/specdown_examples/with_ruby/specdown/env.rb
+- features/specdown_examples/with_ruby/specdown/parser_example.markdown
+- features/step_definitions/command.rb
+- features/step_definitions/parser.rb
+- features/step_definitions/report.rb
+- features/step_definitions/runner.rb
+- features/support/env.rb