punchout 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a28f37c6b1f21bf3390778bb0104757e9b1c2e81
+  data.tar.gz: de7232745143ba047eb6220f26f4e61e2def2947
+SHA512:
+  metadata.gz: 4f2177f1aaceb39aeac074f449d4433fde323a6096348503abcc64e6d5f0030393d70a3183745424b41a5ebbd76a89f51f2c3a5b559267937faee0db4e3d9d33
+  data.tar.gz: 23d3be7c90f197b9b6e9412cfc00216ec2ceb61948b64d03a09232f836a9504751a2b155937e81076d549bc23a6921da925ac28b9afe291337359d4e44749978

data/lib/punchout.rb

@@ -0,0 +1,20 @@
+require 'punchout/puncher'
+require 'punchout/matcher/class'
+
+module Punchout
+  module Punchable
+    def punchable?
+      true
+    end
+
+    attr_accessor :matcher
+
+    def puncher
+      @puncher ||= Puncher.new
+    end
+
+    def punch(obj)
+      puncher.punch(obj)
+    end
+  end
+end

data/lib/punchout/matcher.rb

@@ -0,0 +1,17 @@
+require 'punchout/puncher/matchable'
+
+module Punchout
+  class Matcher
+    def initialize(subject)
+      @subject = subject
+    end
+
+    def punches(thing)
+      Punchout::Puncher::Matchable.new(self, thing)
+    end
+
+    def conflicts?(other)
+      false
+    end
+  end
+end

data/lib/punchout/matcher/ancestry.rb

@@ -0,0 +1,16 @@
+require 'punchout/matcher'
+
+module Punchout
+  class Matcher
+    class Ancestry < Matcher
+      def conflicts?(matcher)
+
+      end
+
+      def matches?(candidate)
+        (@subject >= candidate.class) == true
+      end
+    end
+  end
+end
+

data/lib/punchout/matcher/class.rb

@@ -0,0 +1,16 @@
+require 'punchout/matcher'
+
+module Punchout
+  class Matcher
+    class Klass < Matcher
+      def conflicts?(matcher)
+        false
+      end
+
+      def matches?(candidate)
+        @subject == candidate.class
+      end
+    end
+  end
+end
+

data/lib/punchout/matcher/equal.rb

@@ -0,0 +1,16 @@
+require 'punchout/matcher'
+
+module Punchout
+  class Matcher
+    class Equal < Matcher
+      def conflicts?(matcher)
+
+      end
+
+      def matches?(candidate)
+        @subject == candidate
+      end
+    end
+  end
+end
+

data/lib/punchout/matcher/progeny.rb

@@ -0,0 +1,15 @@
+require 'punchout/matcher'
+
+module Punchout
+  class Matcher
+    class Progeny < Matcher
+      def conflicts?(matcher)
+
+      end
+
+      def matches?(candidate)
+        (@subject <= candidate.class) == true
+      end
+    end
+  end
+end

data/lib/punchout/puncher.rb

@@ -0,0 +1,32 @@
+require 'punchout/puncher/matchable'
+require 'punchout/puncher/matchables'
+
+module Punchout
+  class Puncher
+    def initialize
+      @matchables = Matchables.new
+    end
+
+    def add(matchable)
+      if !matchable.kind_of?(Matchable)
+        raise
+      end
+
+      @matchables.add(matchable)
+    end
+
+    def can_punch?(type)
+      @matchables.include?(type)
+    end
+
+    def punch(type)
+
+      match = @matchables.find(type)
+
+      if match
+        match.thing
+      end
+    end
+  end
+end
+

data/lib/punchout/puncher/matchable.rb

@@ -0,0 +1,20 @@
+module Punchout
+  class Puncher
+    class Matchable
+      def initialize(matcher, thing)
+        @matcher = matcher
+        @thing = thing
+      end
+
+      attr_reader :thing
+
+      def matches?(subject)
+        @matcher.matches?(subject)
+      end
+
+      def conflicts?(other)
+        false
+      end
+    end
+  end
+end

