manacle 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4c15b4fe1557d5ec2312bb4223ac342bd6b7432d
+  data.tar.gz: e1fadac4c7532ef3533daafa688ae4171c98886b
+SHA512:
+  metadata.gz: a954e2e91239354668392b1a8cc2026a31a908f19658157cb93785890633e8ce59ef0f028e4efdd20211d0eb3a683300abe918c0f64e2c16e761ab77c4628ebb
+  data.tar.gz: ad2fce07cb9bbf6b2488d6b4265c2c424dadf3e111da3ff65ea527eecb005d268d772844912f6caeeb13e950627bc20e30f3a7dc41b7c5f9e8af6240653939f7

data/lib/manacle/constraint.rb

@@ -0,0 +1,70 @@
+require 'manacle/constraint/actuator/base'
+require 'manacle/constraint/actuator/nested'
+
+module Manacle
+  # Include this, and magically each of your decorators will get a time
+  # attached, as well as delegation to all the modules contained therein.
+  #
+  # You can then override the parts of Time you want to change.
+  module Constraint
+    module InstanceMethods
+
+      def initialize(obj)
+        if obj.nil?
+          raise
+        end
+
+        if obj.class < Manacle::Proxy
+          raise
+        end
+
+        @actuator = if obj.class < Actuator
+          obj
+        else
+          Actuator.build(obj, self)
+        end
+      end
+
+      attr_reader :actuator
+
+      def constrainables
+        self.class.constrainables
+      end
+
+      def reconstrain(obj)
+        r = @actuator.reconstrain(obj)
+        self.class.new(r)
+      end
+
+      def unconstrain
+        @actuator.unconstrain
+      end
+
+      def constrain
+        @actuator.constrain
+      end
+
+      def proxy
+        proxy_class = @actuator.proxy
+        unless proxy_class.kind_of?(Class)
+          raise "#{@actuator.inspect} is proxying non-classes: #{self.levels}"
+        end
+        proxy_class.new(self)
+      end
+      
+      def klass
+        @actuator.constrain.class
+      end
+
+      def levels
+        ["CONSTRAINT #{constraint}"] + @actuator.levels
+      end
+    end
+
+    def self.included(base)
+      base.instance_eval do
+        include InstanceMethods
+      end
+    end
+  end
+end

data/lib/manacle/constraint/actuator.rb

@@ -0,0 +1,15 @@
+module Manacle
+  module Constraint
+    module Actuator
+      module_function
+
+      def build(subject, constraint)
+        if subject.class < Constraint
+          Actuator::Nested.new(subject.actuator, constraint)
+        else
+          Actuator::Base.new(subject, constraint)
+        end
+      end
+    end
+  end
+end

data/lib/manacle/constraint/actuator/base.rb

@@ -0,0 +1,46 @@
+require 'manacle/constraint/actuator'
+
+require 'manacle/proxy/templates'
+
+module Manacle
+  # Include this, and magically each of your decorators will get a time
+  # attached, as well as delegation to all the modules contained therein.
+  #
+  # You can then override the parts of Time you want to change.
+  module Constraint
+    module Actuator
+      class Base
+
+        include Manacle::Constraint::Actuator
+
+        def initialize(val, constraint)
+          if val.kind_of?(self.class)
+            raise 
+          end
+          @val = val
+          @constraint = constraint
+        end
+
+        def unconstrain
+          @val
+        end
+
+        def levels
+          [self.class, @val.class]
+        end
+
+        def proxy
+          Manacle::Proxy::Templates.for(@val)
+        end
+
+        def reconstrain(obj)
+          self.class.new(obj, @constraint)
+        end
+
+        def constrain
+          @constrained ||= @constraint.base_constrain(@val)
+        end
+      end
+    end
+  end
+end

data/lib/manacle/constraint/actuator/nested.rb

