surrounded 0.9.9 → 0.9.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 676d57f548d17fbf0d9112208472938b7c5a2e82
-  data.tar.gz: 830bf96b8114f786840315b24fba5f90450be813
+  metadata.gz: 2236ff5ee05ddc4b3c857e3700ca2205fa966e62
+  data.tar.gz: 7e47950aaac3dd0dc4b74f18409ef5590226b5ef
 SHA512:
-  metadata.gz: 1bc24e149d0fefd9961ea08c92a01390cbdc24d94a42fa6a06e542a219838572f3c75fa8e65ec6e54324236a53950461e4b81afd7e732a0a6765220e4c5a27d6
-  data.tar.gz: dd4ee61d04717d8418e011e6421031196bada55ae25d6fb04e24c9913fc06ccc2c199a443c4f554618f3298ef6e7319d81467ee69e43b135cf7da6aa2214f0cd
+  metadata.gz: 1b6e97b48a2c4cda950b2507bff57bcb36bad18171774474405d01030f546e43b2df6adb4e8809477517953ee330df5ffde71c8d0e19af1f469103db5eece897
+  data.tar.gz: 606cb9ba7d77942a770956eb73581bd4f0fe08caf31bd8305ad404dcea7dd2dbe558521fc908160ba91c2b70bf36c644fc4aef65d940efb6353cf502be24ae3b

data/.pullreview.yml

@@ -0,0 +1,4 @@
+---
+notifications:
+  pullrequest:
+    comment: verbose

data/.travis.yml

@@ -1,17 +1,16 @@
+before_install:
+  - gem install bundler
 language: ruby
 cache: bundler
 rvm:
-  - 2.0.0
-  - 2.1.5
-  - 2.2.2
+  - 2.3.1
+  - 2.2.5
+  - 2.1.10
   - ruby-head
   - jruby-head
-  - rbx
 env:
 - COVERALLS=true
 matrix:
   allow_failures:
-    - rvm: 2.0.0
     - rvm: ruby-head
     - rvm: jruby-head
-    - rvm: rbx

data/Changelog.md

@@ -0,0 +1,8 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+
+## [0.9.10]
+
+- Do something with name collisions when a role player has an existing method of another role in the context.
+- Move InvalidRoleType exception under the host context class namespace. This allows you to rescue from your own namespace.

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013-2015 'Jim Gay'
+Copyright (c) 2013-2016 'Jim Gay'
 
 MIT License
 

data/README.md

@@ -722,6 +722,15 @@ class ActiviatingAccount
     # ...
   end
 
+  # Handle method name collisions on role players against role names in the context
+  on_name_collision :raise # will raise your context namespaced error: ActiviatingAccount::NameCollisionError
+  on_name_collision :warn
+  on_name_collision ->(message){ puts "Here's the message! #{message}" }
+  on_name_collision :my_custom_handler
+  def my_custom_handler(message)
+    # do something with the message here
+  end
+
   role :activator do # module by default
     def some_behavior; end
   end
@@ -910,6 +919,87 @@ end
 
 You can remember the method name by the convention that `remove` or `apply` describes it's function, `behavior` refers to the first argument (thet contsant holding the behaviors), and then the name of the role which refers to the role playing object: `remove_behavior_role`.
 
+##Name collisions between methods and roles
+
+Lets say that you wish to create a context as below, intending to use instances of the following two classes as role players:
+
+```ruby
+  class Postcode
+    # other methods...
+    def code
+      @code
+    end
+
+    def country
+      @country
+    end
+  end
+
+  class Country
+    # other methods...
+    def country_code
+      @code
+    end
+  end
+
+  class SendAParcel
+    extend Surrounded::Context
+
+    keyword_initialize :postcode, :country
+
+    trigger :send do
+      postcode.send
+    end
+
+    end
+    role :postcode do
+      def send
+        # do things...
+        country_code = country.country_code # name collision...probably raises an exception!
+      end
+    end
+  end
+```
+When you call the `:send` trigger you are likely to be greeted with an `NoMethodError` exception. The reason for this is that there is a name collision between `Postcode#country`, and the `:country` role in the `SendAParcel` context. Where a name collision exists, the method in the role player overrides that of the calling class and you get unexpected results.
+
+To address this issue, use `on_name_collision` to specify the name of a method to use when collisions are found:
+
+```ruby
+
+  class SendAParcel
+    extend Surrounded::Context
+
+    on_name_collision :raise
+  end
+
+```
+
+This option will raise an exception (obviously). You may use any method which is available to the context but it must accept a single message as the argument.
+
+You can also use a lambda:
+
+```ruby
+
+class SendAParcel
+  extend Surrounded::Context
+
+  on_name_collision ->(message){ puts "Here's the message: #{message}"}
+end
+
+```
+
+You may also user a class method:
+
+```ruby
+  class SendAParcel
+    extend Surrounded::Context
+
+    def self.handle_collisions(message)
+      Logger.debug "#{Time.now}: #{message}"
+    end
+  end
+```
+
 ## How to read this code
 
 If you use this library, it's important to understand it.