data/lib/punchout/puncher/matchable/resolver.rb

@@ -0,0 +1,15 @@
+module Punchout
+  class Puncher
+    class Matchable
+      class Resolver
+        def initialize(matcher)
+          @matcher = matcher
+        end
+
+        def build(thing)
+          Matchable.new(@matcher,thing)
+        end
+      end
+    end
+  end
+end

data/lib/punchout/puncher/matchables.rb

@@ -0,0 +1,36 @@
+module Punchout
+  class Puncher
+    class Matchables
+      def initialize
+        @matchables = []
+      end
+
+      def add(matchable)
+        if conflicts?(matchable)
+          raise
+        end
+        @matchables << matchable
+      end
+
+      def include?(type)
+        @matchables.any? do |p|
+          p.matches?(type)
+        end
+      end
+
+      def find(type)
+        @matchables.find do |p|
+          p.matches?(type)
+        end
+      end
+
+      private
+
+      def conflicts?(matchable)
+        @matchables.any? do |m|
+          m.conflicts?(matchable) || matchable.conflicts?(m)
+        end
+      end
+    end
+  end
+end

data/test/integration/punchout_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../test_helper', __FILE__)
+
+require 'punchout'
+require 'punchout/matcher/class'
+
+class Punchout::Test < ActiveSupport::TestCase
+  setup do
+    @punchout_klass = Class.new do
+      include Punchout::Punchable
+    end
+
+    @pairings = 3.times.map {
+      {match: Class.new, punchable: Class.new}
+    }
+  end
+
+  test "#punch" do
+    punchout = @punchout_klass.new
+    puncher = punchout.puncher
+
+    @pairings.each do |p|
+      matcher = Punchout::Matcher::Klass.new(p[:match])
+
+      matchable = matcher.punches(p[:punchable])
+
+      puncher.add(matchable)
+    end
+
+    expected = @pairings.first
+
+    expected_matching_instance = expected[:match].new
+
+    result = puncher.can_punch?(expected_matching_instance)
+    assert result, "#{punchout.puncher.inspect} CAN NOT PUNCH #{expected[:match]}"
+
+    result = puncher.punch(expected_matching_instance)
+    assert_equal expected[:punchable],result
+  end
+end

data/test/integration/test_helper.rb

@@ -0,0 +1,18 @@
+$:.push('lib')
+
+require 'coveralls'
+Coveralls.wear!
+
+if ENV["ENABLE_SIMPLE_COV"]
+  require 'simplecov'
+#  require File.expand_path('../simplecov_helper', __FILE__)
+  SimpleCov.start do
+    add_filter "test"
+    add_group 'API',          "lib"
+  end
+end
+
+require 'active_support/time'
+require 'active_support/test_case'
+require 'test/unit'
+

data/test/unit/punchout/matcher/ancestry_test.rb

@@ -0,0 +1,46 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+require 'punchout/matcher/ancestry'
+
+class Punchout::Matcher::AncestryTest < ActiveSupport::TestCase
+  setup do
+    @ancestor_klass = Class.new
+
+    @base_klass = Class.new(@ancestor_klass)
+
+    @derived_klass = Class.new(@base_klass)
+
+    @independent_klass = Class.new
+
+    @mock_thing = mock
+  end
+
+  test "#match none" do
+    matcher = Punchout::Matcher::Ancestry.new(@derived_klass)
+    result = matcher.matches?(@independent_klass.new)
+
+    assert_equal false, result
+  end
+
+  test "#match should match equivalence" do
+    matcher = Punchout::Matcher::Ancestry.new(@base_klass)
+    result = matcher.matches?(@base_klass.new)
+
+    assert_equal true, result
+  end
+
+  test "#match should match descendant" do
+    matcher = Punchout::Matcher::Ancestry.new(@base_klass)
+    result = matcher.matches?(@derived_klass.new)
+
+    assert_equal true, result
+  end
+
+  test "#match should not match ancestor" do
+    matcher = Punchout::Matcher::Ancestry.new(@derived_klass)
+    result = matcher.matches?(@base_klass.new)
+
+    assert_equal false, result
+  end
+end
+