@@ -0,0 +1,45 @@
+require 'manacle/constraint/actuator'
+
+module Manacle
+  module Constraint
+    module Actuator
+      class Nested 
+
+        include Manacle::Constraint::Actuator
+
+        def initialize(nested, constraint)
+          @nested = nested
+          @constraint = constraint
+        end
+
+        def unconstrain
+          @nested.unconstrain
+        end
+
+        def reconstrain(obj)
+          res = @nested.reconstrain(obj)
+          self.class.new(res, @constraint) 
+        end
+
+        def proxy
+          @nested.proxy
+        end
+
+        def levels
+          [self.class] + @nested.levels
+        end
+
+        def constrain
+          @constrained ||= build_constraint
+        end
+
+        private
+
+        def build_constraint
+          res = @nested.constrain
+          @constraint.base_constrain(res)
+        end
+      end
+    end
+  end
+end

data/lib/manacle/constraint/method.rb

@@ -0,0 +1,17 @@
+require 'manacle/constraint'
+
+module Manacle
+  module Constraint
+    module Method
+      def self.included(base)
+        base.instance_eval do
+          include Manacle::Constraint
+        end
+      end
+
+      def base_constrain(val)
+        val.method(constraint).call
+      end
+    end
+  end
+end

data/lib/manacle/proxy.rb

@@ -0,0 +1,31 @@
+module Manacle
+  class Proxy
+    module InstanceMethods
+      def inspect
+        "#<Manacle::Proxy::#{self.class} #<Manacle::Constraint::#{@constraint.class} #{@constraint.inspect}>"
+      end
+
+      def unproxy
+        @constraint
+      end
+
+      def constrain
+        @constrained ||= @constraint.constrain
+      end
+
+      def unconstrain
+        @constraint.unconstrain
+      end
+
+      def initialize(constraint)
+        if constraint.nil?
+          raise
+        end
+        unless constraint.kind_of?(Manacle::Constraint)
+          raise
+        end
+        @constraint = constraint
+      end
+    end
+  end
+end

data/lib/manacle/proxy/factory.rb

@@ -0,0 +1,20 @@
+require 'manacle/proxy/template'
+module Manacle
+  class Proxy
+    class Factory
+      def initialize(constraint)
+        @constraint = constraint
+        @templates = Manacle::Proxy::Template::Collection.new(@constraint.constrainables)
+      end
+
+      def proxyable?(obj)
+        @templates.has_key?(obj.class)
+      end
+
+      def proxy(obj)
+        c = @constraint.new(obj)
+        @templates.fetch(obj.class).for(c)
+      end
+    end
+  end
+end

data/lib/manacle/proxy/method.rb

@@ -0,0 +1,9 @@
+module Manacle
+  class Proxy
+    module Method
+      def initialize(name)
+        @name = name
+      end
+    end
+  end
+end

data/lib/manacle/proxy/method/constrained.rb

@@ -0,0 +1,35 @@
+require 'manacle/proxy/method'
+
+module Manacle
+  class Proxy
+    module Method
+      class Constrained
+        class Postprocessor
+          def initialize(proxy)
+            @constraint = proxy.unproxy
+          end
+
+          def process(result)
+            if @constraint.constrainables.include?(result.class)
+              @constraint.reconstrain(result).proxy
+            else
+              result
+            end
+          end
+        end
+
+        include Manacle::Proxy::Method
+
+        def bind(proxy)
+          proxy.instance_exec(@name) do |name|
+            define_method(name) do |*args|
+              postprocessor = Postprocessor.new(self)
+              res = constrain.method(name).call(*args)
+              postprocessor.process(res)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/manacle/proxy/method/unconstrained.rb

@@ -0,0 +1,18 @@
+require 'manacle/proxy/method'
+
+module Manacle
+  class Proxy
+    module Method
+      class Unconstrained
+        include Manacle::Proxy::Method
+        def bind(proxy)
+          proxy.instance_exec(@name) do |name|
+            define_method(name) do |*args|
+              @constraint.method(name).call(*args)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/manacle/proxy/template.rb

