mountain_berry_fields 1.0.0

data/bin/mountain_berry_fields

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../../lib/', __FILE__)
+
+require 'mountain_berry_fields'
+require 'mountain_berry_fields/command_line_interaction'
+MountainBerryFields.override(:interaction) { MountainBerryFields::CommandLineInteraction.new }
+
+exit MountainBerryFields.new(ARGV).execute

data/features/context_block.feature

@@ -0,0 +1,73 @@
+Feature: Using a context block
+
+  Sometimes there is necessary code around what the user wants to show.
+  But including this context just distracts from the relevant piece of code.
+
+  The user can declare this context in the context block. Their code example
+  can state that it should be executed in that context, and its body will
+  replace the __CODE__ macro in the context.
+
+  This ensures it gets tested with the context, but displayed without it.
+
+  Scenario: Passing test block with a context
+    Given the file "example.mountain_berry_fields.md":
+    """
+    <% context 'user spec' do %>
+      User = Struct.new :name
+      describe User do
+        it 'does usery things' do
+          __CODE__
+        end
+      end
+    <% end %>
+
+    Users know their names:
+    ```ruby
+    <% test 'users know their name', with: :rspec, context: 'user spec' do %>
+    User.new('Josh').name.should == 'Josh'
+    <% end %>
+    ```
+    """
+    When I run "mountain_berry_fields example.mountain_berry_fields.md"
+    Then it exits with a status of 0
+    And I see the file "example.md":
+    """
+
+    Users know their names:
+    ```ruby
+    User.new('Josh').name.should == 'Josh'
+    ```
+    """
+
+
+  Scenario: Passing test block with a context
+    Given the file "example.mountain_berry_fields.md":
+    """
+    <% context 'user spec' do %>
+      User = Struct.new :name
+      describe User do
+        it 'does usery things' do
+          __CODE__
+        end
+      end
+    <% end %>
+
+    Users know their names:
+    ```ruby
+    <% test 'Users know their names', with: :rspec, context: 'user spec' do %>
+      User.new('Josh').name.should == 'Not Josh'
+    <% end %>
+    ```
+    """
+    When I run "mountain_berry_fields example.mountain_berry_fields.md"
+    Then it exits with a status of 1, and a stderr of:
+    """
+    FAILURE: Users know their names
+    User does usery things:
+      expected: "Not Josh"
+         got: "Josh" (using ==)
+
+    backtrace:
+      /spec.rb:4:in `block (2 levels) in <top (required)>'
+    """
+    And I do not see the file "example.md"

data/features/cwd_is_dir_of_mbf_file.feature

@@ -0,0 +1,16 @@
+Feature: Input and output directories
+  The current working directory while the mbf file executes
+  is its own directory.
+
+  The output file is placed in the same directory.
+
+  Scenario:
+    Given the file "example/mah_filez.mountain_berry_fields":
+    """
+    <% test 'what dir?', with: :magic_comments do %>
+    Dir.pwd # => "{{proving_grounds_dir}}/example"
+    <% end %>
+    """
+    When I run "mountain_berry_fields example/mah_filez.mountain_berry_fields"
+    Then it exits with a status of 0
+    And I see the file "example/mah_filez"

data/features/rake_task.feature

@@ -0,0 +1,46 @@
+Feature: Mountain Berry Fields provides a rake task
+
+  To automate usage, users may wish to add Mountain Berry Fields
+  to a rake task, which runs as part of their suite.
+
+  Scenario: Successful rake task
+    Given the file "Rakefile":
+    """
+    require 'mountain_berry_fields/rake_task'
+    MountainBerryFields::RakeTask.new(:mbf, 'Readme.mountain_berry_fields.md')
+    """
+    And the file "Readme.mountain_berry_fields.md":
+    """
+    Use it like this:
+
+    <% test 'example', with: :always_pass do %>
+    the code
+    <% end %>
+    """
+    When I run "rake mbf"
+    Then it exits with a status of 0
+    And I see the file "Readme.md":
+    """
+    Use it like this:
+
+    the code
+    """
+
+
+  Scenario: Failing rake task
+    Given the file "Rakefile":
+    """
+    require 'mountain_berry_fields/rake_task'
+    MountainBerryFields::RakeTask.new(:mountains, 'Readme.mountain_berry_fields.md')
+    """
+    And the file "Readme.mountain_berry_fields.md":
+    """
+    Use it like this:
+
+    <% test 'example', with: :always_fail do %>
+    the code
+    <% end %>
+    """
+    When I run "rake mountains"
+    Then it exits with a status of 1
+    And I do not see the file "Readme.md"

data/features/setup_block.feature

