erudite 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MmMyNDJiNGZhYjc3YmY5NDJmNjA1ZWY2OWZmNDRkMDdiYjAwMzA0MQ==
+  data.tar.gz: !binary |-
+    NjA3YjdkZWY3OTVjMDM2OTI2NTUzZWU2YzRhNTViMjI5NmE4NjkxOQ==
+SHA512:
+  metadata.gz: !binary |-
+    NjllZjIyNjdkMWE2YjQwNGJmNmUxZTQyYTA5ODFhNmI5OGIxYTllYTU4NDNh
+    OWM5M2Y2N2ZhMWM0YzIxNzI4NzdjOTI3MTQ0YTFlNjdlNzU2ZjhhMjNmZDE4
+    ZDhhMWU1NTc5NzUwY2Q0ZWIxYzVmNDEzZjQzOGE1OWMxNzY4OTU=
+  data.tar.gz: !binary |-
+    MThjNzM2YTllMTY2NzBkNGY4ZjYwZTRmODljMGE1YTkzOGNmYmMzYzQzMDg4
+    N2Y1YzIwY2I4Y2JiMmJmNGVmMTBiMWQwMTY4YjIzZDcxMzk5NmJmZWQ4ZDFh
+    YjhlMGMyOTBmMjVkOTYyYzZkZTI3YTY1NWU1MDI4YzRlMGY2NzY=

data/CHANGELOG.md

@@ -0,0 +1 @@
+# Changelog

data/CONTRIBUTING.md

@@ -0,0 +1,7 @@
+# Contributing
+
+1. **Fork** the repository.
+2. Create a **branch** for your feature (`git checkout -b feature`).
+3. **Commit** your changes (`git commit -a -m 'Feature'`).
+4. **Push** to your branch (`git push origin feature`).
+5. Create a **pull request**.

data/LICENSE.md

@@ -0,0 +1,18 @@
+Copyright (c) 2014 Taylor Fausak <taylor@fausak.me>
+
+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.md

@@ -0,0 +1,53 @@
+# [Erudite][1]
+
+Executable documentation.
+
+``` rb
+examples = Erudite::Parser.parse(<<-'RUBY')
+>> 1 + 2
+=> 3
+
+>> Object.new
+=> #<Object:0x...>
+
+>> gets
+=> nil
+
+>> puts 'hello world'
+hello world
+=> nil
+
+>> warn 'oh noes'
+oh noes
+=> nil
+
+>> fail 'catastrophe!'
+RuntimeError: catastrophe!
+
+>> puts 'chunky
+.. bacon'
+chunky
+bacon
+=> nil
+
+>> def double(n)
+..   2 * n
+.. end
+>> double(3)
+=> 6
+RUBY
+
+examples.each do |example|
+  if example.pass?
+    puts 'PASS'
+  else
+    puts 'FAIL'
+    puts " expected : #{example.expected.result.inspect}"
+    puts "          : #{example.expected.output.inspect}"
+    puts " actual   : #{example.actual.result.inspect}"
+    puts "          : #{example.actual.output.inspect}"
+  end
+end
+```
+
+[1]: https://github.com/tfausak/erudite

data/lib/erudite.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+
+require 'erudite/example'
+require 'erudite/outcome'
+require 'erudite/parser'
+
+# Executable documentation.
+module Erudite
+end

data/lib/erudite/example.rb

@@ -0,0 +1,79 @@
+# coding: utf-8
+
+require 'stringio'
+
+module Erudite
+  # Code to be run and compared against its expected outcome.
+  class Example
+    attr_reader :source
+    attr_reader :expected
+    attr_writer :binding
+
+    def initialize(source, result = nil, output = nil)
+      @source = source
+      @expected = Outcome.new(result, output)
+    end
+
+    def binding
+      @binding ||= TOPLEVEL_BINDING.dup
+    end
+
+    def run!
+      binding.eval(source, __FILE__, __LINE__)
+    end
+
+    def run
+      [run!, nil]
+    rescue Exception => exception # rubocop:disable Lint/RescueException
+      [nil, exception]
+    end
+
+    def self.without_stdio
+      stdin, stdout, stderr = $stdin, $stdout, $stderr
+      $stdin = $stdout = $stderr = io = StringIO.new
+      [yield, io]
+    ensure
+      $stdin, $stdout, $stderr = stdin, stdout, stderr
+    end
+
+    def self.format_exception(exception)
+      "#{exception.class.name}: #{exception.message}"
+    end
+
+    def actual
+      return @actual if defined?(@actual)
+
+      result, io = self.class.without_stdio do
+        result, exception = run
+        warn(self.class.format_exception(exception)) if exception
+        result.inspect
+      end
+
+      @actual = Outcome.new(result, io.string)
+    end
+
+    def self.pattern(string)
+      Regexp.new(Regexp.escape(string).gsub('\.\.\.', '.*?'))
+    end
+
+    def valid_result?
+      return true unless expected.result
+      self.class.pattern(expected.result).match(actual.result)
+    end
+
+    def valid_output?
+      return true unless expected.output
+      self.class.pattern(expected.output).match(actual.output)
+    end
+
+    def pass?
+      actual
+      valid_result? && valid_output?
+    end
+
+    def ==(other)
+      source == other.source &&
+        expected == other.expected
+    end
+  end
+end