data/test/unit/punchout/matcher/class_test.rb

@@ -0,0 +1,48 @@
+
+require File.expand_path('../../../test_helper', __FILE__)
+
+require 'punchout/matcher/class'
+
+class Punchout::Matcher::KlassTest < ActiveSupport::TestCase
+  setup do
+    @ancestor_klass = Class.new
+
+    @base_klass = Class.new(@ancestor_klass)
+
+    @derived_klass = Class.new(@base_klass)
+
+    @independent_klass = Class.new
+
+    @mock_thing = mock
+  end
+
+  test "#match none" do
+    matcher = Punchout::Matcher::Klass.new(@derived_klass)
+    result = matcher.matches?(@independent_klass.new)
+
+    assert_equal false, result
+  end
+
+  test "#match should match equivalence" do
+    matcher = Punchout::Matcher::Klass.new(@base_klass)
+    result = matcher.matches?(@base_klass.new)
+
+    assert_equal true, result
+  end
+
+  test "#match should match descendant" do
+    matcher = Punchout::Matcher::Klass.new(@base_klass)
+    result = matcher.matches?(@derived_klass.new)
+
+    assert_equal false, result
+  end
+
+  test "#match should not match ancestor" do
+    matcher = Punchout::Matcher::Klass.new(@derived_klass)
+    result = matcher.matches?(@base_klass.new)
+
+    assert_equal false, result
+  end
+end
+
+

data/test/unit/punchout/matcher/equal_test.rb

@@ -0,0 +1,17 @@
+
+require File.expand_path('../../../test_helper', __FILE__)
+
+require 'punchout/matcher/equal'
+
+class Punchout::Matcher::EqualTest < ActiveSupport::TestCase
+  test "#match none" do
+    matcher = Punchout::Matcher::Equal.new("foo")
+    assert_equal false, matcher.matches?("bar")
+  end
+
+  test "#match should match equivalence" do
+    matcher = Punchout::Matcher::Equal.new("foo")
+    assert_equal true, matcher.matches?("foo")
+  end
+
+end

data/test/unit/punchout/matcher/progeny_test.rb

@@ -0,0 +1,47 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+require 'punchout/matcher/progeny'
+
+class Punchout::Matcher::ProgenyTest < ActiveSupport::TestCase
+  setup do
+    @ancestor_klass = Class.new
+
+    @base_klass = Class.new(@ancestor_klass)
+
+    @derived_klass = Class.new(@base_klass)
+
+    @independent_klass = Class.new
+    
+    @mock_thing = mock
+  end
+
+  test "#match none" do
+    matcher = Punchout::Matcher::Progeny.new(@derived_klass)
+    result = matcher.matches?(@independent_klass.new)
+
+    assert_equal false, result
+  end
+
+  test "#match should match equivalence" do
+    matcher = Punchout::Matcher::Progeny.new(@base_klass)
+    result = matcher.matches?(@base_klass.new)
+
+    assert_equal true, result
+  end
+
+  test "#match should match descendant" do
+    matcher = Punchout::Matcher::Progeny.new(@base_klass)
+    result = matcher.matches?(@derived_klass.new)
+
+    assert_equal false, result
+  end
+
+  test "#match should not match ancestor" do
+    matcher = Punchout::Matcher::Progeny.new(@derived_klass)
+    result = matcher.matches?(@base_klass.new)
+
+    assert_equal true, result
+  end
+end
+
+

