proxified 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd5b3ded355bfb619efec1c6a3314498662945cd1ca2e36d2b38ae71823a0bb6
-  data.tar.gz: e16834d5a79ab0cd7d5b38b40ed7e7f7af2203c37b84c569e90f33a57ebd6c18
+  metadata.gz: 32993e659cfcc2aa53356778623ee52326882a72b27532690c47e64aff86b4db
+  data.tar.gz: bee698f6c58a298229cdac6ef91dd404ef77e0e56342197ff39bbf0d96f2479d
 SHA512:
-  metadata.gz: 56ba529f8c836164dd010395d7311511bcce0123dd482574585e3327bc66060f1a512984379397f148f73cbcc0d66efae98d3ff1cf54133eb0d269ef1c93ec41
-  data.tar.gz: c7553667d0ff27a830d315a33c44d7a5b257451a7d53201e0dadb13507a419cc4e0e331e1667977503b3032ba0391e614b92f97b63f66d877c605f6798640324
+  metadata.gz: 69c8f491db5b66212e13f64705329a14426883c797669a34a0ed00ad995ce3ba3a8b236c134b7fbdfb6c04c073bfb250b506475111b72d4404f4602355aaed71
+  data.tar.gz: 6a137b59ef2dbf4e821bb0794369304764bf64160fe35b1be83ee2a8aa70dd7c4de688a46b76730494a1c61caf778f056621a61f20cb2bdd2ff961578fa2ab5a

data/.rubocop.yml

@@ -1,5 +1,13 @@
+AllCops:
+  TargetRubyVersion: '2.6'
+
 Metrics/BlockLength:
   Exclude:
+    - lib/proxified.rb
     - spec/**/*
     - Guardfile
     - proxified.gemspec
+
+Naming/MethodName:
+  Exclude:
+    - lib/proxified.rb

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    proxified (0.1.0)
+    proxified (1.0.0)
       activesupport (~> 5.2, >= 5.2.2)
 
 GEM

data/Guardfile

@@ -48,6 +48,8 @@ group :red_green_refactor, halt_on_fail: true do
     # Ruby files
     ruby = dsl.ruby
     dsl.watch_spec_files_for(ruby.lib_files)
+
+    watch(ruby.lib_files) { "#{rspec.spec_dir}/global_methods_spec.rb" }
   end
 
   guard :rubocop, all_on_start: true, cli: ['-a'] do

data/README.md