@@ -0,0 +1,36 @@
+require 'delegate'
+
+require 'manacle/proxy'
+require 'manacle/proxy/method/constrained'
+require 'manacle/proxy/method/unconstrained'
+
+module Manacle
+  class Proxy
+    class Template
+      def self.cut(klass)
+        Class.new do |k|
+          include Manacle::Proxy::InstanceMethods
+
+          define_method(:proxied_klass) do
+            klass
+          end
+          private :proxied_klass
+
+          methods = klass.instance_methods.reject {|m| 
+            [:inspect, :new, :class].include?(m) 
+          }.map {|m| 
+            Method::Constrained.new(m) 
+          } + 
+          Manacle::Constraint::InstanceMethods.instance_methods.map {|m| 
+            Method::Unconstrained.new(m) 
+          }
+
+
+          methods.each do |mth|
+            mth.bind(self)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/manacle/proxy/template/factory.rb

@@ -0,0 +1,18 @@
+require 'manacle/proxy/template'
+
+module Manacle
+  class Proxy
+    class Template
+      class Factory
+        def initialize 
+          @proxies = {}
+        end
+
+        def build(klass)
+          @proxies[klass] ||= Template.cut(klass)
+        end
+      end
+    end
+  end
+end
+

data/lib/manacle/proxy/templates.rb

@@ -0,0 +1,40 @@
+require 'punchout/fabricable'
+require 'punchout/puncher'
+require 'punchout/puncher/matchable'
+require 'punchout/matcher/class'
+require 'manacle/proxy/template/factory'
+
+module Manacle
+  class Proxy
+    module Templates
+      class Factory
+        def initialize
+          @factory = Manacle::Proxy::Template::Factory.new
+        end
+
+        def build(obj)
+          matcher = Punchout::Matcher::Klass.new(obj.class)
+          built = @factory.build(obj)
+
+          Punchout::Puncher::Matchable.new(matcher, built)
+        end
+      end
+
+      extend Punchout::Fabricable
+      
+      module_function
+
+      def factory
+        @factory ||= Factory.new
+      end
+
+      def for(obj)
+        res = puncher.punch(obj.class)
+        unless res.kind_of?(Class)
+          raise
+        end
+        res
+      end
+    end
+  end
+end

data/test/integration/manacle/constraint_test.rb

@@ -0,0 +1,155 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+require 'active_support/core_ext'
+require 'date'
+require 'manacle/constraint/method'
+
+class Manacle::Constraint::Test < Test::Unit::TestCase
+  test '#constrain' do
+    mock_constrainable = Class.new do
+
+      def self.constrainables
+        [ActiveSupport::TimeWithZone, ::Time, ::Date] 
+      end
+
+      include Manacle::Constraint::Method
+
+      def constraint
+        :utc
+      end
+    end
+
+    time = Time.new
+
+    orig = mock_constrainable.new(time)
+
+    mod = orig.reconstrain(Time.now.utc)
+  end
+
+  test '#constrain comparisons' do
+    mock_constrainable = Class.new do
+
+      def self.constrainables
+        [ActiveSupport::TimeWithZone, ::Time, ::Date] 
+      end
+
+      include Manacle::Constraint::Method
+
+      def constraint
+        :utc
+      end
+    end
+
+    time = Time.new
+
+    orig_cons = mock_constrainable.new(time)
+
+    orig = orig_cons.proxy
+
+    steps = [60*60*24, 60*60*5, 60*30]
+
+    mod = steps.reduce(orig) {|d, s|
+      d + s
+    }
+    assert_equal 1, mod <=> orig
+    assert_equal -1, orig <=> mod
+    assert_equal 0, orig <=> orig
+
+    assert mod.kind_of?(::Time), "Result of kind #{mod.class.ancestors} instead of Time"
+    assert_equal mod.constrain, (time + 60*60*24 + 60*60*5 + 60*30).utc
+  end
+
+  test '#constrain nesting' do
+    mock_constrainable = Class.new do
+      def self.constrainables
+        [ActiveSupport::TimeWithZone, ::Time, ::Date] 
+      end
+
+      include Manacle::Constraint::Method
+
+      def constraint
+        :utc
+      end
+    end
+
+    mock_other_constrainable = Class.new do
+      def self.constrainables
+        [ActiveSupport::TimeWithZone, ::Time, ::Date] 
+      end
+
+      include Manacle::Constraint::Method
+
+      def constraint
+        :beginning_of_day
+      end
+    end
+
+    time = Time.now.in_time_zone('PST8PDT')
+    
+    orig_cons = mock_constrainable.new(time)
+    oo_cons = mock_other_constrainable.new(orig_cons)
+    oo = oo_cons.proxy
+
+
+    mod = oo + (1.day + 5.hours + 30.minutes)
+
+
+    assert mod.kind_of?(::Time)
+    assert_equal mod.constrain, (time + 1.day).utc.beginning_of_day
+    
+  end
+
+  test '#constrain repeated' do
+    mock_constrainable = Class.new do
+
+      def self.constrainables
+        [ActiveSupport::TimeWithZone, ::Time, ::Date] 
+      end
+
+      include Manacle::Constraint::Method
+
+      def constraint
+        :utc
+      end
+    end
+
+    mock_other_constrainable = Class.new do
+      def self.constrainables
+        [ActiveSupport::TimeWithZone, ::Time, ::Date] 
+      end
+
+      include Manacle::Constraint::Method
+
+      def constraint
+        :beginning_of_day
+      end
+    end
+
+    time = Time.now.in_time_zone('PST8PDT')
+    
+    orig_cons = mock_constrainable.new(time)
+    oo_cons = mock_other_constrainable.new(orig_cons)
+
+    oo = oo_cons.proxy
+
+
+    5.times do
+      oo = oo + (1.day + 5.hours + 30.minutes)
+    end
+
+
+    5.times do
+      oo = oo.in_time_zone("PST8PDT")
+    end
+
+
+    assert_kind_of ::Time, oo
+    constrained = oo.constrain
+    assert_kind_of ::Time, constrained
+
+    expected_time = (time + 5.day).utc.beginning_of_day
+    assert_equal expected_time, constrained
+    
+  end
+end
+