data/test/unit/punchout/matcher_test.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+require 'punchout/matcher'
+
+class Punchout::MatcherTest < ActiveSupport::TestCase
+  setup do
+    @mock_subject = mock
+    @matcher = Punchout::Matcher.new(@mock_subject)
+  end
+
+  test "#punches" do
+    mock_thing = mock
+
+    mock_matchable = mock
+
+    Punchout::Puncher::Matchable.expects(:new).returns(mock_matchable)
+
+    result = @matcher.punches(mock_thing)
+
+    assert_equal result, mock_matchable
+  end
+end

data/test/unit/punchout/puncher/matchable_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+require 'punchout/puncher/matchable'
+
+class Punchout::Puncher::MatchableTest < ActiveSupport::TestCase
+  test "#matches? true" do
+    mock_matcher = mock
+    mock_thing = mock
+
+    mock_matcher.expects(:matches?).with(mock_thing).returns(true)
+    matchable = Punchout::Puncher::Matchable.new(mock_matcher, mock_thing)
+
+    result = matchable.matches?(mock_thing)
+
+    assert_equal true, result
+  end
+
+  test "#matches? false" do
+    mock_matcher = mock
+    mock_thing = mock
+
+    mock_matcher.expects(:matches?).with(mock_thing).returns(false)
+    matchable = Punchout::Puncher::Matchable.new(mock_matcher, mock_thing)
+
+    result = matchable.matches?(mock_thing)
+
+    assert_equal false, result
+  end
+end

data/test/unit/punchout/puncher/matchables_test.rb

@@ -0,0 +1,68 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+require 'punchout/puncher/matchables'
+
+class Punchout::Puncher::MatchablesTest < ActiveSupport::TestCase
+  setup do
+
+    @mock_matchables = 5.times.map {|x|
+      mock_matchable = mock
+      mock_matchable.expects(:conflicts?).at_least_once.returns(false)
+      mock_matchable
+    }
+
+    @matchables = Punchout::Puncher::Matchables.new
+
+    @mock_matchables.each {|p|
+      @matchables.add(p)
+    }
+
+    @mock_type = mock
+  end
+
+  test '#include? no match' do
+    @mock_matchables.each {|p|
+      p.expects(:matches?).with(@mock_type).returns(false)
+    }
+
+    result = @matchables.include?(@mock_type)
+
+    assert_equal false, result
+  end
+
+  test '#include? match located' do
+    @mock_matchables.take(4).each {|p|
+      p.expects(:matches?).with(@mock_type).returns(false)
+    }
+
+
+    @mock_matchables.last.expects(:matches?).with(@mock_type).returns(true)
+
+    result = @matchables.include?(@mock_type)
+
+    assert_equal true, result
+  end
+
+  test '#fetch no match' do
+    @mock_matchables.each {|p|
+      p.expects(:matches?).with(@mock_type).returns(false)
+    }
+
+    result = @matchables.find(@mock_type)
+
+    assert_equal nil, result
+  end
+
+  test '#fetch match located' do
+    @mock_matchables.take(4).each {|p|
+      p.expects(:matches?).with(@mock_type).returns(false)
+    }
+
+
+    @mock_matchables.last.expects(:matches?).with(@mock_type).returns(true)
+
+    result = @matchables.find(@mock_type)
+
+    assert_equal @mock_matchables.last, result
+  end
+end

data/test/unit/punchout/puncher_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+require 'punchout/puncher'
+
+class Punchout::PuncherTest < ActiveSupport::TestCase
+  setup do
+
+    @mock_matchables = mock
+
+    @puncher = Punchout::Puncher.new
+
+    @mock_type = mock
+  end
+
+  test '#punch no match' do
+    @mock_matchables.expects(:find).with(@mock_type).returns(nil)
+
+    @puncher.instance_variable_set(:@matchables, @mock_matchables)
+
+    result = @puncher.punch(@mock_type)
+
+    assert_equal nil, result
+  end
+
+  test '#punch match located' do
+    mock_matchable = mock
+
+    @mock_matchables.expects(:find).with(@mock_type).returns(mock_matchable)
+
+    mock_thing = mock
+    mock_matchable.expects(:thing).returns(mock_thing)
+
+    @puncher.instance_variable_set(:@matchables, @mock_matchables)
+
+    result = @puncher.punch(@mock_type)
+
+    assert_equal mock_thing, result
+  end
+end