@@ -1,8 +1,10 @@
+[![Gem Version](https://badge.fury.io/rb/proxified.svg)](https://badge.fury.io/rb/proxified)
+
 # Proxified
 
-Proxify any object with a few lines of code.
+A simple way to put a proxy in front of any object, at any time.
 
-A simple way to add (and remove) a proxy to any object's instance methods and to inherit and change the behaviour down the class hierarchy.
+You can add and remove a proxy to and from any object instance methods and inherit or change the behavior down the class hierarchy.
 
 ## Installation
 
@@ -22,114 +24,156 @@ Or install it yourself as:
 
 ## Usage
 
-Just `include Proxified` in your class and call `proxify` with the method(s) you want to proxify and the code you want to run.
+You have two options to *proxify* and *unproxify* objects:
+
+  * *statically*: if you want to put a proxy on a class while defining it, just `include Proxified` and call `proxify` with the method(s) you want to *proxify* and the code you want to run.
+     When you want to remove a proxy, just call `unproxify` with the method(s) you want to *unproxify*, or without methods if you want to *unproxify* all *proxified* methods.
+     To check if a given method is *proxified*, call `proxified?` with the method name, or without arguments to check if any instance method is *proxified*.
 
-If you want to remove a proxy, just call `unproxify` with the method(s) you want to unproxify.
+  * *dynamically*: if you want to put a proxy on a class at runtime, or on a single object without affecting its class, call `Proxify` with the class/object and the method(s) you want to *proxify*.
+     Similarly, use `Unproxify` and `Proxified?` with the class/object and the method(s) you want to *unproxify*/*check*.
 
-In order to not change the class interface, a method is only `proxified` when the corresponding instance method is defined (before or after the proxy definition).
-Similarly, a `proxified method` is removed whenever the corresponding instance method is removed from the class.
+You can also mix the two approaches! (see the examples below)
 
-Moreover, the `proxified methods` take the arguments specified by the `block`, so it should take the same arguments as the original `methods`.
-Finally, it's possible to call the actual `methods` invoking `super` inside the `block`.
+In order not to change the class interface, a method is only *proxified* when the corresponding instance method is defined (before or after the proxy definition).
+Similarly, a *proxified method* is removed whenever the corresponding instance method is removed from the class.
+
+Moreover, the *proxified methods* take the arguments specified by the block, so it should take the same arguments as the original methods.
+Finally, it's possible to call the actual methods invoking `super` inside the block.
 
 ```ruby
 
 require 'proxified'
 
-# Basic usage:
+# Static proxy:
+
 class A
   include Proxified
 
-  proxify :welcome, :goodbye do |name|
-    check(name)
-    super(name)
+  proxify :foo, :bar, :biz do
+    "proxified #{super()}"
   end
 
-  def check(name)
-    puts "checking #{name}"
-  end
+  def foo; 'foo'; end
 
-  def welcome(name)
-    puts "hello #{name}!"
-  end
+  def bar; 'bar'; end
 
-  def goodbye(name)
-    puts "goodbye #{name}!"
-  end
+  def biz; 'biz'; end
+
+  def baz; 'baz'; end
 end
 
-a = A.new
-a.welcome('jack') => 'checking jack'; 'welcome jack!';
-a.goodbye('jack') => 'checking jack'; 'goodbye jack!';
-a.welcome         => raises ArgumentError
-a.check('jack')   => 'checking jack' # not proxified
+A.ancestors # => [A::Proxy, A, Proxified, ...]
 
-# Unproxifing a proxified method:
-class B < A
-  unproxify :welcome
-end
+a1, a2 = A.new, A.new
 
-b = B.new
-b.welcome('jack') => 'welcome jack!';
-b.goodbye('jack') => 'checking jack'; 'goodbye jack!';
+a1.foo # => 'proxified foo'
+a2.foo # => 'proxified foo'
+a1.bar # => 'proxified bar'
+a2.bar # => 'proxified bar'
+a1.biz # => 'proxified biz'
+a2.biz # => 'proxified biz'
+a1.baz # => 'baz'
+a2.baz # => 'baz'
 
 
-# Redefining a proxified method:
-class C < A
-  def welcome(name)
-    puts "welcome #{name.upcase}!"
-  end
-end
+# unproxify the :foo method
+A.unproxify(:foo)  # => [:foo]
 
-c = C.new
-c.welcome('jack') => 'checking jack'; 'welcome JACK!';
-c.goodbye('jack') => 'checking jack'; 'goodbye jack!';
+# the :foo method is not proxified anymore
+A.proxified?(:foo) # => false
+# A is still proxified, i.e. it has at least one proxified method
+A.proxified?       # => true
 
+a1.foo # => 'foo'
+a2.foo # => 'foo'
+a1.bar # => 'proxified bar'
+a2.bar # => 'proxified bar'
+a1.biz # => 'proxified biz'
+a2.biz # => 'proxified biz'
+a1.baz # => 'baz'
+a2.baz # => 'baz'
 
-# Reproxifing a proxified method:
-class D < A
-  proxify :welcome do |name|
-    super(name.upcase)
-  end
-end
 
-d = D.new
-d.welcome('jack') => 'checking JACK'; 'welcome JACK!';
-d.goodbye('jack') => 'checking jack'; 'goodbye jack!';
+# unproxify all the methods
+A.unproxify  # => [:bar, :biz]
 
+# A is not proxified anymore
+A.proxified? # => false
 
-# Reproxifing and redefining a proxified method:
-class E < A
-  proxify :welcome do |name|
-    super(name.upcase)
-  end
+a1.foo # => 'foo'
+a2.foo # => 'foo'
+a1.bar # => 'bar'
+a2.bar # => 'bar'
+a1.biz # => 'biz'
+a2.biz # => 'biz'
+a1.baz # => 'baz'
+a2.baz # => 'baz'
 
-  def welcome(name)
-    puts "hello #{name}!"
-  end
-end
 
-e = E.new
-e.welcome('jack') => 'hello JACK!';
-e.goodbye('jack') => 'checking jack'; 'goodbye jack!';
+# Dynamic proxy:
 
+# on a class
+Proxify(A, :foo, :bar) { 'proxified again' } # => [:foo, :bar]
 
-# Redefining a proxified method to call super:
-class F < A
-  def welcome(name)
-    # Will call F's proxy, then A's proxy and finally A's method
-    super(name)
-    puts 'hi'
-  end
-end
+a1.foo # => 'proxified again'
+a2.foo # => 'proxified again'
+a1.bar # => 'proxified again'
+a2.bar # => 'proxified again'
+a1.biz # => 'biz'
+a2.biz # => 'biz'
+a1.baz # => 'baz'
+a2.baz # => 'baz'
+
+
+# on a single object
+Proxify(a1, :bar, :biz) { 'singleton proxy' } # => [:bar, :biz]
+
+a1.foo # => 'proxified again'
+a2.foo # => 'proxified again'
+a1.bar # => 'singleton proxy'
+a2.bar # => 'proxified again'
+a1.biz # => 'singleton proxy'
+a2.biz # => 'biz'
+a1.baz # => 'baz'
+a2.baz # => 'baz'
+
+
+# unproxify all the methods of a1
+Unproxify(a1)  # => [:foo, :bar, :biz]
+
+# still proxified because of the class' proxy
+Proxified?(a1) # => true
+
+a1.foo # => 'proxified again'
+a2.foo # => 'proxified again'
+a1.bar # => 'proxified again'
+a2.bar # => 'proxified again'
+a1.biz # => 'biz'
+a2.biz # => 'biz'
+a1.baz # => 'baz'
+a2.baz # => 'baz'
+
+
+# unproxify all the methods of A
+Unproxify(A, :foo, :bar)  # => [:foo, :bar]
+
+a1.foo # => 'foo'
+a2.foo # => 'foo'
+a1.bar # => 'bar'
+a2.bar # => 'bar'
+a1.biz # => 'biz'
+a2.biz # => 'biz'
+a1.baz # => 'baz'
+a2.baz # => 'baz'
 
-f = F.new
-f.welcome('jack') => 'checking jack'; 'checking jack'; 'welcome jack!'; 'hi';
-f.goodbye('jack') => 'checking jack'; 'goodbye jack!';
 ```
+
+Just look at the code documentation to see more examples of what you can/cannot do.
+
 ## Notes
 
-This is my first gem, something I extracted from a bigger project and a first attempt to give back something to the community.
+This is my first gem, something I extracted from a bigger project and a first attempt to give something back to the community.
 
 Any constructive feedback is welcome and appreciated, thank you!
 

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'bundler/setup'
 require 'proxified'

data/lib/proxified.rb

@@ -3,39 +3,46 @@
 require 'active_support'
 require 'active_support/core_ext'
 
-# =====Allows to "proxify" and "unproxify" any instance method with custom code and to inherit and change the behaviour down the class hierarchy.
+# Allows to _proxify_ and _unproxify_ any instance method of a class with
+# custom code and to inherit and change the behaviour down the class hierarchy.
+#
+# The global methods allow to dinamically _proxify_ and _unproxify_ a class or
+# an object injecting Proxified in the class or the object's singleton class.
+#
+# This makes possible to dinamically wrap a proxy around any class with no need
+# for the class to know it, and to change the behaviour of one or more objects
+# without side effects on other objects of the same class.
 module Proxified
   extend ::ActiveSupport::Concern
 
   included do
-    # Stores the methods to proxify allowing descendants to override them
+    # Stores the methods to _proxify_ allowing descendants to override them
     # without affecting the parent.
     class_attribute :proxified_methods, default: {}, instance_accessor: false
   end
 
   class_methods do
-    # For each +method+ in +methods+, defines a +proxified_method+ that runs
-    # the given +block+ when +method+ is called, or raises ArgumentError if no
-    # block or no method is given.
+    # For each +method+ in +methods+, defines a _proxified_ _method_ that
+    # runs the given +block+ when +method+ is called, or raises ArgumentError
+    # if no +block+ or no +methods+ are given.
     #
-    # In order to not change the class interface, a method is only +proxified+
+    # In order not to change the class interface, a method is only _proxified_
     # when the corresponding instance method is defined (before or after the
-    # proxy definition), while a +proxified_method+ is removed whenever the
+    # proxy definition), while a _proxified_ _method_ is removed whenever the
     # corresponding instance method is removed from the class. Moreover, the
-    # +proxified_methods+ take the arguments specified by the +block+, so the
-    # +block+ should take the same arguments as the original +methods+
-    # (although it can take any number of arguments). Finally, it's possible
-    # to call the actual +methods+ invoking +super+ inside the +block+.
+    # _proxified_ _methods_ take the arguments specified by the +block+, so the
+    # +block+ should take the same arguments as the original +methods+.
+    # Finally, it's possible to call the original +methods+ invoking +super+
+    # inside the +block+.
     #
-    # The +proxified_methods+ are defined in a proxy module that is prepended
-    # automatically to the class only the first time a +proxified_method+ is
-    # defined within that class and the proxy module's name is prefixed with the
-    # class name. In this way, descendants who redefine a +proxified_method+
-    # get their own proxy module, while those who do not redefine a
-    # +proxified_method+ get the parent's proxy module.
+    # The _proxified_ _methods_ are defined in a proxy module that is
+    # automatically prepended to the class only the first time a _proxified_
+    # _method_ is defined within that class. In this way, descendants who
+    # redefine a _proxified_ _method_ get their own proxy module, while those
+    # who do not redefine a _proxified_ _method_ get the parent's proxy module.
     #
-    # Beware: if a child redefines a +proxified_method+ to call +super+, the
-    # parent's +proxified_method+ will be called.
+    # Beware: if a child redefines a _proxified_ _method_ to call +super+, the
+    # parent's _proxified_ _method_ will be called.
     #
     # ======Examples
     #
@@ -53,7 +60,7 @@ module Proxified
     #     end
     #
     #     def welcome(name)
-    #       puts "hello #{name}!"
+    #       puts "welcome #{name}!"
     #     end
     #
     #     def goodbye(name)
@@ -61,50 +68,54 @@ module Proxified
     #     end
     #   end
     #
-    #   A.ancestors => [A::Proxy, A, Proxified, ...]
+    #   A.ancestors       # => [A::Proxy, A, Proxified, ...]
     #
     #   a = A.new
-    #   a.welcome('jack') => 'checking jack'; 'welcome jack!';
-    #   a.goodbye('jack') => 'checking jack'; 'goodbye jack!';
-    #   a.welcome => raises ArgumentError
-    #   a.check('jack') => 'checking jack' # not proxified
+    #   a.welcome('jack') # => 'checking jack'; 'welcome jack!';
+    #   a.goodbye('jack') # => 'checking jack'; 'goodbye jack!';
+    #   a.welcome         # => raises ArgumentError
+    #   a.check('jack')   # => 'checking jack' (not proxified)
+    #
     #
     # Just inheriting:
     #   class B < A; end
     #
-    #   B.ancestors => [B, A::Proxy, A, Proxified, ...]
+    #   B.ancestors       # => [B, A::Proxy, A, Proxified, ...]
     #
     #   b = B.new
-    #   b.welcome('jack') => 'checking jack'; 'welcome jack!';
-    #   b.goodbye('jack') => 'checking jack'; 'goodbye jack!';
+    #   b.welcome('jack') # => 'checking jack'; 'welcome jack!';
+    #   b.goodbye('jack') # => 'checking jack'; 'goodbye jack!';
     #
-    # Redefining a +proxified_method+:
+    #
+    # Inheriting and redefining a _proxified_ _method_:
     #   class C < A
     #     def welcome(name)
     #       puts "welcome #{name.upcase}!"
     #     end
     #   end
     #
-    #   C.ancestors => [C::Proxy, C, A::Proxy, A, Proxified, ...]
+    #   C.ancestors       # => [C::Proxy, C, A::Proxy, A, Proxified, ...]
     #
     #   c = C.new
-    #   c.welcome('jack') => 'checking jack'; 'welcome JACK!';
-    #   c.goodbye('jack') => 'checking jack'; 'goodbye jack!';
+    #   c.welcome('jack') # => 'checking jack'; 'welcome JACK!';
+    #   c.goodbye('jack') # => 'checking jack'; 'goodbye jack!';
+    #
     #
-    # Reproxifing a +proxified_method+:
+    # Inheriting and _reproxifing_ a _proxified_ _method_:
     #   class D < A
     #     proxify :welcome do |name|
     #       super(name.upcase)
     #     end
     #   end
     #
-    #   D.ancestors => [D::Proxy, D, A::Proxy, A, Proxified, ...]
+    #   D.ancestors       # => [D::Proxy, D, A::Proxy, A, Proxified, ...]
     #
     #   d = D.new
-    #   d.welcome('jack') => 'checking JACK'; 'welcome JACK!';
-    #   d.goodbye('jack') => 'checking jack'; 'goodbye jack!';
+    #   d.welcome('jack') # => 'checking JACK'; 'welcome JACK!';
+    #   d.goodbye('jack') # => 'checking jack'; 'goodbye jack!';
+    #
     #
-    # Reproxifing and redefining a +proxified_method+:
+    # Inheriting, _reproxifing_ and redefining a _proxified_ _method_:
     #   class E < A
     #     proxify :welcome do |name|
     #       super(name.upcase)
@@ -115,13 +126,14 @@ module Proxified
     #     end
     #   end
     #
-    #   E.ancestors => [E::Proxy, E, A::Proxy, A, Proxified, ...]
+    #   E.ancestors       # => [E::Proxy, E, A::Proxy, A, Proxified, ...]
     #
     #   e = E.new
-    #   e.welcome('jack') => 'hello JACK!';
-    #   e.goodbye('jack') => 'checking jack'; 'goodbye jack!';
+    #   e.welcome('jack') # => 'hello JACK!';
+    #   e.goodbye('jack') # => 'checking jack'; 'goodbye jack!';
     #
-    # Redefining a +proxified_method+ to call +super+:
+    #
+    # Inheriting and redefining a _proxified_ _method_ to call +super+:
     #   class F < A
     #     def welcome(name)
     #       super(name)
@@ -129,11 +141,11 @@ module Proxified
     #     end
     #   end
     #
-    #   F.ancestors => [F::Proxy, F, A::Proxy, A, Proxified, ...]
+    #   F.ancestors       # => [F::Proxy, F, A::Proxy, A, Proxified, ...]
     #
     #   f = F.new
-    #   f.welcome('tom')  => 'checking tom'; 'checking tom'; 'welcome tom!'; 'hi';
-    #   f.goodbye('jack') => 'checking jack'; 'goodbye jack!';
+    #   f.welcome('jack') # => 'checking jack'; 'checking jack'; 'welcome jack!'; 'hi';
+    #   f.goodbye('jack') # => 'checking jack'; 'goodbye jack!';
     def proxify(*methods, &block)
       raise ArgumentError, 'no block given' unless block_given?
       raise ArgumentError, 'no methods given' if methods.empty?
@@ -144,54 +156,97 @@ module Proxified
       end
     end
 
-    # Removes +methods+ from the proxy.
+    # Unproxifies the given +methods+ removing them from the proxy module. If no
+    # +methods+ are given, all the _proxified_ _methods_ are removed.
     #
     # ======Examples
     #
     #   class A
     #     include Proxified
     #
-    #     proxify :welcome, :goodbye do |name|
-    #       check(name)
-    #       super(name)
+    #     proxify :foo, :bar, :biz do
+    #       super().upcase
     #     end
     #
-    #     def check(name)
-    #       puts "checking #{name}"
+    #     def foo
+    #       'foo'
     #     end
     #
-    #     def welcome(name)
-    #       puts "welcome #{name}!"
+    #     def bar
+    #       'bar'
     #     end
     #
-    #     def goodbye(name)
-    #       puts "goodbye #{name}!"
+    #     def biz
+    #       'biz'
     #     end
     #   end
     #
-    #   a = A.new
-    #   a.welcome('jack') => 'checking jack'; 'welcome jack!';
-    #   a.goodbye('jack') => 'checking jack'; 'goodbye jack!';
+    #   A.unproxify(:foo)
+    #   a.foo # => 'foo;
+    #   a.bar # => 'BAR'
+    #   a.biz # => 'BIZ'
     #
-    #   a.class.unproxify(:welcome)
-    #
-    #   a.welcome('jack') => 'welcome jack!';
-    #   a.goodbye('jack') => 'checking jack'; 'goodbye jack!';
+    #   A.unproxify
+    #   a.foo # => 'foo;
+    #   a.bar # => 'bar'
+    #   a.biz # => 'biz'
     def unproxify(*methods)
+      methods = proxified_methods.keys if methods.empty?
+
       self.proxified_methods = proxified_methods.except(*methods)
 
       methods.each { |method| remove_proxy_method(method) }
     end
 
-    # Checks whether +method+ has been proxified.
-    def proxified?(method)
-      method.in?(proxified_methods)
+    # If given no +method+, checks whether any instance method is _proxified_,
+    # otherwise it checks for the given +method+.
+    #
+    # ======Examples
+    #
+    #   class A
+    #     include Proxified
+    #
+    #     proxify :foo, :bar do |name|
+    #       super().upcase
+    #     end
+    #
+    #     def foo
+    #       'foo'
+    #     end
+    #
+    #     def bar
+    #       'bar'
+    #     end
+    #
+    #     def biz
+    #       'biz'
+    #     end
+    #   end
+    #
+    #   A.proxified?       # => true
+    #   A.proxified?(:foo) # => true
+    #   A.proxified?(:bar) # => true
+    #   A.proxified?(:biz) # => false
+    #
+    #   A.unproxify(:foo)
+    #   A.proxified?       # => true
+    #   A.proxified?(:foo) # => false
+    #   A.proxified?(:bar) # => true
+    #   A.proxified?(:biz) # => false
+    #
+    #   A.unproxify(:bar)
+    #   A.proxified?       # => false
+    #   A.proxified?(:foo) # => false
+    #   A.proxified?(:bar) # => false
+    #   A.proxified?(:biz) # => false
+    def proxified?(method = nil)
+      method.nil? ? proxified_methods.any? : method.in?(proxified_methods)
     end
 
     private
 
     # Adds the +method+ to the proxy only if it has been proxified.
-    def method_added(method)
+    def method_added(method) # :nodoc:
       # Don't do nothing if the attribute is not defined and initialized yet
       return unless respond_to?(:proxified_methods) && proxified_methods?
 
@@ -199,7 +254,7 @@ module Proxified
     end
 
     # Unproxifies the +method+ only if it has been proxified.
-    def method_removed(method)
+    def method_removed(method) # :nodoc:
       # Don't do nothing if the attribute is not defined and initialized yet
       return unless respond_to?(:proxified_methods) && proxified_methods?
 
@@ -207,22 +262,375 @@ module Proxified
     end
 
     # Defines the +method+ in the proxy module.
-    def add_proxy_method(method)
+    def add_proxy_method(method) # :nodoc:
       # Redefine to avoid warnings if the method has already been defined
       proxy.redefine_method(method, &proxified_methods[method])
     end
 
     # Removes the +method+ from the proxy module.
-    def remove_proxy_method(method)
+    def remove_proxy_method(method) # :nodoc:
       proxy.remove_method(method) if proxy.method_defined?(method)
     end
 
     # Returns the proxy module prepending it only if it's not already present
     # in this class.
-    def proxy
+    def proxy # :nodoc:
       return const_get('Proxy', false) if const_defined?('Proxy', false)
 
       const_set('Proxy', Module.new).tap { |proxy| prepend proxy }
     end
   end
 end
+
+# Injects Proxified in the +receiver+ and _proxifies_ the given +methods+, or
+# raises ArgumentError if no +block+ or no +methods+ are given.
+#
+# +receiver+ can be a class or an ordinary object.
+#
+# If +receiver+ is a class, it is equivalent to including Proxified and calling
+# .proxify.
+#
+# If +receiver+ is an object, Proxified is injected in its singleton class and
+# other objects of the same class will not be affected.
+#
+# If +receiver+ is an object of a _proxified_ class, the class' proxy is
+# overridden but other objects of the class will not be affected.
+#
+# See Proxified.proxify for further details.
+#
+# ======Examples
+#
+# _Proxifying_ a class:
+#   class A
+#     def foo
+#       'foo'
+#     end
+#
+#     def bar
+#       'bar'
+#     end
+#   end
+#
+#   a1, a2 = A.new, A.new
+#
+#   Proxify(A, :foo) { super().upcase }
+#   a1.foo # => 'FOO'
+#   a2.foo # => 'FOO'
+#   a1.bar # => 'bar'
+#   a2.bar # => 'bar'
+#
+#
+# _Proxifying_ an object:
+#   class B
+#     def foo
+#       'foo'
+#     end
+#
+#     def bar
+#       'bar'
+#     end
+#   end
+#
+#   b1, b2 = B.new, B.new
+#
+#   Proxify(b1, :foo) { super().upcase }
+#   b1.foo # => 'FOO'
+#   b2.foo # => 'foo'
+#   b1.bar # => 'bar'
+#   b2.bar # => 'bar'
+#
+#
+# _Reproxifying_ an object of a _proxified_ class:
+#   class C
+#     def foo
+#       'foo'
+#     end
+#
+#     def bar
+#       'bar'
+#     end
+#   end
+#
+#   c1, c2 = C.new, C.new
+#
+#   Proxify(C, :foo, :bar) { super().upcase }
+#
+#   # the class proxy is overridden
+#   Proxify(c1, :foo) { 'proxified' }
+#   c1.foo # => 'proxified'
+#   c2.foo # => 'FOO'
+#   c1.bar # => 'BAR'
+#   c2.bar # => 'BAR'
+#
+#   # if super is called the class' proxy will also be called
+#   Proxify(c1, :foo) { "i am a proxified #{super()}"}
+#   c1.foo # => 'i am a proxified FOO'
+#   c2.foo # => 'FOO'
+#   c1.bar # => 'BAR'
+#   c2.bar # => 'BAR'
+def Proxify(receiver, *methods, &block)
+  raise ArgumentError, 'no block given' unless block_given?
+  raise ArgumentError, 'no methods given' if methods.empty?
+
+  target = receiver.is_a?(Class) ? receiver : receiver.singleton_class
+
+  target.include(Proxified).proxify(*methods, &block)
+end
+
+# If the +receiver+ is _proxified_ unproxifies the given +methods+, or all the
+# _proxified_ _methods_ if no +methods+ are given.
+#
+# +receiver+ can be a class or an ordinary object.
+#
+# If +receiver+ is an object of a _proxified_ class only its (eventual) proxy
+# methods will be removed and the proxy of the class will not be affected.
+#
+# See Proxified.unproxify for further details.
+#
+# ======Examples
+#
+# _Unproxifying_ a _proxified_ class:
+#   class A
+#     def foo
+#       'foo'
+#     end
+#
+#     def bar
+#       'bar'
+#     end
+#
+#     def biz
+#       'biz'
+#     end
+#   end
+#
+#   a1, a2 = A.new, A.new
+#
+#   Proxify(A, :foo, :bar, :biz) { super().upcase }
+#
+#   Unproxify(A, :foo)
+#   a1.foo # => 'foo'
+#   a2.foo # => 'foo'
+#   a1.bar # => 'BAR'
+#   a2.bar # => 'BAR'
+#   a1.biz # => 'BIZ'
+#   a2.biz # => 'BIZ'
+#
+#   Unproxify(A)
+#   a1.foo # => 'foo'
+#   a2.foo # => 'foo'
+#   a1.bar # => 'bar'
+#   a2.bar # => 'bar'
+#   a1.biz # => 'biz'
+#   a2.biz # => 'biz'
+#
+#
+# _Unproxifying_ a _proxified_ object:
+#   class B
+#     def foo
+#       'foo'
+#     end
+#
+#     def bar
+#       'bar'
+#     end
+#
+#     def biz
+#       'biz'
+#     end
+#   end
+#
+#   b1, b2 = B.new, B.new
+#
+#   Proxify(b1, :foo, :bar, :biz) { super().upcase }
+#
+#   Unproxify(b1, :foo)
+#   b1.foo # => 'foo'
+#   b2.foo # => 'foo'
+#   b1.bar # => 'BAR'
+#   b2.bar # => 'BAR'
+#   b1.biz # => 'BIZ'
+#   b2.biz # => 'BIZ'
+#
+#   Unproxify(b1)
+#   b1.foo # => 'foo'
+#   b2.foo # => 'foo'
+#   b1.bar # => 'bar'
+#   b2.bar # => 'bar'
+#   b1.biz # => 'biz'
+#   b2.biz # => 'biz'
+#
+#
+# Trying to _unproxify_ an object of a _proxified_ class:
+#   class C
+#     def foo
+#       'foo'
+#     end
+#   end
+#
+#   c1, c2 = C.new, C.new
+#
+#   Proxify(C, :foo) { super().upcase }
+#
+#   Unproxify(c1)
+#   c1.foo # => 'FOO' (does not work because an object cannot affect its class)
+#   c2.foo # => 'FOO'
+#
+#
+# _Unproxifying_ a _reproxified_ object of a _proxified_ class:
+#   class D
+#     def foo
+#       'foo'
+#     end
+#   end
+#
+#   d1, d2 = D.new, D.new
+#
+#   Proxify(D, :foo) { super().upcase }
+#
+#   Proxify(d1, :foo) { 'proxified'}
+#
+#   Unproxify(d1)
+#   d1.foo # => 'FOO' (the class proxy is restored)
+#   d2.foo # => 'FOO'
+def Unproxify(receiver, *methods)
+  target = receiver.is_a?(Class) ? receiver : receiver.singleton_class
+
+  Proxified?(target) ? target.unproxify(*methods) : methods
+end
+
+# If given no +method+, checks whether any of the +receiver+'s instance
+# methods is _proxified_, otherwise it checks for the given +method+.
+#
+# +receiver+ can be a class or an ordinary object.
+#
+# If +receiver+ is an object of a _proxified_ class and the class has at least a
+# _proxified_ method, will return true even when the +receiver+ has no
+# _proxified_ methods.
+#
+# See Proxified.proxified? for further details.
+#
+# ======Examples
+#
+# Checking if a class is _proxified_:
+#   class A
+#     def foo
+#       'foo'
+#     end
+#
+#     def bar
+#       'bar'
+#     end
+#   end
+#
+#   Proxified?(A)       # => false
+#   Proxified?(A, :foo) # => false
+#   Proxified?(A, :bar) # => false
+#
+#   Proxify(A, :foo, :bar) { 'proxified' }
+#   Proxified?(A)       # => true
+#   Proxified?(A, :foo) # => true
+#   Proxified?(A, :bar) # => true
+#
+#   Unproxify(A, :foo)
+#   Proxified?(A)       # => true
+#   Proxified?(A, :foo) # => false
+#   Proxified?(A, :bar) # => true
+#
+#   Unproxify(A, :bar)
+#   Proxified?(A)       # => false
+#   Proxified?(A, :foo) # => false
+#   Proxified?(A, :bar) # => false
+#
+#
+# Checking if an object is _proxified_:
+#   class B
+#     def foo
+#       'foo'
+#     end
+#
+#     def bar
+#       'bar'
+#     end
+#   end
+#
+#   b1, b2 = B.new, B.new
+#
+#   Proxified?(b1)       # => false
+#   Proxified?(b1, :foo) # => false
+#   Proxified?(b1, :bar) # => false
+#   Proxified?(b2)       # => false
+#   Proxified?(b2, :foo) # => false
+#   Proxified?(b2, :bar) # => false
+#
+#   Proxify(b1, :foo) { 'proxified' }
+#   Proxified?(b1)       # => true
+#   Proxified?(b1, :foo) # => true
+#   Proxified?(b1, :bar) # => false
+#   Proxified?(b2)       # => false
+#   Proxified?(b2, :foo) # => false
+#   Proxified?(b2, :bar) # => false
+#
+#   Unproxify(b1)
+#   Proxified?(b1)       # => false
+#   Proxified?(b1, :foo) # => false
+#   Proxified?(b1, :bar) # => false
+#   Proxified?(b2)       # => false
+#   Proxified?(b2, :foo) # => false
+#   Proxified?(b2, :bar) # => false
+#
+#
+# Checking if an object of a _proxified_ class is _proxified_:
+#   class C
+#     def foo
+#       'foo'
+#     end
+#
+#     def bar
+#       'bar'
+#     end
+#   end
+#
+#   c1, c2 = C.new, C.new
+#
+#   Proxify(C, :foo) { 'proxified' }
+#
+#   Proxified?(c1)       # => true
+#   Proxified?(c1, :foo) # => true
+#   Proxified?(c1, :bar) # => false
+#   Proxified?(c2)       # => true
+#   Proxified?(c2, :foo) # => true
+#   Proxified?(c2, :bar) # => false
+#
+#   Unproxify(c1)
+#   Proxified?(c1)       # => true (the class is not affected)
+#   Proxified?(c1, :foo) # => true
+#   Proxified?(c1, :bar) # => false
+#   Proxified?(c2)       # => true
+#   Proxified?(c2, :foo) # => true
+#   Proxified?(c2, :bar) # => false
+#
+#   Unproxify(C)
+#   Proxified?(c1)       # => false
+#   Proxified?(c1, :foo) # => false
+#   Proxified?(c1, :bar) # => false
+#   Proxified?(c2)       # => false
+#   Proxified?(c2, :foo) # => false
+#   Proxified?(c2, :bar) # => false
+#
+#   Proxify(c1, :foo) { 'proxified' }
+#   Unproxify(C)
+#   Proxified?(c1)       # => true (is not affected by the class)
+#   Proxified?(c1, :foo) # => true
+#   Proxified?(c1, :bar) # => false
+#   Proxified?(c2)       # => false
+#   Proxified?(c2, :foo) # => false
+#   Proxified?(c2, :bar) # => false
+def Proxified?(receiver, method = nil)
+  if receiver.is_a?(Class)
+    receiver.include?(Proxified) && receiver.proxified?(method)
+  else
+    Proxified?(receiver.singleton_class, method) ||
+      Proxified?(receiver.class, method)
+  end
+end

data/lib/proxified/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Proxified
-  VERSION = '0.1.0'.freeze
+  VERSION = '1.0.0'
 end

data/proxified.gemspec

@@ -11,18 +11,20 @@ Gem::Specification.new do |spec|
   spec.email         = ['valerio.licata.dev@gmail.com']
 
   spec.summary       = 'Proxify any object with a few lines of code.'
-  spec.description   = 'A simple way to put a proxy in front of any object.'
+  spec.description   =
+    'A simple way to put a proxy in front of any object, at any time.'
   spec.homepage      = 'https://github.com/vtsl01/proxified'
   spec.license       = 'MIT'
 
-  # # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
-  # # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the
+  # 'allowed_push_host' to allow pushing to a single host or delete this
+  # section to allow pushing to any host.
   # if spec.respond_to?(:metadata)
-  #   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  #   spec.metadata["allowed_push_host"] = "Set to 'http://mygemserver.com'"
   #
   #   spec.metadata["homepage_uri"] = spec.homepage
-  #   spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
-  #   spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  #   spec.metadata["source_code_uri"] = "Put your gem's public repo URL here."
+  #   spec.metadata["changelog_uri"] = "Put your gem's CHANGELOG.md URL here."
   # else
   #   raise "RubyGems 2.0 or newer is required to protect against " \
   #     "public gem pushes."
@@ -40,6 +42,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.required_ruby_version = '~> 2.6'
+
   spec.add_development_dependency 'bundler', '~> 1.17'
   spec.add_development_dependency 'guard', '~> 2.15'
   spec.add_development_dependency 'guard-bundler', '~> 2.2', '>= 2.2.1'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proxified
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Valerio Licata
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-31 00:00:00.000000000 Z
+date: 2019-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -140,7 +140,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.2.2
-description: A simple way to put a proxy in front of any object.
+description: A simple way to put a proxy in front of any object, at any time.
 email:
 - valerio.licata.dev@gmail.com
 executables: []
@@ -176,9 +176,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="