cofgratx 0.0.1

data/spec/non_terminal_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+require 'cofgratx/cfg/rule'
+require 'cofgratx/cfg/non_terminal'
+
+describe NonTerminal do
+  context ".initialize" do
+    before do
+      @rule = Rule.new
+      @rule2 = Rule.new
+    end
+
+    it "can initialize with nothing" do
+      expect{ described_class.new() }.to_not raise_error
+    end
+
+    it "can initialize with a rule" do
+      expect{ described_class.new(@rule) }.to_not raise_error
+    end
+
+    it "can initialize with a set of rules" do
+      expect{ described_class.new(@rule, @rule2) }.to_not raise_error
+    end
+
+    it "can initialize with a set of rules and ignores duplicates" do
+      @non_terminal = described_class.new(@rule, @rule2)
+      expect( @non_terminal.instance_variable_get("@rules").size ).to equal 1
+    end
+
+    it "raises an exception on bad initial objects" do
+      expect{ described_class.new(@rule, 12345) }.to raise_error(ArgumentError, "expected a list of Rules; found bad items: " +
+                               [12345].map{|bad_arg| "#{bad_arg.class.name} #{bad_arg}"}.join("\n"))
+    end
+  end
+
+  context ".match?" do
+    before do
+      @rule = Rule.new
+      @rule2 = Rule.new
+      @rule.instance_variable_set("@rule", [/a/])
+      @rule2.instance_variable_set("@rule", [/b/])
+    end
+
+    context "returns false when the non terminal has no matching rules at the strings beginning" do
+      before do
+        allow(@rule).to receive(:match?){ false }
+        allow(@rule2).to receive(:match?){ false }
+      end
+      it{ expect( described_class.new().match?("no match") ).to be_falsey }
+      it{ expect( described_class.new(@rule).match?("still no match") ).to be_falsey }
+      it{ expect( described_class.new(@rule,@rule2).match?("stubbed so no match") ).to be_falsey }
+    end
+
+    context "returns true when the  non terminal has a matching rule at the start of the string" do
+      before do
+        allow(@rule).to receive(:match?){ false }
+        allow(@rule2).to receive(:match?){ true }
+      end
+      it{ expect( described_class.new(@rule2).match?("test") ).to be_truthy }
+      it{ expect( described_class.new(@rule,@rule2).match?("test first") ).to be_truthy }
+      it{ expect( described_class.new(@rule2,@rule2).match?("tony, get some sandwiches") ).to be_truthy }
+    end
+  end
+
+  context ".extract" do
+    before do
+      @rule = Rule.new
+      @rule2 = Rule.new
+      @rule3 = Rule.new
+      @rule.instance_variable_set("@rule", [/a/])
+      @rule2.instance_variable_set("@rule", [/b/])
+      @rule2.instance_variable_set("@rule", [/c/])
+    end
+
+    context "returns nil and the unmodified string when the terminal is not found at the strings beginning" do
+      before do
+        allow(@rule).to receive(:extract){ |param| [ [nil,param,[[]]] ] }
+        allow(@rule2).to receive(:extract){ |param| [ [nil,param,[[]]] ] }
+      end
+      it{ expect( described_class.new().extract("no match") ).to match_array( [ [nil,"no match",[[]]] ] ) }
+      it{ expect( described_class.new(@rule).extract("still no match") ).to match_array( [ [nil,"still no match",[[]]] ] ) }
+      it{ expect( described_class.new(@rule,@rule2).extract("stubbed so no match") ).to match_array( [ [nil,"stubbed so no match",[[]]] ] ) }
+    end
+
+    context "returns the terminal match and remainder of string" do
+      before do
+        allow(@rule).to receive(:extract){ |param| [ [nil,param,[[]]] ] }
+        allow(@rule2).to receive(:extract){ |param| [ ["D",param[1..-1],[["D"]]] ] }
+        allow(@rule3).to receive(:extract){ |param| [ ["Don",param[3..-1],[["Don"]]] ] }
+      end
+      it "does not mutate the input string" do
+        input_string = "Don't change me!"
+        expect( described_class.new(@rule2,@rule,@rule3).extract(input_string) ).to match_array( [ ["D","on't change me!",[["D"]]], ["Don","'t change me!", [["Don"]]] ] )
+        expect( input_string ).to match "Don't change me!"
+      end
+      it{ expect( described_class.new(@rule,@rule3).extract("Donald") ).to match_array( [ ["Don","ald",[["Don"]]] ] ) }
+      it{ expect( described_class.new(@rule,@rule3,@rule2).extract("Donald") ).to match_array( [ ["D","onald",[["D"]]], ["Don","ald",[["Don"]]] ] ) }
+      it{ expect( described_class.new(@rule2).extract("Donald") ).to match_array( [ ["D","onald",[["D"]]] ] ) }
+    end
+  end
+
+  context ".translate" do
+    before do
+      @rule = Rule.new
+      @rule2 = Rule.new
+      @rule3 = Rule.new
+      @rule.instance_variable_set("@rule", [/a/])
+      @rule2.instance_variable_set("@rule", [/b/])
+      @rule2.instance_variable_set("@rule", [/c/])
+
+      allow(@rule).to receive(:translate){ |param| [[nil, param]] }
+      allow(@rule2).to receive(:translate){ |param| [["ba", param[2..-1]]] }
+      allow(@rule3).to receive(:translate){ |param| [["bba", param[3..-1]]] }
+    end
+
+    it "does not mutate the input string" do
+      input_string = "abb"
+      expect( described_class.new(@rule2,@rule,@rule3).translate(input_string) ).to match_array( [ ["ba","b"], ["bba",""] ] )
+      expect( input_string ).to match "abb"
+    end
+
+    it{ expect( described_class.new(@rule).translate("ab") ).to match_array( [ [nil, "ab"] ] ) }
+    it{ expect( described_class.new(@rule,@rule2).translate("abba") ).to match_array( [ ["ba", "ba"] ] ) }
+    it{ expect( described_class.new(@rule,@rule2).translate("abba") ).to match_array( [ ["ba", "ba"] ] ) }
+    it{ expect( described_class.new(@rule,@rule2,@rule3).translate("abbadabab") ).to match_array( [ ["ba", "badabab"], ["bba", "adabab"] ] ) }
+  end
+end

