adherence 0.1.0 → 0.2.0

data/README.md

@@ -20,6 +20,8 @@ Adherence provides a simple means of declaring abstract behavior in Ruby modules
 
 ## Usage
 
+### Classes
+
 A class may adhere to any number of modules by use of the adheres_to method.
 
 ```ruby
@@ -42,6 +44,8 @@ module Calculator
 end
 
 class TexasInstruments
+  adheres_to ElectronicDevice, Calculator
+
   def on
     @power = true
   end
@@ -69,14 +73,49 @@ class TexasInstruments
   def self.compatible?(device1, device2)
     device1.respond_to?(:add) && device2.respond_to?(:add)
   end
+end
+```
 
-  adheres_to ElectronicDevice, Calculator
+When adheres_to is called, the existing class and instance methods defined in the class are inspected. A check is made on any method whose name and visibility matches that of a method defined in one of the specified modules. If the signature of the method defined in the class does not match that of the method defined in the module, an Adherence::NotAdheredError will be raised. Similarly, any methods defined after adheres_to is called will be inspected when added to the class. Any method not defined in the class will raise a NotImplementedError when invoked:
+
+```ruby
+class HewlettPackard
+adheres_to ElectronicDevice, Calculator
+
+  def on
+    @power = true
+  end
+
+  def off
+    @power = false
+  end
+
+  def add(x1, x2)
+    x1 + x2
+  end
+
+  def subtract(x1, x2)
+    x1 - x2
+  end
+
+  def multiply(x1, x2)
+    x1 * x2
+  end
 end
+
+> device1 = HewlettPackard.new
+> device2 = HewlettPackard.new
+
+> device1.divide(12, 4)
+Adherence::NotImplementedError: "HewlettPackard must define divide"
+
+> HewlettPackard.compatible?(device1, device2)
+Adherence::NotImplementedError: "HewlettPackard must define compatible?"
 ```
 
-A class must define all instance and class methods of all visibilities defined in each module passed to adheres_to or an error is raised. Not only must all methods be defined, but their method signitures must match those of the specified module(s). Failure to implement all methods will result in a NotImplementedError when the class is loaded. Failure to incorrectly declare a message signature will result in a Adherence::NotAdheredError when the class is loaded. Because the methods defined in the class must be inspected, adheres_to must be called after the methods are defined in the class.
+### Modules
 
