hero 0.1.3 → 0.1.5

data/Gemfile

@@ -1,6 +1,8 @@
 source :rubygems
 
-gem "rspec", :group => :test
-gem "grumpy_old_man", :group => :test
-gem "pry", :groups => [:development, :test]
-gem "pry_debug", :groups => [:development, :test]
+group :development do
+  gem "micro_test", "0.3.0.rc4"
+  gem "micro_mock"
+  gem "pry"
+  gem "pry-stack_explorer"
+end

data/Gemfile.lock

@@ -1,31 +1,30 @@
 GEM
   remote: http://rubygems.org/
   specs:
+    binding_of_caller (0.6.8)
+    celluloid (0.12.3)
+      facter (>= 1.6.12)
+      timers (>= 1.0.0)
     coderay (1.0.7)
-    diff-lcs (1.1.3)
-    grumpy_old_man (0.1.2)
+    facter (1.6.14)
     method_source (0.8)
+    micro_mock (0.0.8)
+    micro_test (0.3.0.rc4)
+      celluloid
     pry (0.9.10)
       coderay (~> 1.0.5)
       method_source (~> 0.8)
       slop (~> 3.3.1)
-    pry_debug (0.0.1)
-      pry (~> 0.9.0)
-    rspec (2.11.0)
-      rspec-core (~> 2.11.0)
-      rspec-expectations (~> 2.11.0)
-      rspec-mocks (~> 2.11.0)
-    rspec-core (2.11.1)
-    rspec-expectations (2.11.2)
-      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.11.2)
+    pry-stack_explorer (0.4.7)
+      binding_of_caller (~> 0.6.8)
     slop (3.3.2)
