saga 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+html
+pkg

data/.kick

@@ -0,0 +1,14 @@
+recipe :ignore
+ignore(/(^tmp|\.DS_Store)$/)
+
+recipe :ruby
+process do |files|
+  Ruby.run_tests(files.take_and_map do |file|
+    case file
+    when %r{^lib/(.+)\.rb$}
+      "test/#{$1.gsub('/', '_')}_spec.rb"
+    when %r{^test/(.+)_spec\.rb$}
+      file
+    end
+  end)
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Fingertips, Manfred Stienstra <manfred@fngtps.com>
+
+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.rdoc

@@ -0,0 +1,3 @@
+= Saga
+
+Saga is a tool to convert the story format used at Fingertips to a readable document.

data/Rakefile

@@ -0,0 +1,32 @@
+require 'rake'
+require 'rake/rdoctask'
+
+desc "Run all specs by default"
+task :default => [:spec]
+
+desc "Run all specs"
+task :spec do
+  Dir[File.dirname(__FILE__) + '/test/**/*_spec.rb'].each do |file|
+    load file
+  end
+end
+
+namespace :documentation do
+  Rake::RDocTask.new(:generate) do |rd|
+    rd.main = "README.rdoc"
+    rd.rdoc_files.include("README.rdoc", "LICENSE", "bin/**/*.rb", "lib/**/*.rb", "templates/**/*.rb")
+    rd.options << "--all" << "--charset" << "utf-8"
+  end
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "saga"
+    s.summary = s.description = "Saga is a tool to convert stories syntax to a nicely formatted document."
+    s.homepage = "http://fingertips.github.com"
+    s.email = "manfred@fngtps.com"
+    s.authors = ["Manfred Stienstra"]
+  end
+rescue LoadError
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/saga

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'saga'
+Saga.run(ARGV)

data/lib/saga.rb

@@ -0,0 +1,13 @@
+module Saga
+  autoload :Document,  'saga/document'
+  autoload :Formatter, 'saga/formatter'
+  autoload :Parser,    'saga/parser'
+  autoload :Runner,    'saga/runner'
+  autoload :Tokenizer, 'saga/tokenizer'
+  
+  def self.run(argv)
+    runner = ::Saga::Runner.new(argv)
+    runner.run
+    runner
+  end
+end

data/lib/saga/document.rb

@@ -0,0 +1,13 @@
+module Saga
+  class Document
+    attr_accessor :title, :introduction, :authors, :stories, :definitions
+    
+    def initialize
+      @title        = ''
+      @introduction = []
+      @authors      = []
+      @stories      = {}
+      @definitions  = {}
+    end
+  end
+end

data/lib/saga/formatter.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'erubis'
+
+module Saga
+  class Formatter
+    TEMPLATE_PATH = File.expand_path('../../../templates', __FILE__)
+    
+    def initialize(document)
+      @document = document
+    end
+    
+    def format
+      helpers_file = File.join(self.class.template_path, 'default/helpers.rb')
+      load helpers_file
+      @document.extend(Helpers)
+      binding = @document.send(:binding)
+      
+      template_file = File.join(self.class.template_path, 'default/document.erb')
+      template = Erubis::Eruby.new(File.read(template_file))
+      template.result(binding)
+    end
+    
+    def self.format(document)
+      formatter = new(document)
+      formatter.format
+    end
+    
+    def self.template_path
+      TEMPLATE_PATH
+    end
+  end
+end

data/lib/saga/parser.rb

@@ -0,0 +1,51 @@
+module Saga
+  class Parser
+    attr_accessor :document
+    
+    def initialize
+      @tokenizer = ::Saga::Tokenizer.new(self)
+      @document  = ::Saga::Document.new
+      @current_section = :title
+      @current_header = ''
+    end
+    
+    def parse(input)
+      @tokenizer.process(input)
+      @document
+    end
+    
+    def handle_author(author)
+      @document.authors << author
+    end
+    
+    def handle_story(story)
+      @document.stories[@current_header] ||= []
+      @document.stories[@current_header] << story
+    end
+    
+    def handle_definition(definition)
+      @document.definitions[@current_header] ||= []
+      @document.definitions[@current_header] << definition
+    end
+    
+    def handle_string(string)
+      return if string.strip == ''
+      return(@current_section = :body) if string.strip == 'USER STORIES'
+      
+      case @current_section
+      when :title
+        @document.title = string.gsub(/^requirements/i, '').strip
+        @current_section = :introduction
+      when :introduction
+        @document.introduction << string
+      else
+        @current_header = string.strip
+      end
+    end
+    
+    def self.parse(input)
+      parser = new
+      parser.parse(input)
+    end
+  end
+end