data/test/integration/manacle/proxy_test.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+require 'active_support/core_ext'
+require 'manacle/constraint/method'
+
+class Manacle::Proxy::Test < Test::Unit::TestCase
+end

data/test/integration/manacle_test.rb

@@ -0,0 +1,151 @@
+require File.expand_path('../test_helper', __FILE__)
+
+require 'active_support/core_ext'
+require 'date'
+require 'manacle/constraint/method'
+
+class Manacle::ConstraintTest < Test::Unit::TestCase
+  test '#constrain' do
+    mock_constrainable = Class.new do
+
+      def self.constrainables
+        [ActiveSupport::TimeWithZone, ::Time, ::Date] 
+      end
+
+      include Manacle::Constraint::Method
+
+      def constraint
+        :utc
+      end
+    end
+
+    time = Time.new
+
+    orig = mock_constrainable.new(time).proxy
+
+    mod = orig + 1.day + 5.hours + 30.minutes
+
+    assert mod.kind_of?(::Time), "Result of kind #{mod.class.ancestors} instead of Time"
+    assert_equal mod.constrain, (time + 1.day + 5.hours + 30.minutes).utc
+  end
+
+  test '#constrain comparisons' do
+    mock_constrainable = Class.new do
+
+      def self.constrainables
+        [ActiveSupport::TimeWithZone, ::Time, ::Date] 
+      end
+
+      include Manacle::Constraint::Method
+
+      def constraint
+        :utc
+      end
+    end
+
+    time = Time.new
+
+    orig = mock_constrainable.new(time).proxy
+
+
+    mod = orig + 1.day + 5.hours + 30.minutes
+
+    assert_equal 1, mod <=> orig
+    assert_equal -1, orig <=> mod
+    assert_equal 0, orig <=> orig
+
+    assert mod.kind_of?(::Time), "Result of kind #{mod.class.ancestors} instead of Time"
+    assert_equal mod.constrain, (time + 1.day + 5.hours + 30.minutes).utc
+  end
+
+  test '#constrain nesting' do
+    mock_constrainable = Class.new do
+      def self.constrainables
+        [ActiveSupport::TimeWithZone, ::Time, ::Date] 
+      end
+
+      include Manacle::Constraint::Method
+
+      def constraint
+        :utc
+      end
+    end
+
+    mock_other_constrainable = Class.new do
+      def self.constrainables
+        [ActiveSupport::TimeWithZone, ::Time, ::Date] 
+      end
+
+      include Manacle::Constraint::Method
+
+      def constraint
+        :beginning_of_day
+      end
+    end
+
+    time = Time.now.in_time_zone('PST8PDT')
+    
+    orig_cons = mock_constrainable.new(time)
+    oo_cons = mock_other_constrainable.new(orig_cons)
+    oo = oo_cons.proxy
+
+    mod = oo + (1.day + 5.hours + 30.minutes)
+
+    assert mod.kind_of?(::Time)
+    assert_equal mod.constrain, (time + 1.day).utc.beginning_of_day
+    
+  end
+
+  test '#constrain repeated' do
+    mock_constrainable = Class.new do
+
+      def self.constrainables
+        [ActiveSupport::TimeWithZone, ::Time, ::Date] 
+      end
+
+      include Manacle::Constraint::Method
+
+      def constraint
+        :utc
+      end
+    end
+
+    mock_other_constrainable = Class.new do
+      def self.constrainables
+        [ActiveSupport::TimeWithZone, ::Time, ::Date] 
+      end
+
+      include Manacle::Constraint::Method
+
+      def constraint
+        :beginning_of_day
+      end
+    end
+
+    time = Time.now.in_time_zone('PST8PDT')
+    
+    orig_cons = mock_constrainable.new(time)
+    oo_cons = mock_other_constrainable.new(orig_cons)
+
+    oo = oo_cons.proxy
+
+
+    5.times do
+      oo = oo + (1.day + 5.hours + 30.minutes)
+    end
+
+    5.times do
+      oo = oo.in_time_zone("PST8PDT")
+    end
+
+
+    assert_kind_of ::Time, oo
+    constrained = oo.constrain
+    assert_kind_of ::Time, constrained
+
+    expected_time = (time + 5.day).utc.beginning_of_day
+    assert_equal expected_time, constrained
+    
+  end
+end
+