+    timers (1.0.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  grumpy_old_man
+  micro_mock
+  micro_test (= 0.3.0.rc4)
   pry
-  pry_debug
-  rspec
+  pry-stack_explorer

data/README.md

@@ -213,3 +213,13 @@ Hero::Formula[:log_example].run([])
 # I, [2012-08-26T11:37:22.267282 #76676]  INFO -- : HERO before log_example -> third_step Context: [1, 2] Options: {}
 # I, [2012-08-26T11:37:22.267333 #76676]  INFO -- : HERO after  log_example -> third_step Context: [1, 2, 3] Options: {}
 ```
+
+## Run the Tests
+
+```bash
+$ gem install hero
+$ gem unpack hero
+$ cd hero-VERSION
+$ bundle
+$ mt
+```

data/lib/hero/version.rb

@@ -1,3 +1,3 @@
 module Hero
-  VERSION = "0.1.3"
+  VERSION = "0.1.5"
 end

data/test/formula_test.rb

@@ -0,0 +1,236 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class FormulaTest < MicroTest::Test
+
+  before do
+    Hero.logger = nil
+    Hero::Formula.reset
+  end
+
+  test "should not allow anonymous steps" do
+    err = nil
+    begin
+      Hero::Formula[:test_formula].add_step() {}
+    rescue ArgumentError
+      err = $!
+    end
+    assert err.is_a?(ArgumentError)
+  end
+
+  test "should allow unnamed Class steps" do
+    step = MicroMock.make
+    step.stub(:call) {}
+    Hero::Formula[:test_formula].add_step step
+    assert Hero::Formula[:test_formula].steps.map{|s| s.first}.first =~ /MicroMock/
+    assert Hero::Formula[:test_formula].steps.map{|s| s.last}.include?(step)
+  end
+
+  test "should allow named Class steps" do
+    step = MicroMock.make
+    step.stub(:call) {}
+    Hero::Formula[:test_formula].add_step :foo, step
+    assert Hero::Formula[:test_formula].steps.map{|s| s.first}.include?(:foo)
+    assert Hero::Formula[:test_formula].steps.map{|s| s.last}.include?(step)
+  end
+
+  test "should allow unnamed instance steps" do
+    step = MicroMock.make.new
+    step.stub(:call) {}
+    Hero::Formula[:test_formula].add_step step
+    names = Hero::Formula[:test_formula].steps.map{|s| s.first}
+    steps = Hero::Formula[:test_formula].steps.map{|s| s.last}
+    steps.each { |s| assert s.is_a? MicroMock }
+    assert names.first =~ /MicroMock/i
+    assert steps.include?(step)
+  end
+
+  test "should allow named instance steps" do
+    step = MicroMock.make.new
+    step.stub(:call) {}
+    Hero::Formula[:test_formula].add_step :foo, step
+    names = Hero::Formula[:test_formula].steps.map{|s| s.first}
+    steps = Hero::Formula[:test_formula].steps.map{|s| s.last}
+    steps.each { |s| assert s.is_a? MicroMock }
+    assert names.include?(:foo)
+    assert steps.include?(step)
+  end
+
+  test "should create a named class" do
+    Hero::Formula[:my_formula]
+    assert Object.const_defined?("HeroFormulaMyFormula")
+    assert Hero::Formula[:my_formula].class.name == "HeroFormulaMyFormula"
+    assert Hero::Formula[:my_formula].is_a? HeroFormulaMyFormula
+  end
+
+  test "should safely create a named class" do
+    Hero::Formula["A long and cr@zy f0rmul@ name ~12$%"]
+    assert Hero::Formula.const_defined?("HeroFormulaALongAndCrzyFrmulName")
+  end
+
+  test "should support reset" do
+    Hero::Formula.register(:test_formula)
+    assert Hero::Formula.count == 1
+    Hero::Formula.reset
+    assert Hero::Formula.count == 0
+  end
+
+  test "should support registering a formula" do
+    Hero::Formula.register(:test_formula)
+    assert Hero::Formula.count == 1
+    assert Hero::Formula[:test_formula].is_a? Hero::Formula
+  end
+
+  test "should auto register formulas" do
+    Hero::Formula[:test_formula]
+    assert Hero::Formula.count == 1
+    assert Hero::Formula[:test_formula].is_a? Hero::Formula
+  end
+
+  test "should support registering N number of formulas" do
+    10.times { |i| Hero::Formula.register("example_#{i}") }
+    assert Hero::Formula.count == 10
+  end
+
+  test "should unregister formula observers on reset" do
+    formula = Hero::Formula[:test_formula]
+    assert Hero::Formula.count == 1
+    formula.add_step(:one) {}
+    assert formula.count_observers == 1
+    Hero::Formula.reset
+    assert Hero::Formula.count == 0
+    assert formula.count_observers == 0
+  end
+
+  test "should publish all formulas" do
+    Hero::Formula[:first].add_step(:one) {}
+    Hero::Formula[:first].add_step(:two) {}
+    Hero::Formula[:first].add_step(:three) {}
+    Hero::Formula[:first].add_step(:four) {}
+
+    Hero::Formula[:second].add_step(:one) {}
+    Hero::Formula[:second].add_step(:two) {}
+    Hero::Formula[:second].add_step(:three) {}
+    Hero::Formula[:second].add_step(:four) {}
+
+    begin
+      out = StringIO.new
+      $stdout = out
+      Hero::Formula.print
+      expected = "first\n  1. one\n  2. two\n  3. three\n  4. four\nsecond\n  1. one\n  2. two\n  3. three\n  4. four\n"
+      out.rewind
+      assert out.readlines.join == expected
+    ensure
+      $stdout = STDOUT
+    end
+  end
+
+  # describe "a registered formula" do
+  test "should support adding steps" do
+    Hero::Formula[:test_formula].add_step(:one) { }
+    assert Hero::Formula.count == 1
+    assert Hero::Formula[:test_formula].steps.length == 1
+  end
+
+  invoke_notify_method = Proc.new do |name|
+    step_ran = false
+    target = Object.new
+    Hero::Formula[:test_formula].add_step(:one) do |t, opts|
+      assert t == target
+      assert opts[:foo] == :bar
+      step_ran = true
+    end
+    Hero::Formula[:test_formula].notify(target, :foo => :bar)
+    assert step_ran
+  end
+
+  test "should support notify" do
+    instance_exec(:notify, &invoke_notify_method)
+  end
+
+  test "should support run" do
+    instance_exec(:run, &invoke_notify_method)
+  end
+
+  test "should support running step defined in a class" do
+    step = MicroMock.make.new
+    step.stub(:call) do |context, options|
+      options[:context] = context
+    end
+
+    opts = {}
+    Hero::Formula[:test_formula].add_step(:one, step)
+    Hero::Formula[:test_formula].run(:foo, opts)
+    assert opts[:context] == :foo
+  end
+
+  test "should support running multiple tests" do
+    log = {}
+    Hero::Formula[:test_formula].add_step(:one) { |o, l| l[:one] = true }
+    Hero::Formula[:test_formula].add_step(:two) { |o, l| l[:two] = true }
+    Hero::Formula[:test_formula].run(self, log)
+    assert log[:one]
+    assert log[:two]
+  end
+
+  test "should publish all steps in the formula" do
+    Hero::Formula[:test_formula].add_step(:one) {}
+    Hero::Formula[:test_formula].add_step(:two) {}
+    Hero::Formula[:test_formula].add_step(:three) {}
+    Hero::Formula[:test_formula].add_step(:four) {}
+    expected = "test_formula  1. one  2. two  3. three  4. four"
+    begin
+      out = StringIO.new
+      $stdout = out
+      Hero::Formula[:test_formula].print
+      expected = "test_formula\n  1. one\n  2. two\n  3. three\n  4. four\n"
+      out.rewind
+      assert out.readlines.join == expected
+    ensure
+      $stdout = STDOUT
+    end
+  end
+
+  test "should support logging" do
+    logger = MicroMock.make.new
+    logger.attr :buffer
+    logger.buffer = []
+    logger.stub(:info) { |value| buffer << value }
+    logger.stub(:error) { |value| buffer << value }
+    Hero.logger = logger
+
+    Hero::Formula[:test_formula].add_step(:one) { |list, opts| list << 1; opts[:step] = 1 }
+    Hero::Formula[:test_formula].add_step(:two) { |list, opts| list << 2; opts[:step] = 2 }
+    list = []
+    Hero::Formula[:test_formula].run(list, {})
+    assert Hero.logger.buffer.length == 4
+    assert "HERO before test_formula -> one Context: [] Options: {}" == Hero.logger.buffer[0]
+    assert "HERO after  test_formula -> one Context: [1] Options: {:step=>1}" == Hero.logger.buffer[1]
+    assert "HERO before test_formula -> two Context: [1] Options: {:step=>1}" == Hero.logger.buffer[2]
+    assert "HERO after  test_formula -> two Context: [1, 2] Options: {:step=>2}" == Hero.logger.buffer[3]
+  end
+
+  test "should support logging errors" do
+    logger = MicroMock.make.new
+    logger.attr :buffer
+    logger.attr(:info_count)
+    logger.attr(:error_count)
+    logger.stub(:info) { |value| buffer << value; self.info_count += 1 }
+    logger.stub(:error) { |value| buffer << value; self.error_count += 1 }
+    logger.buffer = []
+    logger.info_count = 0
+    logger.error_count = 0
+    Hero.logger = logger
+    Hero::Formula[:test_formula].add_step(:one) { |list, opts| raise Exception.new("fubar") }
+    err = nil
+    begin
+      Hero::Formula[:test_formula].run
+    rescue Exception
+      err = $!
+    end
+    assert err.is_a?(Exception)
+    assert Hero.logger.buffer.length == 2
+    assert Hero.logger.info_count == 1
+    assert Hero.logger.error_count == 1
+  end
+
+end

data/test/observer_spec.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class ObserverTest < MicroTest::Test
+  test "should support add_step" do
+    step = lambda {}
+    o = Hero::Observer.new(:example)
+    o.add_step(:one, step)
+    assert o.steps.length == 1
+    assert o.steps[0].first == :one
+    assert o.steps[0].last == step
+  end
+
+  test "should support properly handle a double add" do
+    step1 = lambda {}
+    step2 = lambda {}
+    o = Hero::Observer.new(:example)
+    o.add_step(:one, step1)
+    o.add_step(:one, step2)
+    assert o.steps.length == 1
+    assert o.steps[0].first == :one
+    assert o.steps[0].last == step2
+  end
+
+  test "should properly sort steps based on the order they were added" do
+    o = Hero::Observer.new(:example)
+    o.add_step(:one) {}
+    o.add_step(:two) {}
+    o.add_step(:three) {}
+    o.add_step(:four) {}
+    o.add_step(:one) {}
+    assert o.steps.length == 4
+    assert o.steps[0].first == :two
+    assert o.steps[1].first == :three
+    assert o.steps[2].first == :four
+    assert o.steps[3].first == :one
+  end
+end

data/{spec/spec_helper.rb → test/test_helper.rb}

@@ -1,5 +1,6 @@
-require "pry"
-require "grumpy_old_man"
+require "bundler"
+Bundler.require :default, :development
+
 Dir[File.join(File.dirname(__FILE__), "..", "lib", "*.rb")].each do |file|
   require file
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hero
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
   prerelease: 
 platform: ruby
 authors:
@@ -29,9 +29,9 @@ files:
 - Gemfile.lock
 - LICENSE.txt
 - README.md
-- spec/formula_spec.rb
-- spec/observer_spec.rb
-- spec/spec_helper.rb
+- test/formula_test.rb
+- test/observer_spec.rb
+- test/test_helper.rb
 homepage: http://hopsoft.github.com/hero/
 licenses:
 - MIT
@@ -56,6 +56,6 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: You can think of Hero as a simplified state machine.
+summary: Think of Hero as a simplified state machine.
 test_files: []
 has_rdoc: 

data/spec/formula_spec.rb

@@ -1,235 +0,0 @@
-require "spec_helper"
-
-describe Hero::Formula do
-  include GrumpyOldMan
-
-  before :each do
-    Hero.logger = nil
-    Hero::Formula.reset
-  end
-
-  it "should not allow anonymous steps" do
-    assert_raise ArgumentError do
-      Hero::Formula[:test_formula].add_step() {}
-    end
-  end
-
-  it "should allow unnamed Class steps" do
-    class MyStep
-      def self.call(*args); end
-    end
-    Hero::Formula[:test_formula].add_step MyStep
-    assert Hero::Formula[:test_formula].steps.map{|s| s.first}.include?("MyStep")
-    assert Hero::Formula[:test_formula].steps.map{|s| s.last}.include?(MyStep)
-  end
-
-  it "should allow named Class steps" do
-    class MyStep
-      def self.call(*args); end
-    end
-    Hero::Formula[:test_formula].add_step :foo, MyStep
-    assert Hero::Formula[:test_formula].steps.map{|s| s.first}.include?(:foo)
-    assert Hero::Formula[:test_formula].steps.map{|s| s.last}.include?(MyStep)
-  end
-
-  it "should allow unnamed instance steps" do
-    class MyStep
-      def call(*args); end
-    end
-    step = MyStep.new
-    Hero::Formula[:test_formula].add_step step
-    names = Hero::Formula[:test_formula].steps.map{|s| s.first}
-    steps = Hero::Formula[:test_formula].steps.map{|s| s.last}
-    steps.each { |s| assert s.is_a? MyStep }
-    assert names.include?("MyStep")
-    assert steps.include?(step)
-  end
-
-  it "should allow named instance steps" do
-    class MyStep
-      def call(*args); end
-    end
-    step = MyStep.new
-    Hero::Formula[:test_formula].add_step :foo, step
-    names = Hero::Formula[:test_formula].steps.map{|s| s.first}
-    steps = Hero::Formula[:test_formula].steps.map{|s| s.last}
-    steps.each { |s| assert s.is_a? MyStep }
-    assert names.include?(:foo)
-    assert steps.include?(step)
-  end
-
-  it "should create a named class" do
-    Hero::Formula[:my_formula]
-    assert Object.const_defined?("HeroFormulaMyFormula")
-    assert_equal Hero::Formula[:my_formula].class.name, "HeroFormulaMyFormula"
-    assert Hero::Formula[:my_formula].is_a? HeroFormulaMyFormula
-  end
-
-  it "should safely create a named class" do
-    Hero::Formula["A long and cr@zy f0rmul@ name ~12$%"]
-    assert Hero::Formula.const_defined?("HeroFormulaALongAndCrzyFrmulName")
-  end
-
-  it "should support reset" do
-    Hero::Formula.register(:test_formula)
-    assert_equal Hero::Formula.count, 1
-    Hero::Formula.reset
-    assert_equal Hero::Formula.count, 0
-  end
-
-  it "should support registering a formula" do
-    Hero::Formula.register(:test_formula)
-    assert_equal Hero::Formula.count, 1
-    assert Hero::Formula[:test_formula].is_a? Hero::Formula
-  end
-
-  it "should auto register formulas" do
-    Hero::Formula[:test_formula]
-    assert_equal Hero::Formula.count, 1
-    assert Hero::Formula[:test_formula].is_a? Hero::Formula
-  end
-
-  it "should support registering N number of formulas" do
-    10.times { |i| Hero::Formula.register("example_#{i}") }
-    assert_equal Hero::Formula.count, 10
-  end
-
-  it "should unregister formula observers on reset" do
-    formula = Hero::Formula[:test_formula]
-    assert_equal Hero::Formula.count, 1
-    formula.add_step(:one) {}
-    assert_equal formula.count_observers, 1
-    Hero::Formula.reset
-    assert_equal Hero::Formula.count, 0
-    assert_equal formula.count_observers, 0
-  end
-
-  it "should publish all formulas" do
-    Hero::Formula[:first].add_step(:one) {}
-    Hero::Formula[:first].add_step(:two) {}
-    Hero::Formula[:first].add_step(:three) {}
-    Hero::Formula[:first].add_step(:four) {}
-
-    Hero::Formula[:second].add_step(:one) {}
-    Hero::Formula[:second].add_step(:two) {}
-    Hero::Formula[:second].add_step(:three) {}
-    Hero::Formula[:second].add_step(:four) {}
-
-    begin
-      out = StringIO.new
-      $stdout = out
-      Hero::Formula.print
-      expected = "first\n  1. one\n  2. two\n  3. three\n  4. four\nsecond\n  1. one\n  2. two\n  3. three\n  4. four\n"
-      out.rewind
-      assert_equal out.readlines.join, expected
-    ensure
-      $stdout = STDOUT
-    end
-  end
-
-  describe "a registered formula" do
-    it "should support adding steps" do
-      Hero::Formula[:test_formula].add_step(:one) { }
-      assert_equal Hero::Formula.count, 1
-      assert_equal Hero::Formula[:test_formula].steps.length, 1
-    end
-
-    def invoke_notify_method(name)
-      step_ran = false
-      target = Object.new
-      Hero::Formula[:test_formula].add_step(:one) do |t, opts|
-        assert_equal t, target
-        assert_equal opts[:foo], :bar
-        step_ran = true
-      end
-      Hero::Formula[:test_formula].notify(target, :foo => :bar)
-      assert step_ran
-    end
-
-    it "should support notify" do
-      invoke_notify_method(:notify)
-    end
-
-    it "should support run" do
-      invoke_notify_method(:run)
-    end
-
-    it "should support running step defined in a class" do
-      class Step
-        def call(context, options)
-          options[:context] = context
-        end
-      end
-
-      opts = {}
-      Hero::Formula[:test_formula].add_step(:one, Step.new)
-      Hero::Formula[:test_formula].run(:foo, opts)
-      assert_equal opts[:context], :foo
-    end
-
-    it "should support running multiple tests" do
-      log = {}
-      Hero::Formula[:test_formula].add_step(:one) { |o, l| l[:one] = true }
-      Hero::Formula[:test_formula].add_step(:two) { |o, l| l[:two] = true }
-      Hero::Formula[:test_formula].run(self, log)
-      assert log[:one]
-      assert log[:two]
-    end
-
-    it "should publish all steps in the formula" do
-      Hero::Formula[:test_formula].add_step(:one) {}
-      Hero::Formula[:test_formula].add_step(:two) {}
-      Hero::Formula[:test_formula].add_step(:three) {}
-      Hero::Formula[:test_formula].add_step(:four) {}
-      expected = "test_formula  1. one  2. two  3. three  4. four"
-      begin
-        out = StringIO.new
-        $stdout = out
-        Hero::Formula[:test_formula].print
-        expected = "test_formula\n  1. one\n  2. two\n  3. three\n  4. four\n"
-        out.rewind
-        assert_equal out.readlines.join, expected
-      ensure
-        $stdout = STDOUT
-      end
-    end
-
-    it "should support logging" do
-      class TestLogger
-        attr_reader :buffer
-        def initialize; @buffer = []; end
-        def info(value); @buffer << value; end
-        alias :error :info
-      end
-      Hero.logger = TestLogger.new
-
-      Hero::Formula[:test_formula].add_step(:one) { |list, opts| list << 1; opts[:step] = 1 }
-      Hero::Formula[:test_formula].add_step(:two) { |list, opts| list << 2; opts[:step] = 2 }
-      list = []
-      Hero::Formula[:test_formula].run(list, {})
-      assert_equal Hero.logger.buffer.length, 4
-      assert_equal "HERO before test_formula -> one Context: [] Options: {}", Hero.logger.buffer[0]
-      assert_equal "HERO after  test_formula -> one Context: [1] Options: {:step=>1}", Hero.logger.buffer[1]
-      assert_equal "HERO before test_formula -> two Context: [1] Options: {:step=>1}", Hero.logger.buffer[2]
-      assert_equal "HERO after  test_formula -> two Context: [1, 2] Options: {:step=>2}", Hero.logger.buffer[3]
-    end
-
-    it "should support logging errors" do
-      class TestLogger
-        attr_reader :info_count, :error_count, :buffer
-        def initialize; @info_count = 0; @error_count = 0; @buffer = []; end
-        def info(value); @info_count += 1; @buffer << value; end
-        def error(value); @error_count += 1; @buffer << value; end
-      end
-      Hero.logger = TestLogger.new
-      Hero::Formula[:test_formula].add_step(:one) { |list, opts| raise Exception.new("fubar") }
-      assert_raise(Exception) { Hero::Formula[:test_formula].run }
-      assert_equal Hero.logger.buffer.length, 2
-      assert_equal Hero.logger.info_count, 1
-      assert_equal Hero.logger.error_count, 1
-    end
-
-  end
-
-end
-

data/spec/observer_spec.rb

@@ -1,39 +0,0 @@
-require "spec_helper"
-
-describe "Hero::Observer instance" do
-  include GrumpyOldMan
-
-  it "should support add_step" do
-    step = lambda {}
-    o = Hero::Observer.new(:example)
-    o.add_step(:one, step)
-    assert_equal o.steps.length, 1
-    assert_equal o.steps[0].first, :one
-    assert_equal o.steps[0].last, step
-  end
-
-  it "should support properly handle a double add" do
-    step1 = lambda {}
-    step2 = lambda {}
-    o = Hero::Observer.new(:example)
-    o.add_step(:one, step1)
-    o.add_step(:one, step2)
-    assert_equal o.steps.length, 1
-    assert_equal o.steps[0].first, :one
-    assert_equal o.steps[0].last, step2
-  end
-
-  it "should properly sort steps based on the order they were added" do
-    o = Hero::Observer.new(:example)
-    o.add_step(:one) {}
-    o.add_step(:two) {}
-    o.add_step(:three) {}
-    o.add_step(:four) {}
-    o.add_step(:one) {}
-    assert_equal o.steps.length, 4
-    assert_equal o.steps[0].first, :two
-    assert_equal o.steps[1].first, :three
-    assert_equal o.steps[2].first, :four
-    assert_equal o.steps[3].first, :one
-  end
-end