mountain_berry_fields 1.0.0

data/lib/mountain_berry_fields/parser.rb

@@ -0,0 +1,101 @@
+require 'erubis'
+
+class MountainBerryFields
+
+  # This class takes a document with erb in it
+  # It parses the erb and gives you back a file of source code
+  # When that source code is evaluated, you get the file out.
+  # The evaluation environment is expected to provide a `document` method or local variable,
+  # which is a string that the template will be appended to.
+  #
+  # It differs from normal ERB in that you can pass it :visible and :invisible commands lists.
+  # Code inside of a block around an invisible command (method name) will not be added to the document.
+  # Any command invoked at the start of an erb block (<% and <%=) will be checked against the
+  # visible and invisible lists, if they are on either list, their block will return the
+  # text in the template that was written in the block.
+  class Parser < Erubis::Eruby
+    class Recording
+      def initialize(is_command, is_visible=true)
+        @is_command = is_command
+        @is_visible = is_visible
+      end
+
+      def command?
+        @is_command
+      end
+
+      def visible?
+        @is_visible
+      end
+
+      def recorded
+        @recorded ||= ''
+      end
+
+      def record(text)
+        recorded << text if command?
+      end
+    end
+
+    attr_accessor :visible_commands, :invisible_commands, :known_commands, :recordings
+
+    def init_generator(properties={})
+      self.recordings         = [Recording.new(false)]
+      self.visible_commands   = (properties.delete(:visible)   || []).map &:to_s
+      self.invisible_commands = (properties.delete(:invisible) || []).map &:to_s
+      self.known_commands     = visible_commands + invisible_commands
+      super
+    end
+
+    def add_preamble(src)
+      super
+    end
+
+    def add_postamble(src)
+      src << "#{@bufvar} << %(\\n) unless #{@bufvar}.end_with? %(\\n);"
+      src << "document << #{@bufvar};"
+    end
+
+    def parse
+      src
+    end
+
+    def add_text(src, text)
+      recordings.last.record text
+      super if recordings.last.visible?
+    end
+
+    def known_command?(code_with_command)
+      known_commands.include? code_with_command[/\w+/]
+    end
+
+    def visible_command?(code_with_command)
+      visible_commands.include? code_with_command[/\w+/]
+    end
+
+    def end_command?(code_with_command)
+      code_with_command =~ /\A\s*(end|})/
+    end
+
+    def add_stmt(src, code)
+      manage_recording src, code
+      super
+    end
+
+    def add_expr_literal(src, code)
+      manage_recording src, code
+      super
+    end
+
+    def manage_recording(src, code)
+      if known_command? code
+        recordings << Recording.new(true, visible_command?(code))
+      elsif end_command? code
+        recording = recordings.pop
+        src << recording.recorded.inspect << ";" if recording.command?
+      else
+        recordings << Recording.new(false)
+      end
+    end
+  end
+end

data/lib/mountain_berry_fields/rake_task.rb

@@ -0,0 +1,12 @@
+class MountainBerryFields
+  class RakeTask
+    include Rake::DSL
+
+    def initialize(task_name, input_file_name)
+      desc("Test and generate #{input_file_name}") unless ::Rake.application.last_comment
+      task task_name do
+        sh "mountain_berry_fields #{input_file_name}"
+      end
+    end
+  end
+end

data/lib/mountain_berry_fields/test.rb

@@ -0,0 +1,88 @@
+require 'open3'
+
+
+class MountainBerryFields
+
+  # Data structure to store the shit passed to the test method
+  class Test
+    attr_accessor :name, :options
+
+    def initialize(name, options)
+      self.name, self.options = name, options
+    end
+
+    def strategy
+      options[:with]
+    end
+
+    def code
+      options[:code]
+    end
+  end
+
+  # You want to run tests, amirite? So you need something that runs them.
+  # Right now that's called a strategy (expect that to change). Strategies
+  # take the code to test as a string, and then test them and return if they
+  # pass or fail.
+  #
+  # Strategies should probably be registered so that the evaluator can find them.
+  module Test::Strategy
+    @registered = {}
+
+    def self.for(name)
+      @registered.fetch name.to_s do
+        raise NameError, "#{name.inspect} is not a registered strategy, should have been in #{@registered.keys.inspect}"
+      end
+    end
+
+    def self.register(name, strategy)
+      @registered[name.to_s] = strategy
+    end
+
+    def self.unregister(name)
+      @registered.delete name.to_s
+    end
+
+    def self.registered?(name)
+      @registered.has_key? name.to_s
+    end
+
+    attr_reader :code_to_test
+
+    def initialize(code_to_test)
+      @code_to_test = code_to_test.to_s
+    end
+
+    def pass?
+      raise "unimplemented"
+    end
+
+    def failure_message
+      raise "unimplemented"
+    end
+  end
+
+
+  # checks syntax of a code example
+  class Test::RubySyntaxChecker
+    def initialize(code_to_test)
+      @code_to_test = code_to_test
+    end
+
+    def valid?
+      return @valid if defined? @valid
+      out, err, status = Open3.capture3 'ruby -c', stdin_data: @code_to_test
+      @stderr = err
+      @valid = status.exitstatus.zero?
+    end
+
+    def invalid_message
+      valid?
+      "#{@stderr.chomp}\n\noriginal file:\n#@code_to_test"
+    end
+  end
+end
+
+require 'mountain_berry_fields/test/always_fail'
+require 'mountain_berry_fields/test/always_pass'
+Gem.find_files("mountain_berry_fields/test/*").each { |path| require path }