data/test/integration/test_helper.rb

@@ -0,0 +1,7 @@
+$:.push('lib')
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'test/unit/testcase'
+require "mocha/setup"

data/test/unit/manacle/constraint/actuator/base_test.rb

@@ -0,0 +1,58 @@
+require File.expand_path('../../../../test_helper', __FILE__)
+
+require 'manacle/constraint/actuator/base'
+
+class Manacle::Constraint::Actuator::BaseTest < Test::Unit::TestCase
+  def setup
+    @mock_value = mock
+    @mock_constraint = mock
+
+    @actuator = Manacle::Constraint::Actuator::Base.new(@mock_value, @mock_constraint)
+
+  end
+
+  puts Test::Unit::TestCase.method(:test).inspect
+
+  test '#constrain uncached' do
+
+    mock_constrained = mock
+    @mock_constraint.expects(:base_constrain).returns(mock_constrained)
+
+    result = @actuator.constrain
+
+    assert_equal mock_constrained, result
+  end
+
+  test '#constrain cached' do
+
+    mock_constrained = mock
+
+    @mock_value.expects(:constrain).never
+
+    @actuator.instance_variable_set(:@constrained, mock_constrained)
+
+    result = @actuator.constrain
+
+    assert_equal mock_constrained, result
+  end
+
+  test '#reconstrain' do
+    mock_new_value = mock
+
+    mock_actuator = mock
+    Manacle::Constraint::Actuator::Base.expects(:new).with(mock_new_value, @mock_constraint).returns(mock_actuator)
+
+    result = @actuator.reconstrain(mock_new_value)
+
+    assert_equal mock_actuator, result
+  end
+
+  test '#proxy' do
+    mock_proxy = mock
+    Manacle::Proxy::Templates.expects(:for).with(@mock_value).returns(mock_proxy)
+
+    result = @actuator.proxy
+
+    assert_equal mock_proxy, result
+  end
+end

data/test/unit/manacle/constraint/actuator/nested_test.rb