data/spec/repetition_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'cofgratx/cfg/terminal'
+require 'cofgratx/cfg/repetition'
+
+describe Repetition do
+
+  context ".initialize" do
+    it "can initialize with a string" do
+       expect{ described_class.new("something") }.to_not raise_error
+    end
+
+    it "doesn not initialize with a regular expression" do
+       expect{ described_class.new(/,/) }.to raise_error(ArgumentError, "expected String; got #{/,/.class.name}")
+    end
+
+    it "raises an exception on bad initial objects" do
+      expect{ described_class.new(12345) }.to raise_error(ArgumentError, "expected String; got #{12345.class.name}")
+    end
+  end
+
+  context ".match?" do
+    context "returns false when the terminal is not found at the strings beginning" do
+      it{ expect( described_class.new(",").match?("no match") ).to be_falsey }
+      it{ expect( described_class.new(":").match?("one: two") ).to be_falsey }
+    end
+
+    context "returns true when the terminal is found at the start of the string" do
+      it{ expect( described_class.new(",").match?(",test") ).to be_truthy }
+    end
+  end
+
+  context ".extract" do
+    context "returns nil and the unmodified string when the terminal is not found at the strings beginning" do
+      it{ expect( described_class.new(",").extract("no match") ).to match_array( [nil, "no match"] ) }
+      it{ expect( described_class.new(",").extract("no, test first") ).to match_array( [nil, "no, test first"] ) }
+    end
+
+    context "returns the terminal match and remainder of string" do
+      it "does not mutate the input string" do
+        input_string = ","
+        expect( described_class.new(",").extract(input_string) ).to match_array( [",", ""] )
+        expect( input_string ).to match ","
+      end
+      it{ expect( described_class.new(",").extract(",") ).to match_array( [",", ""] ) }
+      it{ expect( described_class.new(",").extract(", first") ).to match_array( [",", " first"] ) }
+    end
+  end
+end

data/spec/rule_spec.rb

