mountain_berry_fields 1.0.0

data/spec/command_line_interaction_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe MountainBerryFields::CommandLineInteraction do
+  let(:interaction) { described_class.new }
+  let(:stderr)      { interaction.stderr.string }
+
+  it 'implements the interaction interface' do
+    Mock::Interaction.should substitute_for MountainBerryFields::CommandLineInteraction, subset: true
+  end
+
+  specify '#declare_failure(message) writes messages to stderr, with newlines' do
+    interaction.declare_failure "failure one"
+    interaction.declare_failure "failure two"
+    stderr.should == "failure one\nfailure two\n"
+  end
+end

data/spec/evaluator_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe MountainBerryFields::Evaluator do
+  it 'implements the evaluator interface' do
+    Mock::Evaluator.should substitute_for described_class, subset: true
+  end
+
+  let(:to_evaluate) { '' }
+  let(:evaluator)   { described_class.new to_evaluate }
+
+  it 'has a document which is initialized to empty string and memoized' do
+    evaluator = described_class.new ''
+    evaluator.document.should == ''
+    evaluator.document << 'abc'
+    evaluator.document.should == 'abc'
+  end
+
+  def should_evaluate
+    evaluator = described_class.new('def meth;end')
+    evaluator.should_not respond_to :meth
+    yield evaluator
+    evaluator.should respond_to :meth
+  end
+
+  it 'ensures evaluation when asked for its document' do
+    should_evaluate { |evaluator| evaluator.document }
+  end
+
+  it 'ensures evaluation when asked if tests pass' do
+    should_evaluate { |evaluator| evaluator.tests_pass? }
+  end
+
+  describe 'evaluation' do
+    it 'instance evals the string only once' do
+      evaluator = described_class.new('def meth;end; document << "abc"')
+      evaluator.evaluate
+      evaluator.evaluate
+      evaluator.document.should == 'abc'
+    end
+  end
+
+
+  describe '#tests_pass?' do
+    test_class = MountainBerryFields::Test
+
+    it 'evaluates the text if not evaluated' do
+      should_evaluate { |evaluator| evaluator.tests_pass? }
+    end
+
+    it 'returns true if all its tests pass' do
+      evaluator = described_class.new ''
+      evaluator.test('Passing test', with: :always_pass) {''}
+      evaluator.tests_pass?.should == true
+    end
+
+    it 'tracks the failure name and message, if any of its tests fail' do
+      evaluator = described_class.new ''
+      evaluator.test('Failbert', with: :always_fail) {}
+      evaluator.tests_pass?.should == false
+      evaluator.failure_name.should == 'Failbert'
+      evaluator.failure_message.should == MountainBerryFields::Test::Strategy.for(:always_fail).new('').failure_message
+    end
+  end
+
+  describe 'visible and invisble commands' do
+    specify '#visible_commands is an array of commands whose output should be displayed' do
+      described_class.visible_commands.should be_a_kind_of Array
+    end
+
+    specify '#invisible_commands is an array of commands whose output should be omitted from the final document' do
+      described_class.invisible_commands.should be_a_kind_of Array
+    end
+  end
+
+
+  describe '#test' do
+    it 'is visible' do
+      described_class.visible_commands.should include :test
+    end
+
+    it 'adds a test with the given name, and options' do
+      options   = { code: 'some code', with: :always_fail }
+      evaluator = described_class.new ''
+      evaluator.tests.size.should == 0
+      evaluator.test('some name', options) { '' }
+      evaluator.tests.size.should == 1
+      evaluator.tests.first.name.should == 'some name'
+      evaluator.tests.first.strategy.should == :always_fail
+    end
+
+    it 'immediately evaluates the test' do
+      $abc = ''
+      evaluator.test 'whatev', with: :always_pass do
+        '$abc = "abc"'
+      end
+      $abc.should == 'abc'
+    end
+  end
+
+
+  describe '#setup' do
+    it 'is invisible' do
+      described_class.invisible_commands.should include :setup
+    end
+
+    it 'is prepended before each test added after it' do
+      evaluator.test('name', with: :always_pass) { "test1\n" }
+      evaluator.setup { "setup\n" }
+      evaluator.test('name', with: :always_pass) { "test2\n" }
+      evaluator.test('name', with: :always_pass) { "test3\n" }
+      evaluator.tests[0].code.should == "test1\n"
+      evaluator.tests[1].code.should == "setup\ntest2\n"
+      evaluator.tests[2].code.should == "setup\ntest3\n"
+    end
+
+    it 'appends to the setup code if invoked multiple times' do
+      evaluator.setup { "setup1\n" }
+      evaluator.setup { "setup2\n" }
+      evaluator.test('name', with: :always_pass) { "test1\n" }
+      evaluator.tests.first.code.should == "setup1\nsetup2\ntest1\n"
+    end
+  end
+
+
+  describe '#context' do
+    let(:context_name) { 'some context name' }
+    let(:test_name)    { 'some test name' }
+
+    it 'is invisible' do
+      described_class.invisible_commands.should include :context
+    end
+
+    it 'must have at least one __CODE__ section in it' do
+      expect {
+        evaluator.context(context_name) { 'no code section' }
+      }.to raise_error ArgumentError, /#{context_name}.*__CODE__/
+    end
+
+    it 'replaces all __CODE__ section with the test using it' do
+      evaluator.context(context_name) { 'a __CODE__ c __CODE__' }
+      evaluator.test(test_name, with: :always_pass, context: context_name) { 'b' }
+      evaluator.tests.first.code.should == 'a b c b'
+    end
+
+    it 'raises an error when a test references a nonexistent context' do
+      evaluator.context(context_name) { '__CODE__' }
+      expect {
+        evaluator.test(test_name, with: :always_pass, context: context_name.reverse) {''}
+      }.to raise_error NameError, /#{context_name.reverse}.*#{context_name}/
+    end
+
+    it 'is applied after setup' do
+      evaluator.setup { 'a' }
+      evaluator.context(context_name) { ' b __CODE__' }
+      evaluator.test(test_name, context: context_name, with: :always_pass) { 'c' }
+      evaluator.tests.first.code.should == 'a b c'
+    end
+
+    let(:context_name1) { 'context name 1' }
+    let(:context_name2) { 'context name 2' }
+    specify 'contexts can have contexts of their own' do
+      evaluator.context(context_name1) { 'a __CODE__ b' }
+      evaluator.context(context_name2, context: context_name1) { 'c __CODE__ d' }
+      evaluator.test(test_name, context: context_name1, with: :always_pass) { 'e' }
+      evaluator.test(test_name, context: context_name2, with: :always_pass) { 'f' }
+      evaluator.tests[0].code.should == 'a e b'
+      evaluator.tests[1].code.should == 'a c f d b'
+    end
+  end
+end