@@ -0,0 +1,62 @@
+require File.expand_path('../../../../test_helper', __FILE__)
+
+require 'manacle/constraint/actuator/nested'
+
+class Manacle::Constraint::Actuator::NestedTest < Test::Unit::TestCase
+  def setup
+    @mock_nested = mock
+    @mock_constraint = mock
+
+    @actuator = Manacle::Constraint::Actuator::Nested.new(@mock_nested, @mock_constraint)
+
+  end
+
+  test '#constrain uncached' do
+
+    mock_ascending_value = mock
+    @mock_nested.expects(:constrain).returns(mock_ascending_value)
+
+    mock_constrained = mock
+    @mock_constraint.expects(:base_constrain).returns(mock_constrained)
+
+    result = @actuator.constrain
+
+    assert_equal mock_constrained, result
+  end
+
+  test '#constrain cached' do
+    mock_constrained = mock
+
+    @mock_nested.expects(:constrain).never
+
+    @actuator.instance_variable_set(:@constrained, mock_constrained)
+
+    result = @actuator.constrain
+
+    assert_equal mock_constrained, result
+  end
+
+  test '#reconstrain' do
+    mock_object = mock
+
+    mock_new_nested = mock
+    @mock_nested.expects(:reconstrain).with(mock_object).returns(mock_new_nested)
+
+    mock_new_actuator = mock
+    Manacle::Constraint::Actuator::Nested.expects(:new).with(mock_new_nested, @mock_constraint).returns(mock_new_actuator)
+
+    result = @actuator.reconstrain(mock_object)
+
+    assert_equal mock_new_actuator, result
+  end
+
+  test '#proxy' do
+    mock_proxy = mock
+    @mock_nested.expects(:proxy).returns(mock_proxy)
+
+    result = @actuator.proxy
+    assert_equal mock_proxy, result
+  end
+end
+
+

data/test/unit/manacle/constraint_test.rb

@@ -0,0 +1,65 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+require 'manacle/constraint'
+
+class Manacle::ConstraintTest < Test::Unit::TestCase
+  def setup
+    @mock_constrainable = Class.new do
+
+      def self.constrainables
+        [ActiveSupport::TimeWithZone, ::Time, ::Date] 
+      end
+
+      include Manacle::Constraint
+
+      def constraint=(constraint)
+        @constraint = constraint
+      end
+
+      def constraint
+        @constraint
+      end
+    end
+
+    @mock_obj = mock
+
+    @mock_actuator = mock
+
+    Manacle::Constraint::Actuator.expects(:build).with(@mock_obj, instance_of(@mock_constrainable)).returns(@mock_actuator)
+
+    @constraint = @mock_constrainable.new(@mock_obj)
+
+    @mock_constraint = mock
+
+    @constraint.constraint = @mock_constraint
+  end
+
+  test "#klass" do
+    mock_val = mock
+    @mock_actuator.expects(:constrain).returns(mock_val)
+
+    mock_val_class = mock
+    mock_val.expects(:class).returns(mock_val_class)
+
+    result = @constraint.klass
+    assert_equal mock_val_class, result
+  end
+
+  test "#unconstrain" do
+    @mock_actuator.expects(:unconstrain).returns(@mock_obj)
+
+    result = @constraint.unconstrain
+
+    assert_equal @mock_obj, result
+  end
+
+  test "#reconstrain" do
+    mock_new_obj = mock
+    @mock_actuator.expects(:reconstrain).returns(mock_new_obj)
+
+    mock_new_actuator = mock
+    Manacle::Constraint::Actuator.expects(:build).with(mock_new_obj, instance_of(@mock_constrainable)).returns(mock_new_actuator)
+
+    result = @constraint.reconstrain(mock_new_obj)
+  end
+end

data/test/unit/manacle/proxy/template_test.rb

