method_found 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c80b59b4cfa2a683e9eaf250f975cebeff2594f0
-  data.tar.gz: 7004c79a99fddd803d098f4ebabe5541d8ebfeae
+  metadata.gz: 9bc50110082afd5058e16422c320e7b48ca7ea75
+  data.tar.gz: 154aa54df987957c7b405ac9f669546a69790f33
 SHA512:
-  metadata.gz: ccb77ec85e8d6b98b66315c53853088308ba74a760dabe638499717f597ccdf9c2dcf44378cb1c4c1a26cf35202963fc8116c6154d785581f7a43b7dee4e96f6
-  data.tar.gz: b76fbe65a0a186bb5f361ab251c9d514e20b020aa0ac0949dfacfcf832e8a997392c519c23e85615227599ec0ed97feeedf5facdd1372792692fa41a2fac69e9
+  metadata.gz: 3ccf3e88a3726c8c709b0df1c479952d85f08e787e2d1cf218eeef2a59f1f62128dbc27e534fb13c214b55f0c0c7644b418ec66d7502247316fe209c11f544b0
+  data.tar.gz: 2bb0be7f5e689e5aec743de2dc90d5bbb0bcf534ff76207afede9373eac35ae52073fcd63951859d4e656f7c227f646dc98fc12837fdf6689188db1311f035ba

data/README.md

@@ -14,7 +14,7 @@ Intercept `method_missing` and do something useful with it.
 Add to your Gemfile:
 
 ```ruby
-gem 'method_found', '~> 0.1.3'
+gem 'method_found', '~> 0.1.4'
 ```
 
 And bundle it.

data/lib/method_found/attribute_interceptor.rb