@@ -0,0 +1,36 @@
+Feature: Using a setup block
+
+  Sometimes the user needs to setup the environment.
+  Rather than forcing the user to provide this setup in the
+  code block, which is visible, allow them to provide a
+  setup block, which will be executed before each block of code.
+
+  The current directory is set to the directory containing the
+  mountain_berry_field file, so file operations can be performed
+  relative to that directory.
+
+  Scenario: setup blocks are evaluated before each test block
+    Given the file "addition_helpers.rb":
+    """
+    def plus_five(n)
+      n + 5
+    end
+    """
+    And the file "example.mountain_berry_fields.md":
+    """
+    <% setup do %>
+    require "./addition_helpers"
+    <% end %>
+
+    <% test 'I see the method', with: :magic_comments do %>
+    plus_five 2 # => 7
+    <% end %>
+    """
+    When I run "mountain_berry_fields example.mountain_berry_fields.md"
+    Then it exits with a status of 0
+    And I see the file "example.md":
+    """
+
+    plus_five 2 # => 7
+    """
+

data/features/step_definitions/steps.rb

@@ -0,0 +1,46 @@
+Given 'the file "$filename":' do |filename, body|
+  in_proving_grounds do
+    ensure_dir File.dirname filename
+    File.write filename, interpret_curlies(body)
+  end
+end
+
+When 'I run "$command"' do |command|
+  in_proving_grounds { cmdline command }
+end
+
+Then /^it exits with a status of (\d+)$/ do |status|
+  last_cmdline.exitstatus.should eq(status.to_i), "Expected #{status}, got #{last_cmdline.exitstatus}. STDERR: #{last_cmdline.stderr}"
+end
+
+Then /^it exits with a status of (\d+), and a stderr of:$/ do |status, stderr|
+  last_cmdline.exitstatus.should == status.to_i
+  last_cmdline.stderr.chomp.should == interpret_curlies(stderr).chomp
+end
+
+Then /^it prints nothing to (stdout|stderr)$/ do |descriptor|
+  last_cmdline.send(descriptor).should == ''
+end
+
+Then 'I see the file "$filename"' do |filename|
+  in_proving_grounds { File.exist?(filename).should be_true }
+end
+
+Then 'I see the file "$filename":' do |filename, body|
+  in_proving_grounds do
+    File.exist?(filename).should be_true, "#{filename} doesn't exist"
+
+    body && strip_trailing_whitespace(File.read(filename)).should ==
+            strip_trailing_whitespace(body)
+  end
+end
+
+Then 'I do not see the file "$filename"' do |filename|
+  in_proving_grounds { File.exist?(filename).should be_false }
+end
+
+And 'I pry' do
+  require 'pry'
+  binding.pry
+end
+

data/features/support/env.rb

@@ -0,0 +1,76 @@
+require 'simplecov'
+
+require 'fileutils'
+module ProvingGrounds
+  def proving_grounds_dir
+    File.expand_path "../../proving_grounds", __FILE__
+  end
+
+  def in_proving_grounds(&block)
+    make_proving_grounds
+    FileUtils.cd(proving_grounds_dir) { return block.call }
+  end
+
+  def make_proving_grounds
+    FileUtils.mkdir_p proving_grounds_dir
+  end
+
+  def remove_proving_grounds
+    FileUtils.rm_r proving_grounds_dir
+  end
+
+  def ensure_dir(dirname)
+    FileUtils.mkdir_p dirname
+  end
+end
+
+
+module Helpers
+  def interpret_curlies(string)
+    string.gsub /{{.*?}}/ do |code|
+      code.sub! /^{{/, ''
+      code.sub! /}}$/, ''
+      eval code
+    end
+  end
+
+  def strip_trailing_whitespace(text)
+    text.gsub /\s+$/, ''
+  end
+end
+
+require 'open3'
+class CommandLine
+  module CukeHelpers
+    def cmdline(command, options={})
+      @last_cmdline = CommandLine.new(command, options)
+      @last_cmdline.execute
+      @last_cmdline
+    end
+
+    def last_cmdline
+      @last_cmdline
+    end
+  end
+
+  attr_reader :command, :options, :stderr, :stdout
+
+  def initialize(command, options={})
+    @command, @options = command, options
+  end
+
+  def execute
+    @stdout, @stderr, @status = Open3.capture3(command, @options)
+  end
+
+  def exitstatus
+    @status.exitstatus
+  end
+end
+
+ENV['PATH'] = "#{File.expand_path "../../../bin", __FILE__}:#{ENV['PATH']}"
+ENV['YO_IM_TESTING_README_SHIT_RIGHT_NOW'] = 'FOR_REALSIES'
+World ProvingGrounds
+World CommandLine::CukeHelpers
+World Helpers
+After { remove_proving_grounds }

data/lib/mountain_berry_fields.rb