data/lib/surrounded/access_control.rb

@@ -1,4 +1,7 @@
 module Surrounded
+  module Context
+    class AccessError < ::StandardError; end
+  end
   module AccessControl
     def self.extended(base)
       base.send(:include, AccessMethods)

data/lib/surrounded/context.rb

@@ -7,6 +7,7 @@ require 'surrounded/context/trigger_controls'
 require 'surrounded/access_control'
 require 'surrounded/shortcuts'
 require 'surrounded/east_oriented'
+require 'surrounded/context/name_collision_detector'
 
 # Extend your classes with Surrounded::Context to handle their
 # initialization and application of behaviors to the role players
@@ -18,7 +19,7 @@ module Surrounded
   module Context
     def self.extended(base)
       base.class_eval {
-        extend RoleBuilders, Initializing, Forwarding
+        extend RoleBuilders, Initializing, Forwarding, NameCollisionDetector
 
         @triggers = Set.new
         include InstanceMethods
@@ -28,11 +29,23 @@ module Surrounded
         include trigger_mod
 
         extend TriggerControls
+
       }
+      define_exceptions(base)
     end
 
     private
 
+    def self.define_exceptions(klass)
+      self.constants.select{|const|
+        self.const_get(const) < ::StandardError
+      }.map{|exception|
+        unless klass.const_defined?(exception)
+          klass.const_set(exception, Class.new(self.const_get(exception)))
+        end
+      }
+    end
+
     # Set the default type of implementation for role methods for all contexts.
     def self.default_role_type
       @default_role_type ||= :module
@@ -135,6 +148,7 @@ module Surrounded
       end
 
       def map_roles(role_object_array)
+        detect_collisions role_object_array
         role_object_array.to_a.each do |role, object|
           if self.respond_to?("map_role_#{role}")
             self.send("map_role_#{role}", object)

data/lib/surrounded/context/initializing.rb

@@ -29,8 +29,6 @@ module Surrounded
 
       def default_initializer(params, setup_args, &block)
         private_attr_reader(*setup_args)