data/lib/erudite/outcome.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+
+module Erudite
+  # Information about an expected or actual outcome.
+  class Outcome
+    attr_reader :result
+    attr_reader :output
+
+    def initialize(result, output)
+      @result = result
+      @output = output
+    end
+
+    def ==(other)
+      result == other.result &&
+        output == other.output
+    end
+  end
+end

data/lib/erudite/parser.rb

@@ -0,0 +1,54 @@
+# coding: utf-8
+
+module Erudite
+  # Parses IRB output into examples.
+  class Parser
+    def self.parse(string)
+      group(string).map { |lines| exemplify(lines) }
+    end
+
+    def self.group(string)
+      buffer = []
+
+      groups = string.each_line.each_with_object([]) do |line, array|
+        if line.start_with?('>> ') && !buffer.empty?
+          array.push(buffer)
+          buffer = []
+        end
+
+        buffer.push(line)
+      end
+
+      buffer.empty? ? groups : groups.push(buffer)
+    end
+
+    def self.exemplify(lines)
+      source = extract_source(lines)
+      result = extract_result(lines)
+      output = extract_output(lines)
+
+      Example.new(source, result, output)
+    end
+
+    def self.extract_source(lines)
+      source = lines
+        .select { |line| line.start_with?('>> ', '.. ') }
+        .map { |line| line[3..-1].chomp }
+      source.join("\n") unless source.empty?
+    end
+
+    def self.extract_result(lines)
+      result = lines
+        .select { |line| line.start_with?('=> ') }
+        .map { |line| line[3..-1].chomp }
+      result.join("\n") unless result.empty?
+    end
+
+    def self.extract_output(lines)
+      output = lines
+        .reject { |line| line.start_with?('>> ', '.. ', '=> ') }
+        .map { |line| line.chomp }
+      output.join("\n") unless output.empty?
+    end
+  end
+end

data/spec/erudite/example_spec.rb