data/lib/saga/runner.rb

@@ -0,0 +1,41 @@
+require 'optparse'
+ 
+module Saga
+  class Runner
+    def initialize(argv)
+      @argv = argv
+      @options = {}
+    end
+    
+    def parser
+      OptionParser.new do |opts|
+        opts.banner =  "Usage: saga [command] [options] <file>"
+        opts.separator ""
+        opts.on("-h", "--help", "Show help") do
+          puts opts
+          exit
+        end
+      end
+    end
+    
+    def run_command(command, options)
+      case command
+      when :run
+      else
+        filename = File.expand_path(command)
+        document = Saga::Parser.parse(File.read(filename))
+        puts Saga::Formatter.format(document)
+      end
+    end
+    
+    def run
+      argv = @argv.dup
+      parser.parse!(argv)
+      if command = argv.shift
+        run_command(command, @options)
+      else
+        puts parser.to_s
+      end
+    end
+  end
+end

data/lib/saga/tokenizer.rb

@@ -0,0 +1,71 @@
+module Saga
+  class Tokenizer
+    def initialize(parser)
+      @parser = parser
+    end
+    
+    def process_line(input)
+      if input[0,2].downcase == 'as'
+        @parser.handle_story(self.class.tokenize_story(input))
+      elsif input[0,1] == '-'
+        @parser.handle_author(self.class.tokenize_author(input))
+      elsif input =~ /^(\w|[\s-])+:/
+        @parser.handle_definition(self.class.tokenize_definition(input))
+      else
+        @parser.handle_string(input)
+      end
+    end
+    
+    def process(input)
+      input.split("\n").each do |line|
+        process_line(line)
+      end
+    end
+    
+    def self.tokenize_story_attributes(input)
+      return {} if input.nil?
+      
+      attributes = {}
+      rest       = []
+      parts      = input.split(/\s/)
+      
+      parts.each do |part|
+        if part.strip == ''
+          next
+        elsif match = /\#(\d+)/.match(part)
+          attributes[:id] = match[1].to_i
+        else
+          rest << part
+        end
+      end
+      
+      attributes[:status] = rest.join(' ') unless rest.empty?
+      attributes
+    end
+    
+    def self.tokenize_story(input)
+      description, attributes = input.split('-')
+      story = tokenize_story_attributes(attributes)
+      story[:description] = description.strip
+      story
+    end
+    
+    def self.tokenize_definition(input)
+      if match = /^([^:]+)\s*:\s*(.+)\s*$/.match(input)
+        {:title => match[1], :definition => match[2]}
+      else
+        {}
+      end
+    end
+    
+    def self.tokenize_author(input)
+      author = {}
+      parts = input[1..-1].split(',')
+      author[:name]    = parts[0].strip if parts[0]
+      author[:email]   = parts[1].strip if parts[1]
+      author[:company] = parts[2].strip if parts[2]
+      author[:website] = parts[3].strip if parts[3]
+      author
+    end
+  end
+end