@@ -0,0 +1,247 @@
+require 'spec_helper'
+require 'cofgratx/cfg/terminal'
+require 'cofgratx/cfg/repetition'
+require 'cofgratx/cfg/translation_repetition_set_error'
+require 'cofgratx/cfg/translation_repetition_set'
+require 'cofgratx/cfg/rule_error'
+require 'cofgratx/cfg/rule'
+require 'cofgratx/cfg/non_terminal'
+
+
+describe Rule do
+  before(:all) do
+    @rule             = Rule.new
+    @terminal_a       = Terminal.new("a")
+    @terminal_b       = Terminal.new(/b/)
+    @repetition_comma = Repetition.new( "," )
+    @nonterminal      = NonTerminal.new(@rule)
+  end
+
+  context ".set_rule" do
+    before do
+      @rule = described_class.new
+    end
+
+    it { expect{ @rule.set_rule() }.to_not raise_error }
+    it { expect{ @rule.set_rule(@terminal_a) }.to_not raise_error }
+    it { expect{ @rule.set_rule(@nonterminal) }.to_not raise_error }
+    it { expect{ @rule.set_rule(@nonterminal, @terminal_b) }.to_not raise_error }
+    it { expect{ @rule.set_rule(@terminal_b) }.to_not raise_error }
+    it { expect{ @rule.set_rule(@terminal_a, @repetition_comma) }.to_not raise_error }
+    it { expect{ @rule.set_rule(@terminal_a, @terminal_b, @terminal_a, @repetition_comma) }.to_not raise_error }
+    it { expect{ @rule.set_rule(@terminal_a, @nonterminal, @terminal_b, @repetition_comma) }.to_not raise_error }
+
+    it "raises an exception on bad initial objects" do
+      expect{ @rule.set_rule(12345) }.to raise_error(ArgumentError, "expected Terminal, NonTerminal or Repetition; got #{12345.class.name}")
+    end
+
+    it "the repetition cannot be the first for the rule" do
+      expect{ @rule.set_rule(@repetition_comma) }.to raise_error(RuleError, "cannot have repetition as the first part of the rule")
+    end
+
+    context "nothing can follow the repetition" do
+      it {expect{
+                  @rule.set_rule(@terminal_a, @repetition_comma, @terminal_a)
+                }.to raise_error(RuleError, "nothing can follow the repetition") }
+      it {expect{
+                  @rule.set_rule(@terminal_a, @repetition_comma, @repetition_comma)
+                }.to raise_error(RuleError, "nothing can follow the repetition") }
+    end
+  end
+
+  context ".set_translation" do
+    before(:all) do
+      @tx_rep_set = TranslationRepetitionSet.new(1, 2, 4)
+    end
+
+    before do
+      @rule = described_class.new
+    end
+
+    it { expect{ @rule.set_translation() }.to_not raise_error }
+    it { expect{ @rule.set_translation(1) }.to_not raise_error }
+    it { expect{ @rule.set_translation(1,2,3) }.to_not raise_error }
+    it { expect{ @rule.set_translation([1,"foo","bar"]) }.to_not raise_error }
+    it { expect{ @rule.set_translation(1, @tx_rep_set) }.to_not raise_error }
+
+    context "bad input" do
+      def message_helper obj
+        "expected Fixnum, String or TranslationRepetitionSet; got #{obj.class.name}"
+      end
+
+      it { expect{ @rule.set_translation(1.32) }.to raise_error(ArgumentError, message_helper(1.32)) }
+      it { expect{ @rule.set_translation(1, {1=>2}) }.to raise_error(ArgumentError, message_helper({1=>2})) }
+      it { expect{ @rule.set_translation(/asd/) }.to raise_error(ArgumentError, message_helper(/asd/)) }
+    end
+  end
+
+
+  context ".initialize" do
+    before(:all) do
+      @tx_rep_set = TranslationRepetitionSet.new(1, 2, 4)
+
+      @rule = [@terminal_a, @terminal_b]
+      @translation = [1, 2, @tx_rep_set]
+    end
+
+    it "sets the subrules and translations by calling the appropriate methods" do
+      expect_any_instance_of(described_class).to receive(:set_rule).with(@rule).and_call_original
+      expect_any_instance_of(described_class).to receive(:set_translation).with(@translation).and_call_original
+
+      described_class.new(@rule, @translation)
+    end
+
+    it "sets the subrules and translations when no translation is given" do
+      expect_any_instance_of(described_class).to receive(:set_rule).with(@rule).and_call_original
+      expect_any_instance_of(described_class).to receive(:set_translation).with([]).and_call_original
+
+      described_class.new(@rule)
+    end
+
+    it "sets the subrules and translations when no input" do
+      expect_any_instance_of(described_class).to receive(:set_rule).with([]).and_call_original
+      expect_any_instance_of(described_class).to receive(:set_translation).with([]).and_call_original
+
+      described_class.new()
+    end
+  end
+
+  context ".valid_translation?" do
+    before(:all) do
+      @tx_rep_set = TranslationRepetitionSet.new(2, 1)
+      @repeat_rule = [@terminal_a, @repetition_comma]
+    end
+
+    it { expect(described_class.new().valid_translation?).to be_truthy }
+    it { expect(described_class.new(@terminal_a).valid_translation?).to be_truthy }
+    it { expect(described_class.new(@repeat_rule).valid_translation?).to be_truthy }
+    it { expect(described_class.new(@repeat_rule, [2,1,@tx_rep_set]).valid_translation?).to be_truthy }
+
+    it "is not valid if a translation number is larger than the number of sub rules" do
+      expect(described_class.new(@repeat_rule, [3]).valid_translation?).to be_falsy
+    end
+
+    it "is not valid if a translation number is larger than the number of sub rules" do
+      expect(described_class.new(@repeat_rule, TranslationRepetitionSet.new(2, 4)).valid_translation?).to be_falsy
+    end
+
+    it "offset can be any positive number" do
+      expect(described_class.new(@repeat_rule, TranslationRepetitionSet.new(999, 2)).valid_translation?).to be_truthy
+    end
+  end
+
+
+  context ".match?" do
+    before(:all) do
+      @term_rule = described_class.new [@terminal_a, @terminal_b]
+      @repeat_rule = described_class.new [@terminal_a, @repetition_comma]
+      @nonterminal_rule = NonTerminal.new(@term_rule)
+      @mix_rule = described_class.new [@terminal_a, @nonterminal_rule]
+    end
+
+    context "returns false when the rule does not match a substring starting at the strings beginning" do
+      it{ expect( @term_rule.match?("aab") ).to be_falsey }
+      it{ expect( @term_rule.match?("b") ).to be_falsey }
+      it{ expect( @term_rule.match?("here ababab") ).to be_falsey }
+      it{ expect( @term_rule.match?("") ).to be_falsey }
+      it{ expect( @repeat_rule.match?(",a") ).to be_falsey }
+      it{ expect( @repeat_rule.match?("b,a") ).to be_falsey }
+      it{ expect( @repeat_rule.match?("") ).to be_falsey }
+      it{ expect( @repeat_rule.match?("no match") ).to be_falsey }
+      it{ expect( @mix_rule.match?("abb") ).to be_falsey }
+      it{ expect( @mix_rule.match?("b") ).to be_falsey }
+      it{ expect( @mix_rule.match?("daab") ).to be_falsey }
+      it{ expect( @mix_rule.match?("") ).to be_falsey }
+    end
+
+    context "returns true when the rule matches a substring starting at the strings beginning" do
+      it{ expect( @term_rule.match?("ab") ).to be_truthy }
+      it{ expect( @term_rule.match?("ab something else") ).to be_truthy }
+      it{ expect( @repeat_rule.match?("a,") ).to be_truthy }
+      it{ expect( @repeat_rule.match?("a,a") ).to be_truthy }
+      it{ expect( @repeat_rule.match?("anothing") ).to be_truthy }
+      it{ expect( @repeat_rule.match?("a,nothing else") ).to be_truthy }
+      it{ expect( @mix_rule.match?("aabb more stuff") ).to be_truthy }
+      it{ expect( @mix_rule.match?("aabbb") ).to be_truthy }
+      it{ expect( @mix_rule.match?("aab") ).to be_truthy }
+    end
+  end
+
+  context ".extract" do
+    before(:all) do
+      @term_rule = described_class.new [@terminal_a, @terminal_b]
+      @repeat_rule = described_class.new [@terminal_a, @repetition_comma]
+      @nonterminal_rule = NonTerminal.new(@term_rule)
+      @mix_rule = described_class.new [@terminal_a, @nonterminal_rule]
+    end
+
+    context "returns nil and the unmodified string when the rule is not matched at the strings beginning" do
+      it{ expect( @term_rule.extract("aab") ).to match_array( [ [nil,"aab",[[]]] ] ) }
+      it{ expect( @term_rule.extract("b") ).to match_array( [ [nil,"b",[[]]] ] ) }
+      it{ expect( @term_rule.extract("here ababab") ).to match_array( [ [nil,"here ababab",[[]]] ] ) }
+      it{ expect( @term_rule.extract("") ).to match_array( [ [nil,"",[[]]] ] ) }
+      it{ expect( @repeat_rule.extract(",a") ).to match_array( [ [nil,",a",[[]]] ] ) }
+      it{ expect( @repeat_rule.extract("b,a") ).to match_array( [ [nil,"b,a",[[]]] ] ) }
+      it{ expect( @repeat_rule.extract("") ).to match_array( [ [nil,"",[[]]] ] ) }
+      it{ expect( @repeat_rule.extract("no match") ).to match_array( [ [nil,"no match",[[]]] ] ) }
+      it{ expect( @mix_rule.extract("abb") ).to match_array( [ [nil,"abb",[[]]] ] ) }
+      it{ expect( @mix_rule.extract("b") ).to match_array( [ [nil,"b",[[]]] ] ) }
+      it{ expect( @mix_rule.extract("daab") ).to match_array( [ [nil,"daab",[[]]] ] ) }
+      it{ expect( @mix_rule.extract("") ).to match_array( [ [nil,"",[[]]] ] ) }
+    end
+
+    context "returns the rule match and remainder of string" do
+      it "does not mutate the input string" do
+        input_string = "Don't change me!"
+        expect( described_class.new(Terminal.new("Don't change me!")).extract(input_string) ).to match_array( [ ["Don't change me!","",[["Don't change me!"]]] ] )
+        expect( input_string ).to match "Don't change me!"
+      end
+
+      it{ expect( @term_rule.extract("ab") ).to match_array( [ ["ab","",[["a","b"]]] ] ) }
+      it{ expect( @term_rule.extract("ab something else") ).to match_array( [ ["ab"," something else",[["a","b"]]] ] ) }
+      it{ expect( @repeat_rule.extract("a,") ).to match_array( [ ["a",",",[["a"]]] ] ) }
+      it{ expect( @repeat_rule.extract("a,a") ).to match_array( [ ["a,a","",[["a",","],["a"]]] ] ) }
+      it{ expect( @repeat_rule.extract("anothing") ).to match_array( [ ["a","nothing",[["a"]]] ] ) }
+      it{ expect( @repeat_rule.extract("a,nothing else") ).to match_array( [ ["a",",nothing else",[["a"]]] ] ) }
+      it{ expect( @repeat_rule.extract("a,a,anothing else") ).to match_array( [ ["a,a,a","nothing else",[["a",","],["a",","],["a"]]] ] ) }
+      it{ expect( @repeat_rule.extract("a,a,a,nothing else") ).to match_array( [ ["a,a,a",",nothing else",[["a",","],["a",","],["a"]]] ] ) }
+    end
+  end
+
+  context ".translate" do
+    before(:all) do
+      @terminal_c = Terminal.new("c")
+      @tx_rep_set = TranslationRepetitionSet.new(2, " repeats:", 2, 1, 3)
+      @simple_rule = described_class.new [@terminal_a, @terminal_b], [2,1]
+      @simple_rule2 = described_class.new [@terminal_a, @terminal_b], [2,1,2,"moo"]
+      @repeat_rule = described_class.new [@terminal_a, @terminal_b, @repetition_comma], [3,2,1,@tx_rep_set]
+      @nonterminal_rule = NonTerminal.new(@simple_rule)
+      @mix_rule = described_class.new [Terminal.new("c"), @nonterminal_rule], [2,1]
+      @mix_rule_repeat = described_class.new [@terminal_c, @nonterminal_rule, @repetition_comma], [3,2,1,@tx_rep_set]
+    end
+
+    it "does not modify the original parameter" do
+      original_string = "ab"
+      expect( @simple_rule.translate original_string ).to match_array( [ ["ba",""] ] )
+      expect( original_string ).to match "ab"
+    end
+
+    it { expect( @simple_rule.translate "abab" ).to match_array( [ ["ba","ab"] ] ) }
+    it { expect( @simple_rule.translate "ab and nothing else" ).to match_array( [ ["ba"," and nothing else"] ] ) }
+    it { expect( @simple_rule2.translate "abab" ).to match_array( [ ["babmoo","ab"] ] ) }
+    it { expect( @simple_rule2.translate "ab and nothing else" ).to match_array( [ ["babmoo"," and nothing else"] ] ) }
+
+    it { expect( @repeat_rule.translate "ab," ).to match_array( [ ["ba",","] ] ) }
+    it { expect( @repeat_rule.translate "ab,ab" ).to match_array( [ [",ba repeats:ba",""] ] ) }
+    it { expect( @repeat_rule.translate "ab,ab,ab" ).to match_array( [ [",ba repeats:ba, repeats:ba",""] ] ) }
+    it { expect( @repeat_rule.translate "ab,ab,ab," ).to match_array( [ [",ba repeats:ba, repeats:ba",","] ] ) }
+
+    it { expect( @mix_rule.translate "cab" ).to match_array( [ ["bac",""] ] ) }
+    it { expect( @mix_rule.translate "cab," ).to match_array( [ ["bac",","] ] ) }
+    it { expect( @mix_rule.translate "cab,cab" ).to match_array( [ ["bac",",cab"] ] ) }
+    it { expect( @mix_rule_repeat.translate "cab," ).to match_array( [ ["bac",","] ] ) }
+    it { expect( @mix_rule_repeat.translate "cab,cab" ).to match_array( [ [",bac repeats:bac",""] ] ) }
+    it { expect( @mix_rule_repeat.translate "cab,cab,cab" ).to match_array( [ [",bac repeats:bac, repeats:bac",""] ] ) }
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,91 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end