@@ -0,0 +1,352 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Erudite::Example do
+  it 'requires some source' do
+    expect { described_class.new }.to raise_error(ArgumentError)
+  end
+
+  it 'can be initialized' do
+    expect(described_class.new(nil)).to be_a(described_class)
+  end
+
+  it 'sets the source' do
+    source = double
+    example = described_class.new(source)
+    expect(example.source).to eql(source)
+  end
+
+  it 'uses the default expected outcome' do
+    example = described_class.new(nil)
+    expect(example.expected).to be_an(Erudite::Outcome)
+    expect(example.expected.result).to be(nil)
+    expect(example.expected.output).to be(nil)
+  end
+
+  it 'sets the expected result' do
+    result = double
+    example = described_class.new(nil, result)
+    expect(example.expected.result).to eql(result)
+  end
+
+  it 'sets the expected output' do
+    output = double
+    example = described_class.new(nil, nil, output)
+    expect(example.expected.output).to eql(output)
+  end
+
+  describe '#binding' do
+    it 'uses the default binding' do
+      example = described_class.new(nil)
+      expect(example.binding).to be_a(Binding)
+      expect(example.binding.eval('self')).to be(TOPLEVEL_BINDING.eval('self'))
+      expect(example.binding).to_not be(TOPLEVEL_BINDING)
+    end
+
+    it 'memoizes the binding' do
+      example = described_class.new(nil)
+      binding = example.binding
+      expect(example.binding).to be(binding)
+    end
+
+    it 'sets the binding' do
+      example = described_class.new(nil)
+      binding = TOPLEVEL_BINDING.dup
+      example.binding = binding
+      expect(example.binding).to be(binding)
+    end
+  end
+
+  describe '#run!' do
+    it 'evaluates the source' do
+      source = ':something'
+      example = described_class.new(source)
+      expect(example.run!).to eql(TOPLEVEL_BINDING.eval(source))
+    end
+
+    it 'evaluates the source in the binding' do
+      source = 'variable'
+      example = described_class.new(source)
+      example.binding.eval('variable = :something')
+      expect(example.run!).to eql(example.binding.eval(source))
+    end
+
+    it 'sets the file name' do
+      example = described_class.new('fail')
+      begin
+        example.run!
+      rescue => error
+        expect(error.backtrace.first).to_not start_with('<main>:')
+      end
+    end
+
+    it 'sets the line number' do
+      example = described_class.new('fail')
+      begin
+        example.run!
+      rescue => error
+        expect(error.backtrace.first).to_not end_with(":1:in `<main>'")
+      end
+    end
+  end
+
+  describe '#run' do
+    it 'returns the result' do
+      source = ':something'
+      example = described_class.new(source)
+      expect(example.run.first).to eql(TOPLEVEL_BINDING.eval(source))
+      expect(example.run.last).to be(nil)
+    end
+
+    it 'returns the exception' do
+      source = 'fail'
+      example = described_class.new(source)
+      expect(example.run.first).to be(nil)
+      expect(example.run.last).to be_a(StandardError)
+    end
+  end
+
+  describe '.without_stdio' do
+    it 'requires a block' do
+      expect { described_class.without_stdio }.to raise_error(LocalJumpError)
+    end
+
+    it 'calls the block' do
+      result = double
+      expect(described_class.without_stdio { result }.first).to eql(result)
+    end
+
+    it 'redirects STDIN' do
+      stdin = $stdin
+      expect(described_class.without_stdio { $stdin }).to_not eq(stdin)
+    end
+
+    it 'redirects STDOUT' do
+      stdout = $stdout
+      expect(described_class.without_stdio { $stdout }).to_not eq(stdout)
+    end
+
+    it 'redirects STDERR' do
+      stderr = $stderr
+      expect(described_class.without_stdio { $stderr }).to_not eq(stderr)
+    end
+
+    it 'reconnects STDIN' do
+      stdin = $stdin
+      begin
+        described_class.without_stdio { fail }
+      rescue
+        nil
+      end
+      expect($stdin).to eq(stdin)
+    end
+
+    it 'reconnects STDOUT' do
+      stdout = $stdout
+      begin
+        described_class.without_stdio { fail }
+      rescue
+        nil
+      end
+      expect($stdout).to eq(stdout)
+    end
+
+    it 'reconnects STDERR' do
+      stderr = $stderr
+      begin
+        described_class.without_stdio { fail }
+      rescue
+        nil
+      end
+      expect($stderr).to eq(stderr)
+    end
+
+    it 'returns the redirected IO' do
+      expect(described_class.without_stdio {}.last).to be_a(StringIO)
+    end
+
+    it 'handles STDIN' do
+      result, _ = described_class.without_stdio { gets }
+      expect(result).to be(nil)
+    end
+
+    it 'handles STDOUT' do
+      _, io = described_class.without_stdio { puts 'something' }
+      expect(io.string).to eql("something\n")
+    end
+
+    it 'handles STDERR' do
+      _, io = described_class.without_stdio { warn 'something' }
+      expect(io.string).to eql("something\n")
+    end
+  end
+
+  describe '.format_exception' do
+    it 'formats the exception' do
+      exception = StandardError.new('something')
+      expect(described_class.format_exception(exception))
+        .to eql("#{exception.class.name}: #{exception.message}")
+    end
+  end
+
+  describe '#actual' do
+    it 'sets the result' do
+      example = described_class.new('"something"')
+      expect(example.actual.result).to eql('"something"')
+      expect(example.actual.output).to eql('')
+    end
+
+    it 'handles STDIN' do
+      example = described_class.new('gets')
+      expect(example.actual.result).to eql('nil')
+      expect(example.actual.output).to eql('')
+    end
+
+    it 'handles STDOUT' do
+      example = described_class.new('puts "something"')
+      expect(example.actual.result).to eql('nil')
+      expect(example.actual.output).to eql("something\n")
+    end
+
+    it 'handles STDERR' do
+      example = described_class.new('warn "something"')
+      expect(example.actual.result).to eql('nil')
+      expect(example.actual.output).to eql("something\n")
+    end
+
+    it 'handles exceptions' do
+      example = described_class.new('fail StandardError, "something"')
+      expect(example.actual.result).to eql('nil')
+      expect(example.actual.output).to eql("StandardError: something\n")
+    end
+
+    it 'memoizes the result' do
+      example = described_class.new('')
+      actual = example.actual
+      expect(example.actual).to be(actual)
+    end
+  end
+
+  describe '.pattern' do
+    it 'returns a Regexp' do
+      pattern = described_class.pattern('something')
+      expect(pattern).to be_a(Regexp)
+    end
+
+    it 'escapes meta characters' do
+      pattern = described_class.pattern('some.thing')
+      expect(pattern).to eql(/some\.thing/)
+    end
+
+    it 'replaces "..."' do
+      pattern = described_class.pattern('some...thing')
+      expect(pattern).to eql(/some.*?thing/)
+    end
+  end
+
+  describe '#valid_result?' do
+    it 'returns true without an expected result' do
+      example = described_class.new(nil, nil)
+      expect(example).to be_valid_result
+    end
+
+    it 'returns true when the results match' do
+      example = described_class.new('"something"', '"something"')
+      expect(example).to be_valid_result
+    end
+
+    it "returns false when the results don't match" do
+      example = described_class.new('"something"', '"something else"')
+      expect(example).to_not be_valid_result
+    end
+
+    it 'allows wildcards' do
+      example = described_class.new('Object.new', '#<Object:0x...>')
+      expect(example).to be_valid_result
+    end
+  end
+
+  describe '#valid_output?' do
+    it 'returns true without expected output' do
+      example = described_class.new(nil, nil)
+      expect(example).to be_valid_output
+    end
+
+    it 'returns true when the output matches' do
+      example = described_class.new('puts "something"', nil, 'something')
+      expect(example).to be_valid_output
+    end
+
+    it "returns false when the output doesn't match" do
+      example = described_class.new('puts "something"', nil, 'something else')
+      expect(example).to_not be_valid_output
+    end
+
+    it 'allows wildcards' do
+      example = described_class.new('puts Object.new', nil, '#<Object:0x...>')
+      expect(example).to be_valid_output
+    end
+  end
+
+  describe '#pass?' do
+    it 'realizes the actual outcome' do
+      example = described_class.new('x = 1')
+      example.pass?
+      expect(example.binding.eval('x')).to eql(1)
+    end
+
+    it 'returns true if both the result and output match' do
+      example = described_class
+        .new('p "something"', '"something"', '"something"')
+      expect(example).to be_pass
+    end
+
+    it "returns false if the result doesn't match" do
+      example = described_class
+        .new('p "something"', '"something else"', '"something"')
+      expect(example).to_not be_pass
+    end
+
+    it "returns false if the output doesn't match" do
+      example = described_class
+        .new('p "something"', '"something"', '"something else"')
+      expect(example).to_not be_pass
+    end
+  end
+
+  describe '#==' do
+    it 'returns true when they have the same source, result, and output' do
+      source = 'x'
+      result = 'y'
+      output = 'z'
+      a = described_class.new(source, result, output)
+      b = described_class.new(source, result, output)
+      expect(a).to eq(b)
+    end
+
+    it "returns false when they don't have the same source" do
+      result = 'y'
+      output = 'z'
+      a = described_class.new('a', result, output)
+      b = described_class.new('b', result, output)
+      expect(a).to_not eq(b)
+    end
+
+    it "returns false when they don't have the same result" do
+      source = 'x'
+      output = 'z'
+      a = described_class.new(source, 'a', output)
+      b = described_class.new(source, 'b', output)
+      expect(a).to_not eq(b)
+    end
+
+    it "returns false when they don't have the same output" do
+      source = 'x'
+      result = 'y'
+      a = described_class.new(source, result, 'a')
+      b = described_class.new(source, result, 'b')
+      expect(a).to_not eq(b)
+    end
+  end
+end