data/lib/mountain_berry_fields/test/always_fail.rb

@@ -0,0 +1,21 @@
+class MountainBerryFields
+  class Test
+
+    # Red. Red. Refactor anyway, cuz fuck it.
+    class AlwaysFail
+      Strategy.register :always_fail, self
+
+      include Strategy
+
+      def pass?
+        eval code_to_test
+      ensure
+        return false
+      end
+
+      def failure_message
+        "THIS STRATEGY ALWAYS FAILS"
+      end
+    end
+  end
+end

data/lib/mountain_berry_fields/test/always_pass.rb

@@ -0,0 +1,19 @@
+class MountainBerryFields
+  class Test
+
+    # Ask it if it passes
+    #
+    # (it does)
+    class AlwaysPass
+      Strategy.register :always_pass, self
+
+      include Strategy
+
+      def pass?
+        eval code_to_test
+      ensure
+        return true
+      end
+    end
+  end
+end

data/lib/mountain_berry_fields/version.rb

@@ -0,0 +1,3 @@
+class MountainBerryFields
+  VERSION = "1.0.0"
+end

data/mountain_berry_fields.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/mountain_berry_fields/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Josh Cheek"]
+  gem.email         = ["josh.cheek@gmail.com"]
+  gem.description   = %q{Test code samples embedded in files like readmes}
+  gem.summary       = %q{Test code samples embedded in files like readmes}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "mountain_berry_fields"
+  gem.require_paths = ["lib"]
+  gem.version       = MountainBerryFields::VERSION
+
+  gem.add_runtime_dependency 'erubis',                                   '= 2.7.0'
+  gem.add_runtime_dependency 'deject',                                   '~> 0.2.2'
+
+  gem.add_development_dependency 'mountain_berry_fields-magic_comments', '~> 1.0.0'
+  gem.add_development_dependency 'mountain_berry_fields-rspec',          '~> 1.0.0'
+  gem.add_development_dependency 'surrogate',                            '~> 0.5.1'
+  gem.add_development_dependency 'rspec',                                '~> 2.10.0'
+  gem.add_development_dependency 'cucumber',                             '~> 1.2.0'
+  gem.add_development_dependency 'simplecov',                            '~> 0.6.4'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'pry'
+end

data/readme_helper.rb