@@ -0,0 +1,89 @@
+require 'deject'
+
+require 'mountain_berry_fields/version'
+require 'mountain_berry_fields/evaluator'
+require 'mountain_berry_fields/parser'
+
+# Ties everything together. It gets the file, passes it to the parser,
+# passes the result to the evaluator, and writes the file. If anything
+# goes wrong along the way, it declares the failure to the interaction
+class MountainBerryFields
+  Deject self, :interaction
+  dependency(:evaluator_class) { Evaluator }
+  dependency(:parser_class)    { Parser }
+  dependency(:file_class)      { File }
+  dependency(:dir_class)       { Dir }
+
+  def initialize(argv)
+    self.argv = argv
+    self.full_filename = File.expand_path filename if filename
+  end
+
+  def execute
+    return false if missing_input_file? || invalid_filename? || nonexistent_file?
+    execute!
+  end
+
+  def evaluator
+    @evaluator ||= evaluator_class.new parser.parse
+  end
+
+  def parser
+    @parser ||= parser_class.new  file_class.read(full_filename),
+                                  visible:   evaluator_class.visible_commands,
+                                  invisible: evaluator_class.invisible_commands
+  end
+
+private
+
+  def missing_input_file?
+    return if filename
+    interaction.declare_failure 'Please provide an input file'
+    true
+  end
+
+  def invalid_filename?
+    return if filename =~ filename_regex
+    interaction.declare_failure "#{filename.inspect} does not match #{filename_regex.inspect}"
+    true
+  end
+
+  def nonexistent_file?
+    return if file_class.exist? filename
+    interaction.declare_failure "#{File.expand_path(filename).inspect} does not exist."
+    true
+  end
+
+  def execute!
+    begin
+      if dir_class.chdir(dirname) { evaluator.tests_pass? }
+        file_class.write output_filename_for(filename), evaluator.document
+        true
+      else
+        interaction.declare_failure "FAILURE: #{evaluator.failure_name}\n#{evaluator.failure_message}"
+        false
+      end
+    rescue StandardError
+      interaction.declare_failure "#{$!.class} #{$!.message}"
+      false
+    end
+  end
+
+  attr_accessor :argv, :full_filename
+
+  def filename
+    argv.first
+  end
+
+  def dirname
+    File.dirname filename
+  end
+
+  def output_filename_for(filename)
+    filename.sub filename_regex, ''
+  end
+
+  def filename_regex
+    /\.mountain_berry_fields\b/
+  end
+end

data/lib/mountain_berry_fields/command_line_interaction.rb

@@ -0,0 +1,13 @@
+class MountainBerryFields
+
+  # Iinteractions are used by the MountainBerryFields to let the users know what's going on.
+  # This one interacts with the command line.
+  class CommandLineInteraction
+    Deject self
+    dependency(:stderr) { $stderr }
+
+    def declare_failure(failure_message)
+      stderr.puts failure_message
+    end
+  end
+end

data/lib/mountain_berry_fields/evaluator.rb

@@ -0,0 +1,90 @@
+require 'mountain_berry_fields/test'
+
+class MountainBerryFields
+
+  # This class evaluates a block of code that was emitted from the parser.
+  # It has a document that the evalutable code can append to.
+  # It implements the visible and invisible methods (see the parser for more on these)
+  # that MountainBerryFields supports.
+  #
+  # It also evaluates tests, and tracks whether they pass or fail (currently only tracking the last failure)
+  class Evaluator
+    attr_reader :to_evaluate
+
+    def initialize(to_evaluate)
+      @to_evaluate = to_evaluate
+    end
+
+    def self.visible_commands
+      [:test]
+    end
+
+    def self.invisible_commands
+      [:setup, :context]
+    end
+
+    def setup
+      setup_code << yield
+    end
+
+    def context(context_name, options={}, &block)
+      contexts[context_name] = in_context options[:context], block.call
+      return if contexts[context_name]['__CODE__']
+      raise ArgumentError, "Context #{context_name.inspect} does not have a __CODE__ block"
+    end
+
+    def contexts
+      @contexts ||= Hash.new
+    end
+
+    def setup_code
+      @setup_code ||= ''
+    end
+
+    def test(name, options={}, &block)
+      code = setup_code + in_context(options[:context], block.call.to_s)
+      test = Test.new(name, options.merge(code: code))
+      strategy = Test::Strategy.for(test.strategy).new(test.code)
+      unless strategy.pass?
+        @failing_strategy = strategy
+        @failing_test     = test
+      end
+      tests << test
+    end
+
+
+    def in_context(context_name, code)
+      return code unless context_name
+      return contexts[context_name].gsub '__CODE__', code if contexts[context_name]
+      raise NameError, "There is no context #{context_name.inspect}, only #{contexts.keys.inspect}"
+    end
+
+    def tests_pass?
+      evaluate
+      !@failing_test
+    end
+
+    def failure_name
+      @failing_test.name
+    end
+
+    def failure_message
+      @failing_strategy.failure_message
+    end
+
+    def tests
+      @tests ||= []
+    end
+
+    def document
+      evaluate
+      @document ||= ''
+    end
+
+    def evaluate
+      return if @evaluated
+      @evaluated = true
+      instance_eval to_evaluate
+    end
+  end
+end