data/templates/default/document.erb

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+<head>
+<title>Requirements <%= title %> &middot; Fingertips</title>
+<link rel="stylesheet" type="text/css" media="all" href="http://resources.fngtps.com/2006/doc.css" />
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<style type="text/css">
+  td.id { text-align: right !important; }
+  td.id a { color: #000; }
+  table.review { border-bottom: 1px solid #ccc; margin-top: -1em;}
+  table.review td { padding: .25em 0; vertical-align: top; text-align: left; min-width: 1em; }
+  table.review th { padding: .25em 0; vertical-align: top; text-align: right; }
+  table.review td.story { width: 100%; border-top: 1px solid #ccc; }
+  table.review td.meta { padding-left: 1em; border-top: 1px solid #ccc; text-align: right !important; white-space: nowrap; }
+  table.review td.notes { color: #666; padding: 0 0 .25em 0; font-style: italic; }
+  table.review .dropped { color: #666; text-decoration: line-through; }
+  table.review .done { color: #666; background-color: #f0f8ff; }
+</style>
+<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.2.6/jquery.min.js"></script>
+</head>
+<body id="doc" class="requirements">
+
+<p id="logo"><img src="http://resources.fngtps.com/2006/print-logo.png" alt="Fingertips design &amp; development" /> </p>
+
+<h1>Requirements <br /><%= title %></h1>
+
+<% authors.each do |author| %>
+<p class="author"><%= format_author(author) %></p>
+<% end %>
+
+<% unless stories.empty? %>
+<h2>User stories</h2>
+<% stories.each do |header, stories| %>
+<% unless header.strip == '' %>
+<h3><%= header %></h3>
+<% end %>
+<table class="review">
+<tr>
+  <th></th>
+  <th title="id">#</th>
+  <th title="Estimate">e</th>
+  <th title="Iteration">i</th>
+  <th title="Status">s</th>
+</tr>
+<% stories.each do |story| %>
+<tr class="<%= story[:status] %>" id="story<%= story[:id] %>">
+  <td class="story"><%= story[:description] %></td>
+  <td class="meta id"><%= story[:id] %></td>
+  <td class="meta estimate"><%= story[:estimate] %></td>
+  <td class="meta iteration"><%= story[:iteration] %></td>
+  <td class="meta status"><%= story[:status] %></td>
+</tr>
+<% end %>
+</table>
+<% end %>
+<% end %>
+
+<% definitions.each do |header, definitions| %>
+<% unless header.strip == '' %>
+<h2><%= format_header(header) %></h2>
+<% end %>
+<dl>
+<% definitions.each do |definition| %>
+<dt><%= definition[:title] %></dt>
+<dd><%= definition[:definition] %></dd>
+<% end %>
+</dl>
+<% end %>
+</body>
+</html>

data/templates/default/helpers.rb

@@ -0,0 +1,17 @@
+module Helpers
+  def format_author(author)
+    parts = []
+    parts << author[:name] if author[:name]
+    parts << "<a href=\"mailto:#{author[:email]}\">#{author[:email]}</a>" if author[:email]
+    if author[:website] and author[:company]
+      parts << "<a href=\"#{author[:website]}\">#{author[:company]}</a>"
+    elsif author[:company]
+      parts << author[:company]
+    end
+    parts.join(', ')
+  end
+  
+  def format_header(header)
+    "#{header[0,1].upcase}#{header[1..-1].downcase}"
+  end
+end

data/test/cases/author.txt

@@ -0,0 +1,8 @@
+- Thijs van der Vossen
+=> {:name => 'Thijs van der Vossen'}
+- Thijs van der Vossen, thijs@fngtps.com
+=> {:name => 'Thijs van der Vossen', :email => 'thijs@fngtps.com'}
+- Thijs van der Vossen, thijs@fngtps.com, Fingertips
+=> {:name => 'Thijs van der Vossen', :email => 'thijs@fngtps.com', :company => 'Fingertips'}
+- Thijs van der Vossen, thijs@fngtps.com, Fingertips, http://www.fngtps.com
+=> {:name => 'Thijs van der Vossen', :email => 'thijs@fngtps.com', :company => 'Fingertips', :website => 'http://www.fngtps.com'}

data/test/cases/definition.txt

@@ -0,0 +1,10 @@
+
+=> {}
+User: A user
+=> {:title => 'User', :definition => 'A user'}
+Administrator: Any user with full administrative access.
+=> {:title => 'Administrator', :definition => 'Any user with full administrative access.'}
+Non-functional: Stories related to non-functional requirements.
+=> {:title => 'Non-functional', :definition => 'Stories related to non-functional requirements.'}
+Service: The part of the web service used by clients to provide search and retrieval as well as account, device, and user management.
+=> {:title => 'Service', :definition => 'The part of the web service used by clients to provide search and retrieval as well as account, device, and user management.'}

data/test/cases/story.txt

@@ -0,0 +1,4 @@
+As a developer I would like to have created database indexes so that the queries run as fast as possible.
+=> {:description => 'As a developer I would like to have created database indexes so that the queries run as fast as possible.'}
+As a recorder I would like to use TLS (SSL) so that my connection with the storage API is secure and I can be sure of the API’s identity. - #4 todo
+=> {:description => 'As a recorder I would like to use TLS (SSL) so that my connection with the storage API is secure and I can be sure of the API’s identity.', :id => 4, :status => 'todo' }

data/test/cases/story_attributes.txt

@@ -0,0 +1,10 @@
+
+=> {}
+
+=> {}
+#4
+=> {:id => 4}
+#12 todo
+=> {:id => 12, :status => 'todo'}
+ #3  partially  done
+=> {:id => 3, :status => 'partially done'}

data/test/saga_document_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe "A Document" do
+  it "responds to accessors" do
+    document = Saga::Document.new
+    [:title, :introduction, :authors, :stories, :definitions].each do |method|
+      document.should.respond_to(method)
+    end
+  end
+end

data/test/saga_formatter_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe "Formatter" do
+  before do
+    @document = Saga::Document.new
+    @document.title = 'Requirements API'
+  end
+  
+  it "formats a saga document to HTML" do
+    html = Saga::Formatter.format(@document)
+    html.should.include('<h1>Requirements <br />Requirements API</h1>')
+  end
+end

data/test/saga_parser_spec.rb

@@ -0,0 +1,112 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module ParserHelper
+  def parser
+    @parser ||= Saga::Parser.new
+  end
+  
+  def parse(input)
+    Saga::Parser.parse(input)
+  end
+  
+  def parse_title
+    parser.parse("Requirements API\n\n")
+  end
+  
+  def parse_introduction
+    parser.parse("This document describes our API.\n\n")
+  end
+  
+  def parse_story_marker
+    parser.parse('USER STORIES')
+  end
+  
+  def parse_header
+    parser.parse('Storage')
+  end
+  
+  def parse_story
+    parser.parse('As a recorder I would like to add a recording so that it becomes available. - #1 todo')
+  end
+  
+  def parse_definition
+    parser.parse('Other: Stories that don’t fit anywhere else.')
+  end
+end
+
+describe "Parser" do
+  it "should initialize and parse" do
+    document = Saga::Parser.parse('')
+    document.should.be.kind_of?(Saga::Document)
+  end
+end
+
+describe "A Parser, concerning the handling of input" do
+  extend ParserHelper
+  before { @parser = nil }
+  
+  it "interprets the first line of the document as a title" do
+    document = parse('Requirements API')
+    document.title.should == 'API'
+    
+    document = parse('Record and Search')
+    document.title.should == 'Record and Search'
+  end
+  
+  it "interprets authors" do
+    document = parse('- Manfred Stienstra')
+    document.authors.map { |author| author[:name] }.should == ['Manfred Stienstra']
+  end
+  
+  it "interprets the introduction" do
+    parse_title
+    parse_introduction
+    parser.document.introduction.should == ['This document describes our API.']
+  end
+  
+  it "interprets stories without a header as being a gobal story" do
+    parse_title
+    parse_introduction
+    parse_story_marker
+    parse_story
+    
+    parser.document.stories.keys.should == ['']
+    parser.document.stories[''].length.should == 1
+    parser.document.stories[''].first[:id].should == 1
+  end
+  
+  it "interprets stories with a header as being part of that section" do
+    parse_title
+    parse_introduction
+    parse_story_marker
+    parse_header
+    parse_story
+    
+    parser.document.stories.keys.should == ['Storage']
+    parser.document.stories['Storage'].length.should == 1
+    parser.document.stories['Storage'].first[:id].should == 1
+  end
+  
+  it "interprets definitions without a header as being a gobal definition" do
+    parse_title
+    parse_introduction
+    parse_story_marker
+    parse_definition
+    
+    parser.document.definitions.keys.should == ['']
+    parser.document.definitions[''].length.should == 1
+    parser.document.definitions[''].first[:title].should == 'Other'
+  end
+  
+  it "interprets definitions with a header as being part of that section" do
+    parse_title
+    parse_introduction
+    parse_story_marker
+    parse_header
+    parse_definition
+    
+    parser.document.definitions.keys.should == ['Storage']
+    parser.document.definitions['Storage'].length.should == 1
+    parser.document.definitions['Storage'].first[:title].should == 'Other'
+  end
+end

data/test/saga_runner_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe "A Runner" do
+  it "should show a help text when invoked without a command and options" do
+    @runner = Saga::Runner.new([])
+    @runner.expects(:puts).with(@runner.parser.to_s)
+    @runner.run
+  end
+  
+  it "should show a help test when the -h option is used" do
+    @runner = Saga::Runner.new(%w(-h))
+    @runner.expects(:puts).at_least(1)
+    @runner.stubs(:exit)
+    @runner.run
+  end
+end

data/test/saga_tokenizer_spec.rb

@@ -0,0 +1,105 @@
+require File.expand_path('../spec_helper', __FILE__)
+ 
+module CasesHelper
+  def _parse_expected(line)
+    eval(line[3..-1])
+  end
+  
+  def each_case(path)
+    filename = File.expand_path("../cases/#{path}.txt", __FILE__)
+    input = nil
+    File.readlines(filename).each do |line|
+      if input.nil?
+        input = line.strip
+      else
+        yield input, _parse_expected(line)
+        input = nil
+      end
+    end
+  end
+end
+
+describe "Tokenizer" do
+  extend CasesHelper
+  
+  it "tokenizes story attributes input" do
+    each_case('story_attributes') do |input, expected|
+      Saga::Tokenizer.tokenize_story_attributes(input).should == expected
+    end
+  end
+  
+  it "tokenizes story input" do
+    each_case('story') do |input, expected|
+      Saga::Tokenizer.tokenize_story(input).should == expected
+    end
+  end
+  
+  it "tokenizes definition input" do
+    each_case('definition') do |input, expected|
+      Saga::Tokenizer.tokenize_definition(input).should == expected
+    end
+  end
+  
+  it "tokenizes author input" do
+    each_case('author') do |input, expected|
+      Saga::Tokenizer.tokenize_author(input).should == expected
+    end
+  end
+end
+
+describe "A Tokenizer" do
+  before do
+    @parser    = stub('Parser')
+    @tokenizer = Saga::Tokenizer.new(@parser)
+  end
+  
+  it "sends a tokenized story to the parser" do
+    line = 'As a recorder I would like to use TLS (SSL) so that my connection with the storage API is secure and I can be sure of the API’s identity. - #4 todo'
+    story = Saga::Tokenizer.tokenize_story(line)
+    
+    @parser.expects(:handle_story).with(story)
+    @tokenizer.process_line(line)
+  end
+  
+  it "sends a tokenized author to the parser" do
+    line = '- Manfred Stienstra, manfred@fngtps.com'
+    author = Saga::Tokenizer.tokenize_author(line)
+    
+    @parser.expects(:handle_author).with(author)
+    @tokenizer.process_line(line)
+  end
+  
+  it "sends a tokenized definition to the parser" do
+    line = 'Author: Someone who writes'
+    definition = Saga::Tokenizer.tokenize_definition(line)
+    
+    @parser.expects(:handle_definition).with(definition)
+    @tokenizer.process_line(line)
+  end
+  
+  it "send a tokenize defintion to the parser (slighly more complex)" do
+    line = 'Search and retrieval: Stories related to selecting and retrieving recordings.'
+    definition = Saga::Tokenizer.tokenize_definition(line)
+    
+    @parser.expects(:handle_definition).with(definition)
+    @tokenizer.process_line(line)
+  end
+  
+  it "forwards plain strings to the parser" do
+    [
+      'Requirements User Application',
+      'USER STORIES',
+      ''
+    ].each do |line|
+      @parser.expects(:handle_string).with(line)
+      @tokenizer.process_line(line)
+    end
+  end
+  
+  it "processes lines from the input" do
+    input = File.read(File.expand_path("../cases/story.txt", __FILE__))
+    count = input.split("\n").length
+    @tokenizer.expects(:process_line).times(count)
+    @tokenizer.process(input)
+  end
+end

data/test/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+require 'mocha-on-bacon'
+
+Bacon.extend Bacon::TapOutput
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'saga'

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: saga
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Manfred Stienstra
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-31 00:00:00 +02:00
+default_executable: saga
+dependencies: []
+
+description: Saga is a tool to convert stories syntax to a nicely formatted document.
+email: manfred@fngtps.com
+executables: 
+- saga
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- .kick
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/saga
+- lib/saga.rb
+- lib/saga/document.rb
+- lib/saga/formatter.rb
+- lib/saga/parser.rb
+- lib/saga/runner.rb
+- lib/saga/tokenizer.rb
+- templates/default/document.erb
+- templates/default/helpers.rb
+- test/cases/author.txt
+- test/cases/definition.txt
+- test/cases/story.txt
+- test/cases/story_attributes.txt
+- test/saga_document_spec.rb
+- test/saga_formatter_spec.rb
+- test/saga_parser_spec.rb
+- test/saga_runner_spec.rb
+- test/saga_tokenizer_spec.rb
+- test/spec_helper.rb
+has_rdoc: true
+homepage: http://fingertips.github.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: Saga is a tool to convert stories syntax to a nicely formatted document.
+test_files: 
+- test/saga_document_spec.rb
+- test/saga_formatter_spec.rb
+- test/saga_parser_spec.rb
+- test/saga_runner_spec.rb
+- test/saga_tokenizer_spec.rb
+- test/spec_helper.rb