@@ -0,0 +1,205 @@
+# Okay look, I know this code is scary, and you're like "I don't want to
+# have to do that shit for my project".
+#
+# But it's not likely that you will, I didn't have to when I did Deject or Surrogate,
+# it's just that this code is embedding readmes in readmes, so they're not really code samples.
+
+Strategy = MountainBerryFields::Test::Strategy
+
+# maybe this should be pulled into its own gem? it seems generally useful
+Strategy.register :install_dep, Class.new {
+  def initialize(install_string)
+    @prompt, @gem_command, @install_command, @dependency_name = install_string.split
+    @gemspec = Gem::Specification.load 'mountain_berry_fields.gemspec'
+  end
+
+  def pass?
+    !failure_message
+  end
+
+  def failure_message
+    return %'prompt marker is "$", not #{@prompt.inspect}' unless @prompt == '$'
+    return %'gem command is "gem", not #{@gem_command.inspect}' unless @gem_command == 'gem'
+    return %'install command is "install", not #{@install_command.inspect}' unless @install_command == 'install'
+    return %'development dependencies are #{development_dependencies.inspect} WTF is #{@dependency_name.inspect}?' unless is_dependency?
+  end
+
+  def development_dependencies
+    @gemspec.development_dependencies.map &:name
+  end
+
+  def is_dependency?
+    development_dependencies.include? @dependency_name
+  end
+}
+
+
+require 'tmpdir'
+require 'open3'
+Strategy.register :mbf_example, Class.new {
+  include Strategy
+
+  attr_accessor :input_filename, :input_code, :command_line_invocation, :output_filename, :output_code, :expected_failure, :failure_message
+
+  def pass?
+    parse
+    happy_path && sad_path
+  end
+
+  def failure_message
+    @failure_message
+  end
+
+  def happy_path
+    happy_lib_code = '
+    <% setup do %>
+      MyLibName = Struct.new :data do
+        def result
+          "some cool result"
+        end
+      end
+    <% end %>
+    '
+    Dir.mktmpdir 'happy_path' do |dir|
+      Dir.chdir dir do
+        File.write input_filename, happy_lib_code + input_code
+        out, err, status = Open3.capture3 command_line_invocation
+        @failure_message = err
+        status.success? && File.exist?(dir + "/" + output_filename)
+      end
+    end
+  end
+
+  def sad_path
+    sad_lib_code = '
+    <% setup do %>
+      MyLibName = Struct.new :data do
+        def result
+          "some unexpected result"
+        end
+      end
+    <% end %>
+    '
+    Dir.mktmpdir 'happy_path' do |dir|
+      Dir.chdir dir do
+        File.write input_filename, sad_lib_code + input_code
+        oout, err, status = Open3.capture3 command_line_invocation
+        self.failure_message = "Error should have been #{expected_failure.inspect}, but was #{err.inspect}"
+        result =( expected_failure == err)
+        result
+      end
+    end
+  end
+
+  # all this parsing is overly simple and a bit fragile, but good enough
+  # revisit it after v2, should have something in place so we don't have to parse
+  # the text, but can instead talk directly to the test or something
+  def parse
+    results = code_to_test.split(/^(?=\S)/)
+    parse_setup      results.shift
+    parse_happy_path results.shift
+    parse_sad_path   results.shift
+  end
+
+  def parse_setup(raw_setup)
+    lines = raw_setup.lines.to_a
+    self.input_filename = lines.shift[/`(.*?)`/, 1]
+    lines.shift
+    lines.pop
+    self.input_code = lines.join.gsub(/^ {4}/, '')
+  end
+
+  def parse_happy_path(raw_happy_path)
+    lines = raw_happy_path.lines.to_a
+    first_line = lines.shift
+    self.command_line_invocation, self.output_filename = first_line.scan(/`[^`]*`/).map { |text| text[1...-1] }
+    command_line_invocation.sub! /^\$\s+/, ''
+    lines.shift
+    lines.pop
+    self.output_code = lines.join.gsub(/^ {4}/, '')
+  end
+
+  def parse_sad_path(raw_sad_path)
+    self.expected_failure = raw_sad_path.lines.drop(2).join.gsub(/^ {4}/, '')
+  end
+}
+
+
+Strategy.register :generic_mbf, Class.new {
+  attr_reader :failure_message
+
+  def initialize(code_to_test, filename='f.mountain_berry_fields', invocation="mountain_berry_fields #{filename}", &do_in_dir)
+    @code_to_test, @filename, @invocation, @do_in_dir =
+     code_to_test,  filename,  invocation,  do_in_dir
+  end
+
+  def pass?
+    @pass ||= Dir.mktmpdir 'setup_block' do |dir|
+      Dir.chdir dir do
+        @do_in_dir.call if @do_in_dir
+        File.write @filename, @code_to_test
+        out, @failure_message, status = Open3.capture3 @invocation
+        status.success?
+      end
+    end
+  end
+}
+
+
+Strategy.register :requires_lib, Class.new {
+  attr_accessor :setup_block
+
+  def initialize(setup_block)
+    self.setup_block = setup_block
+  end
+
+  def pass?
+    strategy.pass?
+  end
+
+  def failure_message
+    strategy.failure_message
+  end
+
+  def strategy
+    @strategy ||= Strategy.for(:generic_mbf).new(code_to_test) do
+      Dir.mkdir 'lib'
+      File.write 'lib/my_lib_name.rb', 'MyLibName = 12'
+    end
+  end
+
+  def code_to_test
+    %'#{setup_block}
+      <% test "loaded", with: :magic_comments do %>
+      MyLibName # => 12
+      <% end %>'
+  end
+}
+
+Strategy.register :task_named_mbf, Class.new {
+  def initialize(task_definition)
+    @task_definition = task_definition
+  end
+
+  def pass?
+    require 'rake'
+    eval @task_definition
+    Rake::Task[:mbf] rescue nil
+  end
+
+  def failure_message
+    "No task named :mbf"
+  end
+}
+
+Strategy.register :register_your_strategy, Class.new {
+  def initialize(registration_code)
+    @registration_code = registration_code
+  end
+
+  def pass?
+    eval "YourStrategy = Object.new"
+    eval @registration_code
+    Strategy.for(:your_strategy) == YourStrategy
+  end
+}