data/spec/erudite/outcome_spec.rb

@@ -0,0 +1,53 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Erudite::Outcome do
+  it 'requires a result' do
+    expect { described_class.new }.to raise_error(ArgumentError)
+  end
+
+  it 'requires some output' do
+    expect { described_class.new(nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'can be initialized' do
+    expect(described_class.new(nil, nil)).to be_a(described_class)
+  end
+
+  it 'sets the result' do
+    result = double
+    outcome = described_class.new(result, nil)
+    expect(outcome.result).to eql(result)
+  end
+
+  it 'sets the output' do
+    output = double
+    outcome = described_class.new(nil, output)
+    expect(outcome.output).to eql(output)
+  end
+
+  describe '#==' do
+    it 'returns true if they have the same result and output' do
+      result = 'some'
+      output = 'thing'
+      a = described_class.new(result, output)
+      b = described_class.new(result, output)
+      expect(a).to eq(b)
+    end
+
+    it "returns false if they don't have the same result" do
+      output = 'something'
+      a = described_class.new('a', output)
+      b = described_class.new('b', output)
+      expect(a).to_not eq(b)
+    end
+
+    it "returns false if they don't have the same output" do
+      result = 'something'
+      a = described_class.new(result, 'a')
+      b = described_class.new(result, 'b')
+      expect(a).to_not eq(b)
+    end
+  end
+end

data/spec/erudite/parser_spec.rb

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+# Monkey patch String to add ability to strip leading whitespace.
+class String
+  def dedent
+    gsub(/^#{self[/\A\s*/]}/, '')
+  end
+end
+
+describe Erudite::Parser do
+  describe '.parse' do
+    it 'parses an example without output or a result' do
+      examples = described_class.parse(<<-'RUBY'.dedent)
+        >> :something
+      RUBY
+      expect(examples).to eq([
+        Erudite::Example.new(':something')])
+    end
+
+    it 'parses an example with a result' do
+      examples = described_class.parse(<<-'RUBY'.dedent)
+        >> :something
+        => :something
+      RUBY
+      expect(examples).to eq([
+        Erudite::Example.new(':something', ':something')])
+    end
+
+    it 'parses an example with output' do
+      examples = described_class.parse(<<-'RUBY'.dedent)
+        >> puts :something
+        something
+      RUBY
+      expect(examples).to eq([
+        Erudite::Example.new('puts :something', nil, 'something')])
+    end
+
+    it 'handles STDIN' do
+      examples = described_class.parse(<<-'RUBY'.dedent)
+        >> gets
+        => nil
+      RUBY
+      expect(examples).to eq([
+        Erudite::Example.new('gets', 'nil')])
+    end
+
+    it 'handles STDOUT' do
+      examples = described_class.parse(<<-'RUBY'.dedent)
+        >> puts :something
+        something
+        => nil
+      RUBY
+      expect(examples).to eq([
+        Erudite::Example.new('puts :something', 'nil', 'something')])
+    end
+
+    it 'handles STDERR' do
+      examples = described_class.parse(<<-'RUBY'.dedent)
+        >> warn :something
+        something
+        => nil
+      RUBY
+      expect(examples).to eq([
+        Erudite::Example.new('warn :something', 'nil', 'something')])
+    end
+
+    it 'handles exceptions' do
+      examples = described_class.parse(<<-'RUBY'.dedent)
+        >> fail 'something'
+        RuntimeError: something
+      RUBY
+      expect(examples).to eq([
+        Erudite::Example.new(
+          "fail 'something'", nil, 'RuntimeError: something')])
+    end
+
+    it 'handles multi-line source and output' do
+      examples = described_class.parse(<<-'RUBY'.dedent)
+        >> puts 'some
+        .. thing'
+        some
+        thing
+        => nil
+      RUBY
+      expect(examples).to eq([
+        Erudite::Example.new("puts 'some\nthing'", 'nil', "some\nthing")])
+    end
+
+    it 'handles multiple examples' do
+      examples = described_class.parse(<<-'RUBY'.dedent)
+        >> def some
+        ..   :thing
+        .. end
+        >> some
+        => :thing
+      RUBY
+      expect(examples).to eq([
+        Erudite::Example.new("def some\n  :thing\nend"),
+        Erudite::Example.new('some', ':thing')])
+    end
+  end
+end

data/spec/erudite_spec.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Erudite do
+  pending
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+# coding: utf-8
+
+require 'erudite'

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: erudite
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Taylor Fausak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.25.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.25.0
+description: Executable documentation.
+email: taylor@fausak.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE.md
+- README.md
+- lib/erudite.rb
+- lib/erudite/example.rb
+- lib/erudite/outcome.rb
+- lib/erudite/parser.rb
+- spec/erudite/example_spec.rb
+- spec/erudite/outcome_spec.rb
+- spec/erudite/parser_spec.rb
+- spec/erudite_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/tfausak/erudite
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: Executable documentation.
+test_files:
+- spec/erudite/example_spec.rb
+- spec/erudite/outcome_spec.rb
+- spec/erudite/parser_spec.rb
+- spec/erudite_spec.rb
+- spec/spec_helper.rb