@@ -0,0 +1,73 @@
+require "method_found"
+
+module MethodFound
+=begin
+
+Class defining prefix, suffix and affix methods to a class for a given
+attribute name or set of attribute names.
+
+@example
+  class Person < Struct.new(:attributes)
+    include MethodFound::AttributeInterceptor.new
+    include MethodFound::AttributeInterceptor.new(suffix: '=')
+    include MethodFound::AttributeInterceptor.new(suffix: '_contrived?')
+    include MethodFound::AttributeInterceptor.new(prefix: 'clear_')
+    include MethodFound::AttributeInterceptor.new(prefix: 'reset_', suffix: '_to_default!')
+
+    def initialize(attributes = {})
+      super(attributes)
+    end
+
+    private
+
+    def attribute_contrived?(attr)
+      true
+    end
+
+    def clear_attribute(attr)
+      send("#{attr}=", nil)
+    end
+
+    def reset_attribute_to_default!(attr)
+      send("#{attr}=", 'Default Name')
+    end
+
+    def attribute(attr)
+      attributes[attr]
+    end
+
+    def attribute=(attr, value)
+      attributes[attr] = value
+    end
+  end
+=end
+  class AttributeInterceptor < Interceptor
+    def initialize(prefix: '', suffix: '')
+      @prefix, @suffix = prefix, suffix
+      regex_ = regex
+      attribute_matcher = proc do |method_name|
+        (matches = regex_.match(method_name)) && attributes.include?(matches[1]) && matches[1]
+      end
+      attribute_matcher.define_singleton_method :inspect do
+        regex_.inspect
+      end
+
+      super attribute_matcher do |_, attr_name, *arguments, &block|
+        send("#{prefix}attribute#{suffix}", attr_name, *arguments, &block)
+      end
+    end
+
+    def regex
+      /\A(?:#{Regexp.escape(@prefix)})(.*)(?:#{Regexp.escape(@suffix)})\z/.freeze
+    end
+
+    def define_attribute_methods(*attr_names)
+      prefix, suffix = @prefix, @suffix
+      attr_names.each do |attr_name|
+        define_method "#{@prefix}#{attr_name}#{@suffix}".freeze do |*arguments, &block|
+          send("#{prefix}attribute#{suffix}".freeze, attr_name, *arguments, &block)
+        end
+      end
+    end
+  end
+end

data/lib/method_found/attribute_methods.rb

@@ -0,0 +1,69 @@
+require "method_found/attribute_interceptor"
+
+module MethodFound
+=begin
+
+@example
+  class Person < Struct.new(:attributes)
+    include MethodFound::AttributeMethods
+
+    attribute_method_suffix ''
+    attribute_method_suffix '='
+    attribute_method_suffix '_contrived?'
+    attribute_method_prefix 'clear_'
+    attribute_method_affix  prefix: 'reset_', suffix: '_to_default!'
+
+    define_attribute_methods :name
+
+    def initialize(attributes = {})
+      super(attributes)
+    end
+
+    private
+
+    def attribute_contrived?(attr)
+      true
+    end
+
+    def clear_attribute(attr)
+      send("#{attr}=", nil)
+    end
+
+    def reset_attribute_to_default!(attr)
+      send("#{attr}=", 'Default Name')
+    end
+
+    def attribute(attr)
+      attributes[attr]
+    end
+
+    def attribute=(attr, value)
+      attributes[attr] = value
+    end
+  end
+
+=end
+  module AttributeMethods
+    def self.included(base)
+      base.instance_eval do
+        def attribute_method_affix(prefix: '', suffix: '')
+          include(AttributeInterceptor.new(prefix: prefix, suffix: suffix))
+        end
+
+        def attribute_method_suffix(suffix)
+          include(AttributeInterceptor.new(suffix: suffix))
+        end
+
+        def attribute_method_prefix(prefix)
+          include(AttributeInterceptor.new(prefix: prefix))
+        end
+
+        def define_attribute_methods(*attributes)
+          ancestors.each do |ancestor|
+            ancestor.define_attribute_methods(*attributes) if ancestor.is_a?(AttributeInterceptor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/method_found/interceptor.rb

@@ -27,7 +27,7 @@ string/symbol.
       method_cacher = method(:cache_method)
 
       define_method :method_missing do |method_name, *arguments, &method_block|
-        if matches = matcher_.match(method_name)
+        if matches = matcher_.match(method_name, self)
           method_cacher.(method_name, matches)
           send(method_name, *arguments, &method_block)
         else
@@ -36,7 +36,7 @@ string/symbol.
       end
 
       define_method :respond_to_missing? do |method_name, include_private = false|
-        if matches = matcher_.match(method_name)
+        if matches = matcher_.match(method_name, self)
           method_cacher.(method_name, matches)
         else
           super(method_name, include_private)
@@ -53,9 +53,13 @@ string/symbol.
     private
 
     def cache_method(method_name, matches)
-      intercept_method = @intercept_method
+      intercept_method, matcher = @intercept_method, @matcher
       define_method method_name do |*arguments, &block|
-        send(intercept_method, method_name, matches, *arguments, &block)
+        if matcher.proc? && !(matches = matcher.match(method_name, self))
+          return super(*arguments, &block)
+        end
+        arguments = [matches, *arguments] unless method(intercept_method).arity == 1
+        send(intercept_method, method_name, *arguments, &block)
       end
     end
 
@@ -66,16 +70,20 @@ string/symbol.
     end
 
     class Matcher < Struct.new(:matcher)
-      def match(method_name)
+      def match(method_name, context)
         if matcher.is_a?(Regexp)
           matcher.match(method_name)
         elsif matcher.respond_to?(:call)
-          matcher.call(method_name) && [method_name.to_s]
+          context.instance_exec(method_name, &matcher)
         else
-          (matcher.to_sym == method_name) && [method_name.to_s]
+          (matcher.to_sym == method_name)
         end
       end
 
+      def proc?
+        matcher.is_a?(Proc)
+      end
+
       def inspect
         matcher.inspect
       end

data/lib/method_found/version.rb

@@ -1,3 +1,3 @@
 module MethodFound
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: method_found
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Chris Salzberg
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-23 00:00:00.000000000 Z
+date: 2017-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,9 +71,10 @@ files:
 - bin/console
 - bin/setup
 - lib/method_found.rb
+- lib/method_found/attribute_interceptor.rb
+- lib/method_found/attribute_methods.rb
 - lib/method_found/builder.rb
 - lib/method_found/interceptor.rb
-- lib/method_found/simple_model.rb
 - lib/method_found/version.rb
 - method_found.gemspec
 homepage: https://github.com/shioyama/method_found

data/lib/method_found/simple_model.rb

@@ -1,109 +0,0 @@
-require "method_found"
-
-module MethodFound
-=begin
-
-Example class using MethodFound interceptors to implement attributes and change
-tracking. Symbols passed into constructor define patterns in interceptor
-modules to catch method calls and define methods on module as needed. New
-methods can be dynamically defined by calling any undefined method with a bang (!).
-
-This class is not included by default when requiring MethodFound, so you will need to explicitly require it with:
-
-  require "method_found/simple_model"
-
-@example Setting Attributes
-  post = MethodFound::SimpleModel.new(:title, :content)
-
-  post.title = "Method Found"
-  post.content = "Once upon a time..."
-
-  post.title
-  #=> "Method Found"
-
-  post.content
-  #=> "Once upon a time..."
-
-@example Dyanamically defining new attributes
-  post = MethodFound::SimpleModel.new
-
-  post.foo
-  #=> raises MethodNotFound error
-
-  post.foo!
-  #=> nil
-
-  post.foo = "my foo"
-  post.foo
-  #=> "my foo"
-
-@example Tracking changes
-  post = MethodFound::SimpleModel.new(:title)
-
-  post.title = "foo"
-  post.title_changed?
-  #=> false
-
-  post.title = "bar"
-  post.title_changed?
-  #=> true
-  post.title_was
-  #=> "foo"
-  post.title_changes
-  #=> ["bar", "foo"]
-
-=end
-  class SimpleModel
-    attr_reader :attribute_builder
-
-    # @param attribute_names [Symbol] One or more attribute names to define
-    #   interceptors for on model.
-    def initialize(*attribute_names)
-      @attributes = Hash.new { |h, k| h[k] = [] }
-
-      @attribute_builder = builder = Builder.new do
-        def define_missing(attribute_name)
-          intercept /\A(#{attribute_name})(=|\?)?\Z/.freeze do |_, matches, *arguments|
-            name  = matches[1]
-            value = @attributes[name].last
-
-            if matches[2] == "=".freeze
-              new_value = arguments[0]
-              @attributes[name].push(new_value) unless new_value == value
-            else
-              matches[2] == "?".freeze ? !!value : value
-            end
-          end
-
-          intercept /\A(reset_(#{attribute_name})|(#{attribute_name})_(changed\?|changes|was))\Z/.freeze do |_, matches|
-            if matches[1] == "reset_#{attribute_name}".freeze
-              !!@attributes.delete(matches[2])
-            else
-              changes = @attributes[matches[3]]
-              if matches[4] == "changes".freeze
-                changes.reverse
-              elsif matches[4] == "was".freeze
-                changes[-2]
-              else
-                changes.size > 1
-              end
-            end
-          end
-        end
-
-        intercept /\A(.+)\!\Z/ do |_, matches|
-          builder.define_missing matches[1]
-          singleton_class.include builder
-          @attributes[matches[1]].last
-        end
-      end
-      attribute_names.each { |name| builder.define_missing(name) }
-
-      singleton_class.include builder
-    end
-
-    def attributes
-      Hash[@attributes.map { |k, v| [k, v.last] }]
-    end
-  end
-end