data/test/unit/punchout_test.rb

@@ -0,0 +1,74 @@
+require File.expand_path('../test_helper', __FILE__)
+
+require 'punchout'
+
+class Punchout::PunchableTest < ActiveSupport::TestCase
+  test "#include" do
+    @klass = Class.new do
+      include Punchout::Punchable
+    end
+  end
+
+  test "#puncher greenfield" do
+    @klass = Class.new do
+      include Punchout::Punchable
+    end
+
+    instance = @klass.new
+
+    mock_matcher_klass = mock
+
+    mock_puncher = mock
+    Punchout::Puncher.expects(:new).returns(mock_puncher)
+
+    instance.matcher = mock_matcher_klass
+    
+    result = instance.puncher
+
+    assert_equal mock_puncher, result
+  end
+
+  test "#puncher cached" do
+    @klass = Class.new do
+      include Punchout::Punchable
+    end
+
+    instance = @klass.new
+
+    mock_matcher_klass = mock
+
+    mock_puncher = mock
+
+    instance.matcher = mock_matcher_klass
+    instance.instance_variable_set(:@puncher, mock_puncher)
+    
+    result = instance.puncher
+
+    assert_equal mock_puncher, result
+  end
+
+  test "#punch" do
+    @klass = Class.new do
+      include Punchout::Punchable
+    end
+
+    instance = @klass.new
+
+    mock_matcher_klass = mock
+
+    mock_puncher = mock
+
+    instance.matcher = mock_matcher_klass
+    instance.instance_variable_set(:@puncher, mock_puncher)
+
+    mock_obj = mock
+
+    mock_punched = mock
+    mock_puncher.expects(:punch).with(mock_obj).returns(mock_punched)
+    
+    result = instance.punch(mock_obj)
+
+    assert_equal mock_punched, result
+  end
+end
+

data/test/unit/test_helper.rb

@@ -0,0 +1,18 @@
+$:.push('lib')
+
+require 'coveralls'
+Coveralls.wear!
+
+if ENV["ENABLE_SIMPLE_COV"]
+  require 'simplecov'
+#  require File.expand_path('../simplecov_helper', __FILE__)
+  SimpleCov.start do
+    add_filter "test"
+    add_group 'API',          "lib"
+  end
+end
+
+require 'active_support/time'
+require 'active_support/test_case'
+require 'test/unit'
+

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: punchout
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Ed Carrel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A flexible implementation of the Registry pattern, with an extensible
+  finder/matcher mechanism.
+email:
+- edward@carrel.org
+- ed@pocketchange.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/punchout/matcher/ancestry.rb
+- lib/punchout/matcher/class.rb
+- lib/punchout/matcher/equal.rb
+- lib/punchout/matcher/progeny.rb
+- lib/punchout/matcher.rb
+- lib/punchout/puncher/matchable/resolver.rb
+- lib/punchout/puncher/matchable.rb
+- lib/punchout/puncher/matchables.rb
+- lib/punchout/puncher.rb
+- lib/punchout.rb
+- test/integration/punchout_test.rb
+- test/integration/test_helper.rb
+- test/unit/punchout/matcher/ancestry_test.rb
+- test/unit/punchout/matcher/class_test.rb
+- test/unit/punchout/matcher/equal_test.rb
+- test/unit/punchout/matcher/progeny_test.rb
+- test/unit/punchout/matcher_test.rb
+- test/unit/punchout/puncher/matchable_test.rb
+- test/unit/punchout/puncher/matchables_test.rb
+- test/unit/punchout/puncher_test.rb
+- test/unit/punchout_test.rb
+- test/unit/test_helper.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.10
+signing_key: 
+specification_version: 4
+summary: A flexible registry pattern gem
+test_files: []
+has_rdoc: