erudite 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2dcd8553e0a52b455a6437a4fc7f339e744bc4cf
-  data.tar.gz: 0bf967f16cc6422116ba59cbbb263b1753c90c8e
+  metadata.gz: 31047c1a7d1cd92aa0092499808bde1d5793b03a
+  data.tar.gz: 9f3256675420eb9c01542654f589bff00a014a95
 SHA512:
-  metadata.gz: 38b880bc0c05e713911ce85df61a43082db3446cd8a63093b0c85a338eb46aa4190590712b76d7136f924de874a610293e88a21812897b3dbb4d5d566e98f2cf
-  data.tar.gz: 79c25e231334d1d254f7f88fcb8803ed9273ca150d745babe1876cb3d0e3e8009fb65cf187840bcc759844b41b7d2968c2bd790d2f3e01bab09fc8a97277642c
+  metadata.gz: 8310d570566c1050ebbc4772f0e907af356a0e64b1c337c6398c429762d5dded513dcef4e36553ca6fb85438f265f0e6e84d83129aadb697eabab540cb3b67dc
+  data.tar.gz: 469d662e4a0673af98195ef52ca91ffd38831e857bf945df34e18e8bb71b6cb31b7dfb686dc1c8b14a6848428daf96dd432d151d7d6d483fca9146f99dd57b58

data/CHANGELOG.md

@@ -1,9 +1,23 @@
 # Changelog
 
+This project uses [Semantic Versioning][1].
+
+## v0.3.0 (2015-01-26)
+
+- Modified the executable to read Ruby files instead of IRB files.
+- Added a class for extracting comments from Ruby source code (#5).
+- Added the ability to refer to variables defined in earlier examples (#3).
+
 ## v0.2.0 (2014-09-18)
 
-- Create an executable.
+- Created an executable.
 
 ## v0.1.0 (2014-08-24)
 
-- Initial release.
+- Initially released.
+
+## v0.0.0 (2014-08-23)
+
+- Initially created.
+
+[1]: http://semver.org/spec/v2.0.0.html

data/LICENSE.md

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

data/README.md

@@ -16,59 +16,43 @@ Executable documentation.
 Add it to your Gemfile:
 
 ``` rb
-gem 'erudite', '~> 0.2.0'
+gem 'erudite', '~> 0.3.0'
 ```
 
 Or install it manually:
 
 ``` sh
-$ gem install erudite --version 0.2.0
+$ gem install erudite --version '~> 0.3.0'
 ```
 
-This project uses [Semantic Versioning][12].
-
 ## Usage
 
-``` irb
-# example.irb
->> 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
+``` rb
+# example.rb
+
+# >> x = 1
+# => 1
+# >> x + 1
+# => 2
+
+# >> x = 2
+# => 2
+#
+# x + 1
+# => 3
+
+# >> x
+# NameError: ...
+
+# >> f(3)
+# => 9
+def f(x)
+  x**2
+end
 ```
 
 ``` sh
-$ erudite example.irb
-- PASS
-- PASS
-- PASS
+$ erudite example.rb
 - PASS
 - PASS
 - PASS
@@ -78,14 +62,13 @@ $ erudite example.irb
 ```
 
 [1]: https://github.com/tfausak/erudite
-[2]: https://badge.fury.io/rb/erudite.svg
+[2]: https://img.shields.io/gem/v/erudite.svg?style=flat
 [3]: http://rubygems.org/gems/erudite
-[4]: https://travis-ci.org/tfausak/erudite.svg
+[4]: https://img.shields.io/travis/tfausak/erudite/master.svg?style=flat
 [5]: https://travis-ci.org/tfausak/erudite
-[6]: https://img.shields.io/coveralls/tfausak/erudite.svg
+[6]: https://img.shields.io/coveralls/tfausak/erudite/master.svg?style=flat
 [7]: https://coveralls.io/r/tfausak/erudite
-[8]: https://codeclimate.com/github/tfausak/erudite/badges/gpa.svg
+[8]: https://img.shields.io/codeclimate/github/tfausak/erudite.svg?style=flat
 [9]: https://codeclimate.com/github/tfausak/erudite
-[10]: https://gemnasium.com/tfausak/erudite.svg
+[10]: https://img.shields.io/gemnasium/tfausak/erudite.svg?style=flat
 [11]: https://gemnasium.com/tfausak/erudite
-[12]: http://semver.org/spec/v2.0.0.html

data/lib/erudite.rb

@@ -1,10 +1,12 @@
 # coding: utf-8
 
-require 'erudite/example'
-require 'erudite/executable'
-require 'erudite/outcome'
-require 'erudite/parser'
-
 # Executable documentation.
 module Erudite
 end
+
+require 'erudite/example'
+require 'erudite/example/outcome'
+require 'erudite/example/parser'
+require 'erudite/executable'
+require 'erudite/extractor'
+require 'erudite/version'

data/lib/erudite/example/outcome.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+
+module Erudite
+  class Example
+    # 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
+end

data/lib/erudite/example/parser.rb

@@ -0,0 +1,56 @@
+# coding: utf-8
+
+module Erudite
+  class Example
+    # 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(&:chomp)
+        output.join("\n") unless output.empty?
+      end
+    end
+  end
+end

data/lib/erudite/executable.rb

@@ -4,7 +4,17 @@ module Erudite
   # Parses, runs, and outputs examples.
   class Executable
     def self.run(io)
-      Parser.parse(io).each { |example| puts format_example(example) }
+      source = io.read
+
+      Extractor.extract(source).each do |group|
+        binding = TOPLEVEL_BINDING.dup
+        binding.eval(source)
+
+        group.each do |example|
+          example.binding = binding
+          puts format_example(example)
+        end
+      end
     end
 
     def self.format_example(example)
@@ -20,7 +30,7 @@ module Erudite
     end
 
     def self.format_failing_example(example)
-      <<-TXT
+      <<-"TEXT"
 - FAIL
   Source: #{example.source}
   Expected:
@@ -29,7 +39,7 @@ module Erudite
   Actual:
     Output: #{example.actual.output.inspect}
     Result: #{example.actual.result.inspect}
-      TXT
+      TEXT
     end
   end
 end

data/lib/erudite/extractor.rb

@@ -0,0 +1,65 @@
+# coding: utf-8
+
+require 'parser/current'
+
+module Erudite
+  # Extracts examples from comments.
+  class Extractor
+    def self.extract(source)
+      group_comments(parse_comments(source))
+        .map { |group| group.flat_map { |comment| extract_text(comment) } }
+        .map { |text| find_examples(group_text(text)).join("\n") }
+        .reject(&:empty?)
+        .map { |example| Example::Parser.parse(example) }
+    end
+
+    def self.find_examples(groups)
+      groups
+        .reject(&:empty?)
+        .each_with_object([]) do |lines, examples|
+          lines.first.match(/^(\s*)>> /) do |match|
+            if lines.all? { |line| line.start_with?(match[1]) }
+              examples.push(lines.map { |line| line[match[1].size..-1] })
+            end
+          end
+        end
+    end
+
+    def self.group_text(lines)
+      lines.each_with_object([[]]) do |line, groups|
+        if line[/^\s*$/]
+          groups.push([])
+        else
+          groups.last.push(line.chomp)
+        end
+      end
+    end
+
+    def self.extract_text(comment)
+      if comment.inline?
+        [comment.text[1..-1]]
+      else
+        comment.text[7..-6].lines.map(&:chomp)
+      end
+    end
+
+    def self.group_comments(comments)
+      previous = comments.first
+
+      comments.each_with_object([]) do |comment, groups|
+        groups.push([]) unless groupable?(previous, comment)
+        groups.last.push(comment)
+        previous = comment
+      end
+    end
+
+    def self.groupable?(a, b)
+      a.loc.line == b.loc.line - 1 &&
+        a.loc.column == b.loc.column
+    end
+
+    def self.parse_comments(source)
+      Parser::CurrentRuby.parse_with_comments(source).last
+    end
+  end
+end

data/lib/erudite/version.rb

@@ -0,0 +1,5 @@
+# coding: utf-8
+
+module Erudite # rubocop:disable Style/Documentation
+  VERSION = Gem::Version.new('0.3.0')
+end

data/spec/erudite/{outcome_spec.rb → example/outcome_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Erudite::Outcome do
+describe Erudite::Example::Outcome do
   it 'requires a result' do
     expect { described_class.new }.to raise_error(ArgumentError)
   end

data/spec/erudite/{parser_spec.rb → example/parser_spec.rb}

@@ -2,14 +2,7 @@
 
 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 Erudite::Example::Parser do
   describe '.parse' do
     it 'parses an example without output or a result' do
       examples = described_class.parse(<<-'RUBY'.dedent)

data/spec/erudite/example_spec.rb

@@ -20,7 +20,7 @@ describe Erudite::Example do
 
   it 'uses the default expected outcome' do
     example = described_class.new(nil)
-    expect(example.expected).to be_an(Erudite::Outcome)
+    expect(example.expected).to be_an(Erudite::Example::Outcome)
     expect(example.expected.result).to be(nil)
     expect(example.expected.output).to be(nil)
   end
@@ -312,19 +312,19 @@ describe Erudite::Example do
 
     it 'returns true if both the result and output match' do
       example = described_class
-        .new('p "something"', '"something"', '"something"')
+                .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"')
+                .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"')
+                .new('p "something"', '"something"', '"something else"')
       expect(example).to_not be_pass
     end
   end

data/spec/erudite/executable_spec.rb

@@ -20,18 +20,48 @@ describe Erudite::Executable do
     end
 
     context 'with input' do
-      let(:input) { ">> p(true)\ntrue\n=> true\n" }
+      let(:input) do
+        <<-'RUBY'
+          # >> p(true)
+          # true
+          # => true
+        RUBY
+      end
 
-      it 'returns the example' do
+      it 'returns the example groups' do
         expect(result).to_not be_empty
-        result.each do |example|
-          expect(example).to be_an(Erudite::Example)
+        result.each do |group|
+          expect(group).to_not be_empty
+          group.each do |example|
+            expect(example).to be_an(Erudite::Example)
+          end
         end
       end
 
       it 'prints the results' do
         result
-        expect($stdout.string).to eql("- PASS\n")
+        expect($stdout.string).to eql(<<-'TEXT'.dedent)
+          - PASS
+        TEXT
+      end
+    end
+
+    context 'with multiple examples' do
+      let(:input) do
+        <<-'RUBY'
+          # >> x = 1
+          # => 1
+          # >> x
+          # => 1
+        RUBY
+      end
+
+      it 'uses the same binding for all examples' do
+        result
+        expect($stdout.string).to eql(<<-'TEXT'.dedent)
+          - PASS
+          - PASS
+        TEXT
       end
     end
   end

data/spec/erudite/extractor_spec.rb

@@ -0,0 +1,352 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Erudite::Extractor do
+  describe '.extract' do
+    it 'returns an empty array if there are no examples' do
+      expect(described_class.extract(<<-'RUBY'))
+      RUBY
+        .to eq([])
+    end
+
+    it 'returns an example from inline comments' do
+      expect(described_class.extract(<<-'RUBY'))
+        # >> p(true)
+        # true
+        # => true
+      RUBY
+        .to eq([[Erudite::Example.new('p(true)', 'true', 'true')]])
+    end
+
+    it 'returns an example from block comments' do
+      expect(described_class.extract(<<-'RUBY'))
+=begin
+>> p(false)
+false
+=> false
+=end
+      RUBY
+        .to eq([[Erudite::Example.new('p(false)', 'false', 'false')]])
+    end
+
+    it 'extracts an example surrounded by whitespace' do
+      expect(described_class.extract(<<-'RUBY'))
+        # One plus two is...
+        #
+        # >> 1 + 2
+        # => 3
+        #
+        # three.
+      RUBY
+        .to eq([[Erudite::Example.new('1 + 2', '3')]])
+    end
+
+    it 'ignores examples not surrounded by whitespace' do
+      expect(described_class.extract(<<-'RUBY'))
+        # Four plus five is...
+        # >> 4 + 5
+        # => 9
+        # nine.
+      RUBY
+        .to eq([])
+    end
+
+    it 'groups multiple examples together' do
+      expect(described_class.extract(<<-'RUBY'))
+        # >> x = 1
+        # => 1
+        # >> x + 1
+        # => 2
+      RUBY
+        .to eq([[
+          Erudite::Example.new('x = 1', '1'),
+          Erudite::Example.new('x + 1', '2')
+        ]])
+    end
+
+    it 'groups multiple examples separated by whitespace together' do
+      expect(described_class.extract(<<-'RUBY'))
+        # >> x = 2
+        # => 2
+        #
+        # >> x * 3
+        # => 6
+      RUBY
+        .to eq([[
+          Erudite::Example.new('x = 2', '2'),
+          Erudite::Example.new('x * 3', '6')
+        ]])
+    end
+
+    it 'puts examples from different comments in different groups' do
+      expect(described_class.extract(<<-'RUBY'))
+        # >> x = 3
+        # => 3
+
+        # >> x
+        # NameError: ...
+      RUBY
+        .to eq([
+          [Erudite::Example.new('x = 3', '3')],
+          [Erudite::Example.new('x', nil, 'NameError: ...')]
+        ])
+    end
+
+    it 'ignores ragged examples' do
+      expect(described_class.extract(<<-'RUBY'))
+        #  >> nil
+        # => nil
+      RUBY
+        .to eq([])
+    end
+  end
+
+  describe '.find_examples' do
+    subject(:result) { described_class.find_examples(groups) }
+    let(:groups) { [] }
+
+    context 'with an example' do
+      let(:groups) { [['>> true']] }
+
+      it 'returns the example' do
+        expect(result).to eql([['>> true']])
+      end
+    end
+
+    context 'with an example and some text' do
+      let(:groups) { [['a'], ['>> false'], ['b']] }
+
+      it 'returns only the example' do
+        expect(result).to eql([['>> false']])
+      end
+    end
+
+    context 'with an example and some blanks' do
+      let(:groups) { [[], ['>> nil'], []] }
+
+      it 'returns only the example' do
+        expect(result).to eql([['>> nil']])
+      end
+    end
+
+    context 'with an indented example' do
+      let(:groups) { [[' >> true']] }
+
+      it 'returns the example' do
+        expect(result).to eql([['>> true']])
+      end
+    end
+
+    context 'with a ragged example' do
+      let(:groups) { [[' >> 1', '=> 2']] }
+
+      it 'does not return the example' do
+        expect(result).to eql([])
+      end
+    end
+  end
+
+  describe '.group_text' do
+    subject(:result) { described_class.group_text(lines) }
+    let(:lines) { '' }
+
+    context 'with two adjacent lines' do
+      let(:lines) { %w(a b) }
+
+      it 'returns the lines in their own group' do
+        expect(result).to eql([%w(a b)])
+      end
+    end
+
+    context 'with two separate lines' do
+      let(:lines) { ['a', '', 'b'] }
+
+      it 'returns the lines in separate groups' do
+        expect(result).to eql([['a'], ['b']])
+      end
+    end
+
+    context 'with two lines separated by whitespace' do
+      let(:lines) { ['a', ' ', 'b'] }
+
+      it 'returns the lines in separate groups' do
+        expect(result).to eql([['a'], ['b']])
+      end
+    end
+  end
+
+  describe '.extract_text' do
+    subject(:result) { described_class.extract_text(comment) }
+    let(:comment) { Parser::CurrentRuby.parse_with_comments(source).last.first }
+    let(:source) { '' }
+
+    context 'with an inline comment' do
+      let(:source) { '# I know kung-fu.' }
+
+      it 'extracts the text' do
+        expect(result).to eql([' I know kung-fu.'])
+      end
+    end
+
+    context 'with a block comment' do
+      let(:source) { "=begin\nSo you lie to yourself to be happy.\n=end" }
+
+      it 'extracts the text' do
+        expect(result).to eql(['So you lie to yourself to be happy.'])
+      end
+    end
+
+    context 'with a multi-line block comment' do
+      let(:source) { "=begin\nThis is the last of Earth!\nI am content!\n=end" }
+
+      it 'extracts the text' do
+        expect(result).to eql(['This is the last of Earth!', 'I am content!'])
+      end
+    end
+  end
+
+  describe '.group_comments' do
+    subject(:result) { described_class.group_comments(comments) }
+    let(:comments) { [] }
+
+    it 'returns an array' do
+      expect(result).to be_an(Array)
+    end
+
+    context 'with an inline comment' do
+      let(:comments) do
+        Parser::CurrentRuby.parse_with_comments(<<-'RUBY').last
+          # It was a pleasure to burn.
+        RUBY
+      end
+
+      it 'returns the comment in its own group' do
+        expect(result).to eql([comments])
+      end
+    end
+
+    context 'with multiple inline comments' do
+      let(:comments) do
+        Parser::CurrentRuby.parse_with_comments(<<-'RUBY').last
+          # It was the best of times,
+          #
+          # it was the worst of times, ...
+        RUBY
+      end
+
+      it 'returns the comments in a group' do
+        expect(result).to eql([comments])
+      end
+    end
+
+    context 'with two separate inline comments' do
+      let(:comments) do
+        Parser::CurrentRuby.parse_with_comments(<<-'RUBY').last
+          # I don't know half of you half as well as I should like;
+
+          # and I like less than half of you half as well as you deserve.
+        RUBY
+      end
+
+      it 'returns the comments in separate groups' do
+        expect(result).to eql([[comments.first], [comments.last]])
+      end
+    end
+
+    context 'with ragged inline comments' do
+      let(:comments) do
+        Parser::CurrentRuby.parse_with_comments(<<-'RUBY').last
+          # You can't win, Darth.
+            # If you strike me down,
+          # I shall become more powerful than you can possibly imagine.
+        RUBY
+      end
+
+      it 'returns the comments in separate groups' do
+        expect(result).to eql([[comments[0]], [comments[1]], [comments[2]]])
+      end
+    end
+
+    context 'with a block comment' do
+      let(:comments) do
+        Parser::CurrentRuby.parse_with_comments(<<-'RUBY').last
+=begin
+Remember - the enemy's gate is down.
+=end
+        RUBY
+      end
+
+      it 'returns the comment in its own group' do
+        expect(result).to eql([comments])
+      end
+    end
+
+    context 'with two block comments' do
+      let(:comments) do
+        Parser::CurrentRuby.parse_with_comments(<<-'RUBY').last
+=begin
+Time is an illusion.
+=end
+=begin
+Lunchtime doubly so.
+=end
+        RUBY
+      end
+
+      it 'returns the comments in separate groups' do
+        expect(result).to eql([[comments.first], [comments.last]])
+      end
+    end
+  end
+
+  describe '.groupable?' do
+    subject(:result) { described_class.groupable?(a, b) }
+    let(:a) { comments.first }
+    let(:b) { comments.last }
+    let(:comments) { Parser::CurrentRuby.parse_with_comments(source).last }
+    let(:source) { '' }
+
+    context 'with two adjacent comments' do
+      let(:source) { "# 1\n# 2" }
+
+      it 'returns true' do
+        expect(result).to be(true)
+      end
+    end
+
+    context 'with two separate comments' do
+      let(:source) { "# 1\n\n# 2" }
+
+      it 'returns false' do
+        expect(result).to be(false)
+      end
+    end
+
+    context 'with two ragged comments' do
+      let(:source) { "# 1\n # 2" }
+
+      it 'returns false' do
+        expect(result).to be(false)
+      end
+    end
+  end
+
+  describe '.parse_comments' do
+    subject(:result) { described_class.parse_comments(source) }
+    let(:source) { '' }
+
+    it 'returns an array' do
+      expect(result).to be_an(Array)
+    end
+
+    context 'with a comment' do
+      let(:source) { '# Call me Ishmael.' }
+
+      it 'returns the comment' do
+        expect(result).to_not be_empty
+        result.each { |e| expect(e).to be_a(Parser::Source::Comment) }
+      end
+    end
+  end
+end

data/spec/erudite/version_spec.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Erudite::VERSION do
+  it 'is a gem version' do
+    expect(described_class).to be_a(Gem::Version)
+  end
+end

data/spec/spec_helper.rb

@@ -4,3 +4,10 @@ require 'coveralls'
 Coveralls.wear!
 
 require 'erudite'
+
+# Monkey patch String to add ability to strip leading whitespace.
+class String
+  def dedent
+    gsub(/^#{self[/\A\s*/]}/, '')
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: erudite
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Taylor Fausak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-18 00:00:00.000000000 Z
+date: 2015-01-26 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -30,14 +44,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '10.3'
+        version: '10.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '10.3'
+        version: '10.4'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +72,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.26'
+        version: '0.28'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.26'
+        version: '0.28'
 description: Executable documentation.
 email: taylor@fausak.me
 executables:
@@ -80,13 +94,17 @@ files:
 - bin/erudite
 - lib/erudite.rb
 - lib/erudite/example.rb
+- lib/erudite/example/outcome.rb
+- lib/erudite/example/parser.rb
 - lib/erudite/executable.rb
-- lib/erudite/outcome.rb
-- lib/erudite/parser.rb
+- lib/erudite/extractor.rb
+- lib/erudite/version.rb
+- spec/erudite/example/outcome_spec.rb
+- spec/erudite/example/parser_spec.rb
 - spec/erudite/example_spec.rb
 - spec/erudite/executable_spec.rb
-- spec/erudite/outcome_spec.rb
-- spec/erudite/parser_spec.rb
+- spec/erudite/extractor_spec.rb
+- spec/erudite/version_spec.rb
 - spec/erudite_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/tfausak/erudite
@@ -109,14 +127,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.1
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Executable documentation.
 test_files:
+- spec/erudite/example/outcome_spec.rb
+- spec/erudite/example/parser_spec.rb
 - spec/erudite/example_spec.rb
 - spec/erudite/executable_spec.rb
-- spec/erudite/outcome_spec.rb
-- spec/erudite/parser_spec.rb
+- spec/erudite/extractor_spec.rb
+- spec/erudite/version_spec.rb
 - spec/erudite_spec.rb
 - spec/spec_helper.rb

data/lib/erudite/outcome.rb

@@ -1,19 +0,0 @@
-# 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

@@ -1,54 +0,0 @@
-# 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(&:chomp)
-      output.join("\n") unless output.empty?
-    end
-  end
-end