data/spec/mock_substitutability_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Mock::File do
+  it 'is substitutable for ::File' do
+    Mock::File.should substitute_for ::File, subset: true
+  end
+end
+
+describe Mock::Dir do
+  it 'is substitutable for ::Dir' do
+    Mock::Dir.should substitute_for Dir, subset: true
+  end
+end
+
+describe Mock::Process::Status do
+  it 'is substitutable for ::Process::Status' do
+    Mock::Process::Status.should substitute_for ::Process::Status, subset: true
+  end
+end
+
+describe Mock::Open3 do
+  it 'is substitutable for ::Open3' do
+    Mock::Open3.should substitute_for ::Open3, subset: true
+  end
+end

data/spec/mountain_berry_fields_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe MountainBerryFields do
+  let(:dir_class)   { mbf.dir_class }
+  let(:file_class)  { mbf.file_class }
+  let(:stderr)      { mbf.stderr.string }
+  let(:interaction) { mbf.interaction }
+  let(:evaluator)   { mbf.evaluator }
+  let(:parser)      { mbf.parser }
+
+  shared_examples 'a failure' do
+    it 'returns false' do
+      mbf.execute.should == false
+    end
+
+    it 'does not write any files' do
+      file_class.should_not have_been_told_to :write
+    end
+  end
+
+
+  context 'when no input file is provided' do
+    nonexistence_message = 'Please provide an input file'
+    let(:mbf) { described_class.new [] }
+
+    it_behaves_like 'a failure'
+
+    it "declares the error '#{nonexistence_message}'" do
+      mbf.execute
+      interaction.should have_been_told_to(:declare_failure).with(nonexistence_message)
+    end
+  end
+
+
+  context 'when the input file does not exist' do
+    nonexistent_filename = '/some/bullshit/file.mountain_berry_fields.md'.freeze
+    nonexistence_message = "#{nonexistent_filename.inspect} does not exist.".freeze
+
+    let(:mbf) { described_class.new [nonexistent_filename] }
+    before { file_class.will_exist? false }
+
+    it_behaves_like 'a failure'
+
+    it "declares the error '#{nonexistent_filename}'" do
+      mbf.execute
+      file_class.should have_been_asked_for_its(:exist?).with(nonexistent_filename)
+      interaction.should have_been_told_to(:declare_failure).with(nonexistence_message)
+    end
+  end
+
+
+  context 'when the input file does not match /\.mountain_berry_fields\b/' do
+    invalid_filename         = "invalid_filename.md"
+    invalid_filename_message = "#{invalid_filename.inspect} does not match /\\.mountain_berry_fields\\b/"
+    let(:mbf) { described_class.new [invalid_filename] }
+
+    it "declares the error '#{invalid_filename_message}'" do
+      mbf.execute
+      interaction.should have_been_told_to(:declare_failure).with(invalid_filename_message)
+    end
+  end
+
+  context 'when unsuccessfully parsing a file' do
+    let(:input_filename)   { 'some_invalid_file.mountain_berry_fields.md' }
+    let(:mbf)    { described_class.new [input_filename] }
+    before { parser.will_parse StandardError.new "some error message" }
+
+    it_behaves_like 'a failure'
+
+    it 'writes the exception class and message as the error' do
+      mbf.execute
+      interaction.should have_been_told_to(:declare_failure).with("StandardError some error message")
+    end
+  end
+
+  context 'when successfully parsing a file' do
+    let(:input_filepath)     { '/a/b/c' }
+    let(:input_filename)     { input_filepath + '/some_valid_file.mountain_berry_fields.md' }
+    let(:output_filename)    { input_filepath + '/some_valid_file.md' }
+    let(:mbf)                { described_class.new [input_filename] }
+    let(:file_body)          { 'SOME FILE BODY' }
+    let(:parsed_body)        { 'PARSED BODY' }
+    let(:document)           { 'EVALUATED DOCUMENT' }
+
+    before { file_class.will_read file_body }
+    before { parser.will_parse parsed_body }
+
+    it 'declares no errors' do
+      mbf.execute
+      interaction.should_not have_been_told_to :declare_failure
+    end
+
+    it 'passes the file contents to the parser' do
+      visible_commands = mbf.evaluator_class.visible_commands
+      invisible_commands = mbf.evaluator_class.invisible_commands
+      mbf.execute
+      file_class.should have_been_told_to(:read).with(/#{input_filename}$/)
+      parser.should have_been_initialized_with file_body, visible: visible_commands, invisible: invisible_commands
+    end
+
+    it "evaluates the results of the parsing, in the input file's directory" do
+      dir_class.will_chdir false
+      mbf.execute
+      dir_class.should have_been_told_to(:chdir).with(input_filepath) { |block|
+        block.before { evaluator.should_not have_been_asked_if :tests_pass? }
+        block.after  { evaluator.should     have_been_asked_if :tests_pass? }
+      }
+      evaluator.should have_been_initialized_with parsed_body
+    end
+
+
+    context 'when the tests pass' do
+      before { evaluator.will_tests_pass? true }
+      before { evaluator.will_have_document document }
+
+      it 'returns true' do
+        mbf.execute.should == true
+      end
+
+      it 'writes the interpreted file to the new filename (the same name, but with mountain_berry_fields segment removed)' do
+        mbf.execute
+        file_class.should have_been_told_to(:write).with(output_filename, document)
+      end
+    end
+
+    context 'when the tests fail' do
+      before { evaluator.will_tests_pass? false }
+      it_behaves_like 'a failure'
+
+      it "declares the failure with the evaluator's failure's name and message" do
+        evaluator.will_have_failure_name "sir"
+        evaluator.will_have_failure_message "failsalot"
+        mbf.execute
+        interaction.should have_been_told_to(:declare_failure).with("FAILURE: sir\nfailsalot")
+      end
+    end
+
+    context 'when evaluation raises an exception' do
+      before { evaluator.will_tests_pass? StandardError.new('blah') }
+      it_behaves_like 'a failure'
+      it 'writes the exception class and message as the error' do
+        mbf.execute
+        interaction.should have_been_told_to(:declare_failure).with("StandardError blah")
+      end
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe MountainBerryFields::Parser do
+  let :evaluator_class do
+    Class.new do
+      attr_reader :document, :visible_saw, :invisible_saw
+
+      def initialize
+        @document = ''
+        @visible_saw = []
+        @invisible_saw = []
+      end
+
+      def visible
+        @visible_saw << yield
+        'visible'
+      end
+
+      def invisible
+        @invisible_saw << yield
+        'invisible'
+      end
+
+      def record_args(*args)
+        @recorded_args = args
+      end
+
+      def recorded_args
+        @recorded_args
+      end
+
+      def inspect
+        "#<evaluator_class>"
+      end
+    end
+  end
+
+  attr_reader :evaluator
+
+  def visible_in(code)
+    parsed code
+    evaluator.visible_saw
+  end
+
+  def invisible_in(code)
+    parsed code
+    evaluator.invisible_saw
+  end
+
+  def recorded_args(code)
+    parsed code
+    evaluator.recorded_args
+  end
+
+  def parsed(text)
+    program = described_class.new(text, visible: [:visible], invisible: [:invisible]).parse
+    @evaluator = evaluator_class.new
+    @evaluator.instance_eval program
+    @evaluator.document
+  end
+
+  it 'parses normal erb code' do
+    parsed("a\n<% if true %>\ndo shit\n<% end %>b").should == "a\ndo shit\nb\n"
+    parsed("a\n<% if false %>do shit<% end %>b").should == "a\nb\n"
+    parsed("a<% if true %>b<% end %>c").should == "abc\n"
+    parsed("a<%= 1 + 2 %>b").should == "a3b\n"
+    parsed("a<%# comment %>b").should == "ab\n"
+    parsed("a<%% whatev %>b").should == "a<% whatev %>b\n"
+    parsed("a<%%= whatev %>b").should == "a<%= whatev %>b\n"
+    parsed("a<% if 'I' %>b<% end %>c").should == "abc\n"
+    recorded_args("a<% record_args 'I' %>").should == ['I']
+    recorded_args("a<%= record_args 'I' %>").should == ['I']
+  end
+
+  specify 'results always end with a newline' do
+    parsed("abc").should == "abc\n"
+  end
+
+  describe 'visible methods' do
+    specify 'are provided in a list to the constructor and converted to strings' do
+      described_class.new('', visible: [:a]).visible_commands.should == ['a']
+    end
+
+    specify 'default to an empty array' do
+      described_class.new('').visible_commands.should == []
+    end
+
+    specify 'show up in the document when evaluated' do
+      parsed("a<% visible do %>b<% end %>c").should == "abc\n"
+    end
+
+    specify 'are returned when the block is invoked' do
+      visible_in("a<% visible do %>b<% end %>c").should == ['b']
+    end
+
+    specify "support basic nesting (can't do complex nesting without editing parse trees -- not a big deal, these are things that even erubis can't do)" do
+      visible_in("a<%visible {%>b<%visible {%>c<% } %>d<% } %>e").should == ['c', 'bd']
+      visible_in("a<%visible {%>b<%if false %>c<% end %>d<% } %>e").should == ['bd']
+      visible_in("<%# visible %>").should == []
+      visible_in('<% visible do %>\'a\'\\<% end %>').should == ['\'a\'\\']
+    end
+  end
+
+  describe 'invisible methods' do
+    specify 'are provided in a list to the constructor and converted to strings' do
+      described_class.new('', invisible: [:a]).invisible_commands.should == ['a']
+    end
+
+    specify 'default to an empty array' do
+      described_class.new('').invisible_commands.should == []
+    end
+
+    specify 'do not show up in the document when evaluated' do
+      parsed("a<% invisible do %>b<% end %>c").should == "ac\n"
+    end
+
+    specify 'are returned when the block is invoked' do
+      invisible_in("a<% invisible do %>b<% end %>c").should == ['b']
+    end
+
+    specify "support basic nesting (can't do complex nesting without editing parse trees -- not a big deal, these are things that even erubis can't do)" do
+      invisible_in("a<%invisible {%>b<%invisible {%>c<% } %>d<% } %>e").should == ['c', 'bd']
+      invisible_in("a<%invisible {%>b<%if false %>c<% end %>d<% } %>e").should == ['bd']
+      invisible_in("<%# invisible %>").should == []
+      invisible_in('<% invisible do %>\'a\'\\<% end %>').should == ['\'a\'\\']
+    end
+  end
+
+  # Unfortunately, this problem is in Erubis.
+  # It might be possible to fix it in the subclass,
+  # but that seems like a lot of work for an incredibly rare use case
+  # so just going to leave this pending for now.
+  #
+  # Erubis::Eruby.new('<% a = "<% b %>"; a * 2 %>').src # => "_buf = ''; a = \"<% b ; _buf << '\"; a * 2 %>';\n_buf.to_s\n"
+  xit 'ignores erb tags inside erb blocks' do
+    parse("a<% s='<% visible { %>b<% } %>' %>c").should == "ac\n"
+    parsed("a<% s='<% invisible { %>b<% } %>' %>c").should == "ac\n"
+  end
+end