-
-        parameters = setup_args.map{|a| "#{a}:"}.join(',')
         @initializer_block = block || nil
         mod = Module.new
         line = __LINE__; mod.class_eval %{

data/lib/surrounded/context/name_collision_detector.rb

@@ -0,0 +1,70 @@
+module Surrounded
+  module Context
+    class NameCollisionError <::StandardError; end
+    module NameCollisionDetector
+
+      attr_reader :handler
+
+      def self.extended(base)
+        base.send :include, NameCollisionHandler
+        unless defined?(base::NameCollisionError)
+          base.const_set(:NameCollinionError, Class.new(::Surrounded::Context::NameCollisionError))
+        end
+      end
+  
+      def on_name_collision(method_name)
+        @handler = method_name
+      end
+
+      module NameCollisionHandler
+    
+        private
+    
+        def detect_collisions(role_object_map)
+          if handler
+            handle_collisions(collision_warnings(role_object_map))
+          end
+        end
+    
+        def collision_warnings(role_object_map)
+          role_object_map.select{|role, object|
+            ![object.methods & role_object_map.keys].flatten.empty?
+          }.map{|role, object|
+            role_collision_message(role,(object.methods & role_object_map.keys).sort)
+          }.join("\n")
+        end
+    
+        def handle_collisions(collisions)
+          handler_args = [collisions]
+          if handler == :raise
+            handler_args.unshift self.class::NameCollisionError
+          end
+      
+          handler_method.call(*handler_args)
+        end
+    
+        def role_collision_message(role, colliding_method_names)
+          "#{role} has name collisions with #{colliding_method_names}"
+        end
+    
+        def nothing(*); end
+
+        def handler
+          self.class.handler
+        end
+    
+        def handler_method
+          if handler.respond_to?(:call)
+            handler
+          elsif respond_to?(handler, true)
+            method(handler)
+          elsif self.class.respond_to?(handler, true)
+            self.class.method(handler)
+          else
+            method(:nothing)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/surrounded/context/role_builders.rb

@@ -1,5 +1,15 @@
 module Surrounded
   module Context
+    class InvalidRoleType < ::StandardError
+      unless method_defined?(:cause)
+        def initialize(msg=nil)
+          super
+          @cause = $!
+        end
+        attr_reader :cause
+      end
+    end
+
     module RoleBuilders
 
       # Define behaviors for your role players
@@ -13,7 +23,7 @@ module Surrounded
           meth.call(name, &block)
         end
       rescue NameError => e
-        raise InvalidRoleType, e.message
+        raise self::InvalidRoleType, e.message
       end
       alias_method :role_methods, :role
 

data/lib/surrounded/context/role_map.rb

@@ -2,6 +2,8 @@ require 'triad'
 require 'surrounded/context_errors'
 module Surrounded
   module Context
+    class InvalidRole < ::Triad::ItemNotPresent; end
+
     class RoleMap
 
       class << self

data/lib/surrounded/context_errors.rb

@@ -1,16 +1,5 @@
 require 'triad'
 module Surrounded
   module Context
-    class InvalidRole < ::Triad::ItemNotPresent; end
-    class InvalidRoleType < ::StandardError
-      unless method_defined?(:cause)
-        def initialize(msg=nil)
-          super
-          @cause = $!
-        end
-        attr_reader :cause
-      end
-    end
-    class AccessError < ::StandardError; end
   end
-end
+end

data/lib/surrounded/shortcuts.rb

@@ -8,6 +8,7 @@ module Surrounded
         instance.public_send(name)
       end
     end
+
     def store_trigger(*names)
       names.each do |name|
         define_shortcut(name)

data/lib/surrounded/version.rb

@@ -1,5 +1,5 @@
 module Surrounded
-  VERSION = "0.9.9"
+  VERSION = "0.9.10"
   
   def self.version
     VERSION

data/surrounded.gemspec

@@ -20,6 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "triad",  "~> 0.2.2"
 
-  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake"
 end

data/test/example_proxy_test.rb

@@ -13,6 +13,10 @@ class ProxyContext
     def talking_to_others
       task.name
     end
+
+    def combined_methods
+      some_admin_method
+    end
   end
 
   wrap :task do
@@ -41,6 +45,10 @@ class ProxyContext
   trigger :get_admin_method do
     admin.method(:talking_to_others)
   end
+
+  trigger :combined_interface_methods do
+    admin.combined_methods
+  end
 end
 
 ProxyUser = Class.new do
@@ -83,6 +91,15 @@ describe ProxyContext do
     assert context.admin_responds?
   end
 
+  # A Negotiator object merely applies methods to another object
+  # so that once the method is called, the object has no knowledge
+  # of the module from which the method was applied.
+  it 'does not find other interface methods' do
+    assert_raises(NameError){
+      context.combined_interface_methods
+    }
+  end
+
   it 'is able to grab methods from the object' do
     assert_equal :talking_to_others, context.get_admin_method.name
   end

data/test/name_collisions_test.rb

@@ -0,0 +1,162 @@
+require 'test_helper'
+##
+# The problem is as follows: When an object already contains a method
+# that has the same name as an actor in the context, then the object
+# defaults to its own method rather than calling the actor.
+# This is simulated in the two classes below, where HasNameCollision has
+# an empty attribute called will_collide (which is always nil). In the following
+# context, when the method collide is called on the actor will_collide, the
+# actor is ignored and the HasNameCollision#will_collide is called instead,
+# returning nil.
+##
+
+class HasNameCollision
+  include Surrounded
+
+  attr_accessor :will_collide # should always return nil
+
+  def assert_has_role
+    true
+  end
+
+  def will_collide=(_); end
+end
+
+class ShouldCollide
+  include Surrounded
+  def collide
+    return 'Method called in ShouldCollide'
+  end
+end
+
+class ContextOverridesName
+  extend Surrounded::Context
+
+  # The specific behaviour we want to test is that when a role has a method that
+  # has the same name as another role, then when that method is called strange
+  # things happen.
+  keyword_initialize :base, :will_collide
+  on_name_collision :nothing
+
+  trigger :check_setup do
+    base.assert_has_role
+  end
+
+  trigger :induce_collision do
+    base.name_collision
+  end
+
+  role :base do
+    def name_collision
+      will_collide.collide
+    end
+
+    def assert_has_role
+      true
+    end
+  end
+end
+
+class ContextWithMultipleCollisions
+  extend Surrounded::Context
+
+  on_name_collision :warn
+
+  keyword_initialize :first, :second, :third
+end
+
+class First
+
+  def second;end
+  def third;end
+end
+
+class Second
+  def first;end
+
+  def third;end
+end
+
+class Third
+  def first;end
+  def second;end
+
+end
+
+describe 'handling name collisions' do
+
+  let(:new_context_with_collision){
+    ContextOverridesName.new(base: HasNameCollision.new, will_collide: ShouldCollide.new)
+  }
+
+  after do
+    ContextOverridesName.instance_eval{
+      remove_instance_variable :@handler if defined?(@handler)
+    }
+  end
+
+  def set_handler(handler)
+    ContextOverridesName.instance_eval{
+      on_name_collision handler
+    }
+  end
+
+  it 'is works properly without handling collisions' do
+    assert new_context_with_collision.check_setup
+  end
+
+  it 'allows a name collision' do
+    err = assert_raises(NoMethodError){
+      new_context_with_collision.induce_collision
+    }
+    assert_match(/undefined method \`collide' for nil:NilClass/, err.message)
+  end
+
+  it 'can raise an exception' do
+    set_handler :raise
+    assert_raises(ContextOverridesName::NameCollisionError){
+      new_context_with_collision
+    }
+  end
+
+  it 'can print a warning' do
+    set_handler :warn
+    assert_output(nil, "base has name collisions with [:will_collide]\n") {
+      new_context_with_collision
+    }
+  end
+
+  let(:create_context_with_multiple_collisions){
+    ContextWithMultipleCollisions.new(first: First.new, second: Second.new, third: Third.new)
+  }
+
+  it 'can handle multiple collisions' do
+    expected_message = <<ERR
+first has name collisions with [:second, :third]
+second has name collisions with [:first, :third]
+third has name collisions with [:first, :second]
+ERR
+    assert_output(nil, expected_message){
+      create_context_with_multiple_collisions
+    }
+  end
+
+  it 'can use a class method' do
+    class ContextOverridesName
+      def class_method_handler(message)
+        puts message
+      end
+    end
+    set_handler :class_method_handler
+    assert_output("base has name collisions with [:will_collide]\n"){
+      new_context_with_collision
+    }
+  end
+
+  it 'can use a proc' do
+    set_handler ->(message){ puts "message from a proc: #{message}"}
+    assert_output("message from a proc: base has name collisions with [:will_collide]\n"){
+      new_context_with_collision
+    }
+  end
+end

data/test/role_context_method_test.rb

@@ -89,14 +89,16 @@ describe Surrounded::Context, '.role' do
  
   describe 'unknown' do
     it 'raises an error' do
+      class UnknownRole
+        extend Surrounded::Context
+      end
+
       err = _{
-        class UnknownRole
-          extend Surrounded::Context
- 
+        UnknownRole.instance_eval do
           role :admin, :unknown do
           end
         end
-      }.must_raise Surrounded::Context::InvalidRoleType
+      }.must_raise UnknownRole::InvalidRoleType
       _(err.cause).must_be_kind_of NameError
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: surrounded
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 0.9.10
 platform: ruby
 authors:
 - "'Jim Gay'"
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-18 00:00:00.000000000 Z
+date: 2016-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: triad
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -61,8 +61,10 @@ extra_rdoc_files: []
 files:
 - ".codeclimate.yml"
 - ".gitignore"
+- ".pullreview.yml"
 - ".simplecov"
 - ".travis.yml"
+- Changelog.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -74,6 +76,7 @@ files:
 - lib/surrounded/context.rb
 - lib/surrounded/context/forwarding.rb
 - lib/surrounded/context/initializing.rb
+- lib/surrounded/context/name_collision_detector.rb
 - lib/surrounded/context/negotiator.rb
 - lib/surrounded/context/role_builders.rb
 - lib/surrounded/context/role_map.rb
@@ -95,6 +98,7 @@ files:
 - test/example_threaded_test.rb
 - test/example_wrapper_test.rb
 - test/initialization_test.rb
+- test/name_collisions_test.rb
 - test/non_surrounded_role_player_test.rb
 - test/override_methods_test.rb
 - test/role_context_method_test.rb
@@ -121,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Create encapsulated environments for your objects.
@@ -138,6 +142,7 @@ test_files:
 - test/example_threaded_test.rb
 - test/example_wrapper_test.rb
 - test/initialization_test.rb
+- test/name_collisions_test.rb
 - test/non_surrounded_role_player_test.rb
 - test/override_methods_test.rb
 - test/role_context_method_test.rb