-Similarly, a module may adhere to other modules:
+A module may adhere to other modules:
 
 ```ruby
 module ScientificCalculator

data/adherence.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |spec|
   spec.name         = "adherence"
-  spec.version      = "0.1.0"
-  spec.date         = "2012-08-30"
+  spec.version      = "0.2.0"
+  spec.date         = "2012-09-10"
   spec.summary      = "Adds simple interface-like behavior to Ruby"
   spec.authors      = ["Mike Bradford"]
   spec.email        = "mbradford@47primes.com"

data/lib/adherence.rb

@@ -1,12 +1,36 @@
 Dir.glob(File.dirname(__FILE__) + "/adherence/*.rb").each {|f| require f}
 
 module Adherence
+	module HelperMethods
+		private
+
+	  def add_method(method, singleton_method=false)
+		  name   = method.name
+		  params = method.parameters.reduce([]) do |memo, word|
+		              arity, param = word
+		              case arity
+		              when :req then memo << "#{param}"
+		              when :opt then memo << "#{param}=nil"
+		              when :block then memo << "&#{param}"
+		              when :rest then memo << "*#{param}"
+		              end
+		            end.join(", ")
+		  
+		  module_eval <<-DEF
+		    def #{"self." if singleton_method}#{name}(#{params})
+		      raise NotImplementedError, "This method must be defined in the calling class."
+		    end
+		  DEF
+		end
+	end
 end
 
 class Module
+  include Adherence::HelperMethods
   include Adherence::Module
 end
 
 class Class
+	include Adherence::HelperMethods
   include Adherence::Class
 end

data/lib/adherence/class.rb

@@ -2,37 +2,90 @@ module Adherence
   class NotAdheredError < NotImplementedError; end
   module Class
 
-    def adheres_to(*args)
-      args.each {|mod| adheres_to_module mod}
-    end
-
     private
 
-    def adheres_to_module(mod)
-      raise ArgumentError, "Module expected" unless mod.class.to_s == "Module"
+    def adheres_to(*mods)
+      @adhered_modules = []
 
-      (mod.instance_methods(false) + mod.private_instance_methods(false)).each do |method|
-        if !(instance_methods + private_instance_methods).include?(method)
-          raise NotImplementedError, "#{self.class} must define #{method}"
+      mods.each {|mod| adheres_to_module mod}
+
+      class_eval do
+        def self.method_added(method)
+          @adhered_modules.each do |mod|
+            if mod.instance_methods(false).include?(method) && !equal?(instance_method(method), mod.instance_method(method))
+              raise NotAdheredError, "Signature does not match #{mod}##{method}"
+            end
+          end
         end
-        if !equal? instance_method(method), mod.instance_method(method)
-          raise NotAdheredError, "Signature does not match #{mod}##{method}"
+
+        def self.singleton_method_added(method)
+          @adhered_modules.each do |mod|
+            if mod.singleton_class.instance_methods(false).include?(method) && !equal?(singleton_class.instance_method(method), mod.singleton_class.instance_method(method))
+              raise NotAdheredError, "Signature does not match #{mod}.#{method}"
+            end
+          end
         end
       end
+    end
 
-      module_class_methods = mod.singleton_class.instance_methods(false) + mod.singleton_class.private_instance_methods(false)
-      module_class_methods.each do |method|
-        if !(singleton_class.instance_methods + singleton_class.private_instance_methods).include?(method)
-          raise NotImplementedError, "#{self.class} must define self.#{method}"
+    def adheres_to_module(mod)
+      raise ArgumentError, "Module expected" unless mod.class.to_s == "Module"
+      @adhered_modules << mod
+
+      # Add all instance methods from mod not already defined in class
+
+      public_instance_methods_to_add = mod.public_instance_methods(false).reject {|m| public_method_defined?(m)}
+      protected_instance_methods_to_add = mod.protected_instance_methods(false).reject {|m| protected_method_defined?(m)}
+      private_instance_methods_to_add = mod.private_instance_methods(false).reject {|m| private_method_defined?(m)}
+
+      (public_instance_methods_to_add + protected_instance_methods_to_add + private_instance_methods_to_add).each do |method|
+        add_method mod.instance_method(method)
+      end
+      public *public_instance_methods_to_add
+      protected *protected_instance_methods_to_add
+      private *private_instance_methods_to_add
+
+      # Add all class methods from mod not already defined in class
+
+      public_class_methods_to_add = mod.singleton_class.public_instance_methods(false).reject {|m| singleton_class.public_method_defined?(m)}
+      protected_class_methods_to_add = mod.singleton_class.protected_instance_methods(false).reject {|m| singleton_class.protected_method_defined?(m)}
+      private_class_methods_to_add = mod.singleton_class.private_instance_methods(false).reject {|m| singleton_class.private_method_defined?(m)}
+
+      (public_class_methods_to_add + protected_class_methods_to_add + private_class_methods_to_add).each do |method|
+        add_method mod.singleton_class.instance_method(method), true
+      end
+      singleton_class.send :public, *public_class_methods_to_add
+      singleton_class.send :protected, *protected_class_methods_to_add
+      singleton_class.send :private, *private_class_methods_to_add
+
+      # Ensure all instance methods have the same signature of those defined in mod
+
+      %w(public protected private).each do |visibility|
+        send("#{visibility}_instance_methods", false).each do |method|
+          if mod.send("#{visibility}_method_defined?", method) && !equal?(instance_method(method), mod.instance_method(method))
+            raise NotAdheredError, "Signature does not match #{mod}##{method}"
+          end
         end
-        if !equal? singleton_class.instance_method(method), mod.singleton_class.instance_method(method)
-          raise NotAdheredError, "Signature does not match #{mod}.#{method}"
+      end
+
+      # Ensure all class methods have the same signature of those defined in mod
+
+      %w(public protected private).each do |visibility|
+        singleton_class.send("#{visibility}_instance_methods", false).each do |method|
+          if mod.singleton_class.send("#{visibility}_method_defined?", method) && !equal?(singleton_class.instance_method(method), mod.singleton_class.instance_method(method))
+            raise NotAdheredError, "Signature does not match #{mod}.#{method}"
+          end
         end
       end
     end
 
+    class <<self
+      attr_reader :adhered_modules
+    end
+
     def equal?(method1, method2)
       method1.name == method2.name && method1.parameters == method2.parameters ? true : false
     end
+
   end
 end

data/lib/adherence/module.rb

@@ -40,24 +40,5 @@ module Adherence
       private_class_method *mod.singleton_class.private_instance_methods(false)
     end
 
-    def add_method(method, singleton_method=false)
-        name   = method.name
-        params = method.parameters.reduce([]) do |memo, word|
-                    arity, param = word
-                    case arity
-                    when :req then memo << "#{param}"
-                    when :opt then memo << "#{param}=nil"
-                    when :block then memo << "&#{param}"
-                    when :rest then memo << "*#{param}"
-                    end
-                  end.join(", ")
-        
-        module_eval <<-DEF
-          def #{"self." if singleton_method}#{name}(#{params})
-            raise NotImplementedError, "This method must be defined in the calling class."
-          end
-        DEF
-    end
-
   end
 end

data/spec/adherence_class_spec.rb

@@ -16,89 +16,156 @@ end
 
 describe Object, "adheres_to" do
 
-  before do
-    class Duck
-      attr_reader :name
+  it "should succeed if the object has defined all behavior from the module" do
+    expect do 
+      class Duck
+        adheres_to Animal
+
+        def speak
+          "quack"
+        end
 
-      def initialize(name)
-        @name = name
+        def move(feet)
+          "waddle #{feet} feet"
+        end
+
+        private
+
+        def life_expectancy
+          10
+        end
+
+        def self.build(name, &block)
+          new
+        end
       end
+    end.to_not raise_error
+  end
+
+  it "should raise an error if argument is not a module" do
+    expect do 
+      class Otter 
+        adheres_to Class.new
+      end
+    end.to raise_error(ArgumentError)
+  end
+
+  it "should raise an error if a non-implemented class method is called" do
+    class Dog
+      adheres_to Animal
 
       def speak
-        "quack"
+        "woof"
       end
 
       def move(feet)
-        "waddle #{feet} feet"
+        "trots #{feet} feet"
       end
 
       private
 
       def life_expectancy
-        10
+        13
+      end
+    end
+
+    expect { Dog.build("fido") }.to raise_error(NotImplementedError)
+  end
+
+  it "should raise an error if a non-implemented instance method is called" do
+    class Shark
+      adheres_to Animal
+
+      def move(feet)
+        "swim #{feet} feet"
+      end
+
+      private
+
+      def life_expectancy
+        32
       end
 
       def self.build(name, &block)
-        Duck.new(name)
+        new
       end
     end
+
+    expect { Shark.new.speak }.to raise_error(NotImplementedError)
   end
 
-  it "should succeed if the object has defined all behavior from the module" do
-    expect do 
-      class Duck
-        adheres_to Animal
+  it "should raise an error if a non-implemented private instance method is called" do
+    class Horse
+      adheres_to Animal
+
+      def speak
+        "neigh"
       end
-    end.to_not raise_error
-  end
 
-  it "should raise an error if argument is not a module" do
-    expect do 
-      class Duck 
-        adheres_to Class.new
+      def move(feet)
+        "gallop #{feet} feet"
       end
-    end.to raise_error(ArgumentError)
-  end
 
-  it "should raise an error if all methods are not implemented" do
-    Duck.send(:remove_method, :speak)
+      private
 
-    expect do 
-      class Duck
-        adheres_to Animal
+      def self.build(name, &block)
+        new
       end
-    end.to raise_error(NotImplementedError)
-  end
+    end
 
-  it "should raise an error if all private methods are not implemented" do
-    Duck.send(:remove_method, :life_expectancy)
+    expect { Horse.new.send(:life_expectancy) }.to raise_error(NotImplementedError)
+  end
 
+  it "should raise an error if instance method is implemented with an invalid signature" do
     expect do 
-      class Duck
+      class Bear
         adheres_to Animal
-      end
-    end.to raise_error(NotImplementedError)
-  end
 
-  it "should raise an error if all class methods are not implemented" do
-    Duck.singleton_class.send(:remove_method, :build)
+        def speak
+          "grrrr"
+        end
 
-    expect { Duck.adheres_to(Animal) }.to raise_error(NotImplementedError)
-  end
+        def move(distance)
+          "run #{distance} feet"
+        end
+
+        private
+
+        def life_expectancy
+          30
+        end
 
-  it "should raise an error if methods are implemented with an invalid signature" do
-    Duck.send(:remove_method, :move)
-    Duck.class_eval do
-      def move(distance)
-        "waddle #{distance} feet"
+        def self.build(name, &block)
+          new
+        end
       end
-    end
+    end.to raise_error(Adherence::NotAdheredError, "Signature does not match Animal#move")
+  end
 
+  it "should raise an error if class method is implemented with an invalid signature", class_method: true do
     expect do 
-      class Duck
+      class Person
         adheres_to Animal
+
+        def speak
+          "hello"
+        end
+
+        def move(feet)
+          "walk #{distance} feet"
+        end
+
+        private
+
+        def life_expectancy
+          80
+        end
+
+        def self.build(name)
+          new
+        end
       end
-    end.to raise_error(Adherence::NotAdheredError)
+    end.to raise_error(Adherence::NotAdheredError, "Signature does not match Animal.build")
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: adherence
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-30 00:00:00.000000000 Z
+date: 2012-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -40,10 +40,10 @@ files:
 - ./lib/adherence/module.rb
 - ./lib/adherence.rb
 - ./README.md
-- ./spec/adherence_module_spec.rb
 - ./spec/adherence_class_spec.rb
-- spec/adherence_module_spec.rb
+- ./spec/adherence_module_spec.rb
 - spec/adherence_class_spec.rb
+- spec/adherence_module_spec.rb
 homepage: http://github.com/47primes/adherence
 licenses: []
 post_install_message: 
@@ -64,10 +64,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Adds simple interface-like behavior to Ruby
 test_files:
-- spec/adherence_module_spec.rb
 - spec/adherence_class_spec.rb
+- spec/adherence_module_spec.rb