@@ -0,0 +1,48 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+require 'manacle/proxy/template'
+
+class Manacle::Proxy::TemplateTest < Test::Unit::TestCase
+  class MockClass ; end
+
+
+  test ".ancestors" do
+    mock_klass = MockClass
+
+    mock_instance_methods = 5.times.map {|x|
+      "method_#{x}".to_sym
+    }
+
+    mock_klass.expects(:instance_methods).returns(mock_instance_methods)
+
+    mock_proxy_klass = Manacle::Proxy::Template.cut(mock_klass)
+
+    mock_proxy_klass.ancestors.include?(MockClass)
+  end
+
+  test ".cut" do
+    mock_klass = MockClass
+
+    mock_instance_methods = 5.times.map {|x|
+      "method_#{x}".to_sym
+    }
+
+    mock_instance_methods.each {|m|
+      mock_method_obj = mock
+      #mock_klass.expects(:instance_method).returns(mock_method_obj)
+    }
+
+    mock_klass.expects(:instance_methods).returns(mock_instance_methods)
+
+    mock_proxy_klass = Manacle::Proxy::Template.cut(mock_klass)
+
+    mock_constraint = mock
+    mock_constraint.expects(:kind_of?).with(Manacle::Constraint).returns(true)
+
+    mock_proxy_instance = mock_proxy_klass.new(mock_constraint)
+
+    mock_instance_methods.each {|m|
+      assert mock_proxy_instance.respond_to?(m), "mock class does not respond to #{m}"
+    }
+  end
+end

data/test/unit/manacle/proxy_test.rb

@@ -0,0 +1,42 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+require 'manacle/proxy'
+
+class Manacle::ProxyTest < Test::Unit::TestCase
+
+  def setup
+    @mock_constraint = mock
+
+    @mock_constraint.expects(:kind_of?).with(Manacle::Constraint).returns(true)
+
+    proxy_class = Class.new do
+      include Manacle::Proxy::InstanceMethods
+    end
+
+    @proxy = proxy_class.new(@mock_constraint)
+  end
+
+  test "#constrained uncached" do
+    mock_constrained = mock
+    
+    @mock_constraint.expects(:constrain).returns(mock_constrained)
+
+    result = @proxy.constrain
+
+    assert_equal mock_constrained, result
+  end
+
+  test "#constrained cached" do
+    mock_constrained = mock
+
+    @proxy.instance_variable_set(:@constrained, mock_constrained)
+
+    @mock_constraint.expects(:constrain).never
+
+    result = @proxy.constrain
+
+    assert_equal mock_constrained, result
+  end
+
+
+end

data/test/unit/test_helper.rb

@@ -0,0 +1,16 @@
+$:.push('lib')
+
+require 'coveralls'
+Coveralls.wear!
+
+if ENV["ENABLE_SIMPLE_COV"]
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "test"
+    add_group 'API',          "lib"
+  end
+end
+
+require 'test/unit/testcase'
+require "mocha/setup"
+

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: manacle
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Ed Carrel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: punchout
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  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: activesupport
+  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: |2
+      Manacle will allow you to attach constraints to your objects that will persist across new instances of similar objects.
+
+      As an example, you can constrain a Time object to always advance to the next hour. Then, if you add even one minute to that Time, it will snap to the next hour.
+email:
+- ed@pocketchange.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/manacle/constraint/actuator/base.rb
+- lib/manacle/constraint/actuator/nested.rb
+- lib/manacle/constraint/actuator.rb
+- lib/manacle/constraint/method.rb
+- lib/manacle/constraint.rb
+- lib/manacle/proxy/factory.rb
+- lib/manacle/proxy/method/constrained.rb
+- lib/manacle/proxy/method/unconstrained.rb
+- lib/manacle/proxy/method.rb
+- lib/manacle/proxy/template/factory.rb
+- lib/manacle/proxy/template.rb
+- lib/manacle/proxy/templates.rb
+- lib/manacle/proxy.rb
+- test/integration/manacle/constraint/actuator_test.rb
+- test/integration/manacle/constraint_test.rb
+- test/integration/manacle/proxy_test.rb
+- test/integration/manacle_test.rb
+- test/integration/test_helper.rb
+- test/unit/manacle/constraint/actuator/base_test.rb
+- test/unit/manacle/constraint/actuator/nested_test.rb
+- test/unit/manacle/constraint_test.rb
+- test/unit/manacle/proxy/factory_test.rb
+- test/unit/manacle/proxy/template_test.rb
+- test/unit/manacle/proxy_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 sticky constraint gem
+test_files: []
+has_rdoc: