proxy_method 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09fd4847c5a3f98f43e2fa734b759d9ff9ee777c6d2fee717440db40120b7a9b'
-  data.tar.gz: a989d2beb4ea2c7cb048a483bfa8a32c5ebc4e886c0f502993d0ac27417958dc
+  metadata.gz: '07808eb01a4645e80fbde075254b0ae39a7eb4301c5fe035594337f202ab2cbf'
+  data.tar.gz: c9b26c4bf4a112d2dbb134e4adac063140b70e26a4fb7ccaac95a0f19687e3f2
 SHA512:
-  metadata.gz: 33542c8cc53c3402b5eadcd8cc6ca972f3455219017e16017a3bc9f51f7075ac31fa38736c0c31ac97d6f0a70705509f8cc07b3a1aab997055421d263c114011
-  data.tar.gz: 4dc532102f028ee2ff996b718312818e72442e93eeb94c4d04435947acc168578218d0d278d3b4914af0d31846e9defbc63eda26d2cad682c6b967218a765163
+  metadata.gz: e53e844eb9ad0640f907de886df62fc50550b6a70654eea26eb79a59c8fc1a0670fe0443499d244ed82a84e6c3b0e3e828d950480830bee35c1969c1e8347d10
+  data.tar.gz: bbfc055815f09864dcf312b73b76df89062af0a15c66d736aeee2479f23e62164c70e5cc52ada54ca3040b5212113e1036a9449d0efa016a99f5626ff68ba88c

data/README.md

@@ -52,10 +52,10 @@ You can do this:
     Turtle.new.save
     # => RuntimeError: Disabled by proxy_method
     
-    Turtle.proxied_create
+    Turtle.unproxied_create
     # => 'created'
     
-    Turtle.new.proxied_save
+    Turtle.new.unproxied_save
     # => 'saved'
 
 Specify a custom error message:
@@ -88,12 +88,47 @@ Supply your own prefix for the original, unproxied method:
     class PrefixPelican < Animal
       include ProxyMethod
       
-      proxy_method :save, prefix: 'pelican'
+      proxy_method :save, prefix: 'pelican_'
     end
     
     PrefixPelican.new.pelican_save
     # => 'saved'
 
+Use an "unproxied" version of an instance:
+
+    class DefaultDuck < Animal
+      include ProxyMethod
+      
+      proxy_method :save
+    end
+    
+    duck = DefaultDuck.new
+    duck_unproxied = duck.unproxied
+    
+    duck.save
+    # => RunTimeError: Disabled by proxy_method 
+    
+    duck_unproxied.save
+    # => 'saved'
+
+
+This is important, because if you proxy a method like `#save` in ActiveRecord,
+you're also preventing the natural use of `#create` and `#update` since these
+rely on `#save` under the hood. "Unproxying" the entire instance then frees
+an interactor to use `#create`, `#update` and `#save` in an intentional way.
+
+You can also use an unproxied version of the entire class:
+
+    duck = DefaultDuck.new
+    duck_unproxied = DefaultDuck.unproxied.new
+    
+    duck.save
+    # => RunTimeError: Disabled by proxy_method 
+    
+    duck_unproxied.save
+    # => 'saved'
+
+
 ## Installation
 Add this line to your application's Gemfile:
 

data/lib/proxy_method.rb

@@ -3,30 +3,107 @@ module ProxyMethod
     DEFAULT_PROXY_MESSAGE = 'Disabled by proxy_method'
     DEFAULT_PREFIX = 'unproxied_'
 
+    def proxied_instance_methods
+      @_proxied_instance_methods ||= {}
+    end
+
+    def proxied_class_methods
+      @_proxied_class_methods ||= {}
+    end
+
+    def proxy_class_methods_enabled?
+      return @_proxy_class_methods_enabled if defined?(@_proxy_class_methods_enabled)
+      @_proxy_class_methods_enabled = true
+    end
+
     def proxy_class_method(original_method_names, options = {})
+      original_method_names = Array(original_method_names)
+
       error_message = options[:message] || DEFAULT_PROXY_MESSAGE
       prefix = options[:prefix] || DEFAULT_PREFIX
 
-      Array(original_method_names).each do |original_method_name|
-        self.singleton_class.send(:alias_method, :"#{prefix}#{original_method_name}", original_method_name)
-        define_singleton_method(original_method_name){ raise error_message }
+      original_method_names.each do |original_method_name|
+        self.proxied_class_methods.merge!(original_method_name => prefix)
+        new_method_name = :"#{prefix}#{original_method_name}"
+
+        self.singleton_class.send(:alias_method, new_method_name, original_method_name)
+        define_singleton_method(original_method_name) do |*args, &block|
+          if proxy_class_methods_enabled?
+            raise error_message
+          else
+            send(new_method_name, *args, &block)
+          end
+        end
       end
     end
 
     def proxy_instance_method(original_method_names, options = {})
+      original_method_names = Array(original_method_names)
+
       error_message = options[:message] || DEFAULT_PROXY_MESSAGE
       prefix = options[:prefix] || DEFAULT_PREFIX
 
-      Array(original_method_names).each do |original_method_name|
-        alias_method :"#{prefix}#{original_method_name}", original_method_name
-        define_method(original_method_name){ raise error_message }
+      original_method_names.each do |original_method_name|
+        self.proxied_instance_methods.merge!(original_method_name => prefix)
+        new_method_name = :"#{prefix}#{original_method_name}"
+
+        alias_method new_method_name, original_method_name
+
+        define_method(original_method_name) do |*args, &block|
+          if proxy_instance_methods_enabled?
+            raise error_message
+          else
+            send(new_method_name, *args, &block)
+          end
+        end
       end
     end
 
     alias_method :proxy_method, :proxy_instance_method
+
+    def unproxied
+      self.dup.unproxy!
+    end
+
+    def proxied
+      self.dup.proxy!
+    end
+
+    def unproxy!
+      @_proxy_class_methods_enabled = false
+      self
+    end
+
+    def reproxy!
+      @_proxy_class_methods_enabled = true
+      self
+    end
   end
 
   def self.included(base)
     base.extend ClassMethods
   end
+
+  def proxy_instance_methods_enabled?
+    return @_proxy_instance_methods_enabled if defined?(@_proxy_instance_methods_enabled)
+    @_proxy_instance_methods_enabled = true
+  end
+
+  def unproxied
+    self.dup.unproxy!
+  end
+
+  def proxied
+    self.dup.proxy!
+  end
+
+  def unproxy!
+    @_proxy_instance_methods_enabled = false
+    self
+  end
+
+  def reproxy!
+    @_proxy_instance_methods_enabled = true
+    self
+  end
 end

data/lib/proxy_method/version.rb

@@ -1,3 +1,3 @@
 module ProxyMethod
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/test/test_proxy_method.rb

@@ -2,20 +2,28 @@ require 'minitest/autorun'
 require 'proxy_method'
 
 class Animal
-  def self.create
-    'created'
+  def self.create target=nil
+    ['created', target].compact.join(' ')
   end
 
   def self.destroy_all
     'destroyed'
   end
 
+  def self.blocky(first, second)
+    yield(first, second)
+  end
+
   def save
     'saved'
   end
 
-  def update
-    'updated'
+  def update target=nil
+    ['updated', target].compact.join(' ')
+  end
+
+  def blocky(first, second)
+    yield(first, second)
   end
 end
 
@@ -48,6 +56,12 @@ class PrefixPelican < Animal
   proxy_method :save, prefix: 'pelican_'
 end
 
+class ArgumentativeAardvark < Animal
+  include ProxyMethod
+
+  proxy_method :blocky
+end
+
 class ProxyMethodTest < MiniTest::Test
   describe "proxying class methods" do
     it "does not allow original method name to be called" do
@@ -103,6 +117,38 @@ class ProxyMethodTest < MiniTest::Test
 
       assert 'created', PrefixPelican.pelican_create
     end
+
+    describe "unproxied class" do
+      it "allows methods to be called directly" do
+        assert_equal 'created feathers', MultiMonkey.unproxied.create('feathers')
+
+        # ensure that it doesn't affect any other classes
+        exception = assert_raises StandardError do
+          DefaultDuck.create('feathers')
+        end
+
+        assert_equal "Disabled by proxy_method", exception.message
+      end
+
+      it "handles arguments and blocks" do
+        assert_equal 13, ArgumentativeAardvark.unproxied.blocky(6, 7){ |a, b| a + b }
+      end
+
+      it "handles custom prefixes" do
+        assert_equal 'created', PrefixPelican.unproxied.create
+      end
+    end
+
+    it "leaves the original proxied" do
+      duck_unproxied = DefaultDuck.unproxied
+      duck_proxied = DefaultDuck
+
+      assert_equal 'created', duck_unproxied.create
+
+      assert_raises StandardError do
+        duck_proxied.create
+      end
+    end
   end
 
   describe "proxying instance methods" do
@@ -168,4 +214,36 @@ class ProxyMethodTest < MiniTest::Test
       assert 'saved', PrefixPelican.new.pelican_save
     end
   end
+
+  describe "unproxied instance" do
+    it "allows methods to be called directly" do
+      assert_equal 'updated feathers', MultiMonkey.new.unproxied.update('feathers')
+
+      # ensure that it doesn't affect any other instances
+      exception = assert_raises StandardError do
+        MultiMonkey.new.update('feathers')
+      end
+
+      assert_equal "Disabled by proxy_method", exception.message
+    end
+
+    it "handles arguments and blocks" do
+      assert_equal 13, ArgumentativeAardvark.new.unproxied.blocky(6, 7){ |a, b| a + b }
+    end
+
+    it "handles custom prefixes" do
+      assert_equal 'saved', PrefixPelican.new.unproxied.save
+    end
+
+    it "leaves the original proxied" do
+      duck_proxied = DefaultDuck.new
+      duck_unproxied = duck_proxied.unproxied
+
+      assert_equal 'saved', duck_unproxied.save
+
+      assert_raises StandardError do
+        duck_proxied.save
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proxy_method
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Jaime Bellmyer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-18 00:00:00.000000000 Z
+date: 2019-12-19 00:00:00.000000000 Z
 dependencies: []
 description: |2
       The purpose of this gem is to prevent directly running the inherited