surrounded 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8490f4520253094598c520cdc7b3a73186d48d5
-  data.tar.gz: 31d8f5baebf2e1f42b761207972de0523ac41885
+  metadata.gz: f7ef86c7f64ee33fa79398d58bbdcb13ed3f8e4e
+  data.tar.gz: 9f65308ecb76695601b51fa5a7f745b21e7ca866
 SHA512:
-  metadata.gz: 161b86c91796ead35d60f817308a252585544b3690055039c026bf2ad97bf0f3ed5573709fd341673681399dcb8687113102cf698e2c5f255856d22e47471e2a
-  data.tar.gz: 975026239c9e4e2796d8f66f73c062c7907159beeaf30a8f0dfea8ee69960d970155bfdcdc1ec69b81a6c13c5ed9ad8d862cfdcfb159108758da8293db4cb270
+  metadata.gz: 2f83e74f34de171f5f66170b9f481624a4a148ce448fb880c59318dc9d2f9389e25321dc6552ba0c8058ec475a67be5bc297d82453f3a3f0e37cbe8a367e993d
+  data.tar.gz: 84e3aa18ddaf6b1b30c60897152e5dab28fe545df81566a3bd3c40cbbee3b7108e5a7bdfcb3c4a70520c9a913bac64ad27ee716d85b6d32cd696e0069ef87fb3

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
+cache: bundler
 rvm:
   - 2.0.0
   - 2.1.1

data/README.md

@@ -6,9 +6,7 @@
 [![Coverage Status](https://coveralls.io/repos/saturnflyer/surrounded/badge.png)](https://coveralls.io/r/saturnflyer/surrounded)
 [![Gem Version](https://badge.fury.io/rb/surrounded.png)](http://badge.fury.io/rb/surrounded)
 
-# Get work done with only what you need and nothing more.
-
-Surrounded is designed to help you better manage your business logic.
+Surrounded is designed to help you better manage your business logic by keeping cohesive behaviors together. Bring objects together to implement your use cases and gain behavior only when necessary.
 
 ## How to think about your objects
 
@@ -543,10 +541,12 @@ Using the `role` method to define modules and classes takes care of the setup fo
   end
 ```
 
-The `:interface` option is a special object which has all of its methods removed (excepting `__send__` and `object_id`) so that other methods will be pulled from the ones that you define, or from the object it attempts to proxy.
+The `:interface` option is a special object which has all of the standard Object methods removed (excepting `__send__` and `object_id`) so that other methods will be pulled from the ones that you define, or from the object it attempts to proxy.
 
 Notice that the `:interface` allows you to return `self` whereas the `:wrap` acts more like a wrapper and forces you to deal with that shortcoming by using it's wrapped-object-accessor method: `__getobj__`.
 
+The downside of using an interface is that it is still a wrapper. All of your defined role methods are executed in the context of the object playing the role, but the interface has it's own identity.
+
 If you'd like to choose one and use it all the time, you can set the default:
 
 ```ruby
@@ -636,6 +636,13 @@ class ActiviatingAccount
   # these also must be done if you create your own initialize method.
   # this is a shortcut for using attr_reader and private
   private_attr_reader :activator, :account
+  
+  # initialize with keyword arguments
+  keyword_initialize(:activator, :account)
+  # this makes the following instance method signature with required keyword arguments
+  def initialize(activator:, account:)
+    # ...
+  end
 
   role :activator do # module by default
     def some_behavior; end
@@ -724,7 +731,7 @@ end
 
 ## Dependencies
 
-The dependencies are minimal. The plan is to keep it that way but allow you to configure things as you need. The [Triad](http://github.com/saturnflyer/triad) project was written specifically to manage the mapping of roles and objects to the modules which contain the behaviors.
+The dependencies are minimal. The plan is to keep it that way but allow you to configure things as you need. The [Triad](http://github.com/saturnflyer/triad) project was written specifically to manage the mapping of roles and objects to the modules which contain the behaviors. It is used in Surrounded to keep track of role player, roles, and role constant names but it is not a hard requirement. You may implement your own but presently you'll need to dive into the implementation to fully understand how. Future updates may provide better support and guidance.
 
 If you're using [Casting](http://github.com/saturnflyer/casting), for example, Surrounded will attempt to use that before extending an object, but it will still work without it.
 

data/lib/surrounded/access_control.rb

@@ -30,7 +30,7 @@ module Surrounded
     
     def define_access_method(name, &block)
       mod = Module.new
-      mod.class_eval {
+      num = __LINE__; mod.class_eval {
         define_method "disallow_#{name}?" do
           begin
             apply_behaviors

data/lib/surrounded/context/initializing.rb

@@ -10,13 +10,32 @@ module Surrounded
         line = __LINE__
         mod.class_eval "
           def initialize(#{setup_args.join(',')})
-            @role_map = RoleMap.new
+            @role_map = role_mapper_class.new
             map_roles(#{setup_args.to_s}.zip([#{setup_args.join(',')}]))
           end
         ", __FILE__, line
         const_set("ContextInitializer", mod)
         include mod
       end
+
+      def keyword_initialize(*setup_args)
+        private_attr_reader(*setup_args)
+
+        parameters = setup_args.map{|a| "#{a}:"}.join(',')
+        puts parameters
+
+        mod = Module.new
+        line = __LINE__
+        mod.class_eval %{
+          def initialize(#{parameters})
+            @role_map = role_mapper_class.new
+            map_roles(#{setup_args.to_s}.zip([#{setup_args.join(',')}]))
+          end
+        }, __FILE__, line
+        const_set("ContextInitializer", mod)
+        include mod
+      end
+      alias initialize_with_keywords keyword_initialize
     end
   end
 end

data/lib/surrounded/context/negotiator.rb

@@ -1,12 +1,31 @@
 module Surrounded
   module Context
     class Negotiator
+      class << self
+        # Return a class which has methods defined to forward the method to
+        # the wrapped object delegating to the behavior module.
+        # This prevents hits to method_missing.
+        def for_role(mod)
+          klass = Class.new(self)
+          mod.instance_methods(false).each do |meth|
+            num = __LINE__; klass.class_eval %{
+              def #{meth}(*args, &block)
+                @behaviors.instance_method(:#{meth}).bind(@object).call(*args, &block)
+              end
+            }, __FILE__, num
+          end
+          klass
+        end
+      end
+
+
       identity = "__send__|object_id"
 
-      instance_methods.each do |meth|
-        unless meth.to_s =~ /#{identity}/
-          undef_method meth
-        end
+      # Remove all methods except the identity methods
+      instance_methods.reject{ |m|
+        m.to_s =~ /#{identity}/
+      }.each do |meth|
+        undef_method meth
       end
 
       private
@@ -16,15 +35,17 @@ module Surrounded
       end
 
       def method_missing(meth, *args, &block)
-        if @behaviors.instance_methods.include?(meth)
-          the_method = @behaviors.instance_method(meth)
-          the_method.bind(@object).call(*args, &block)
-        else
-          @object.send(meth, *args, &block)
-        end
+        @object.send(meth, *args, &block)
+      end
+
+      def respond_to_missing?(meth, include_private=false)
+        @object.respond_to?(meth, include_private)
       end
     end
 
+    # The method_missing definition from Surrounded will apply
+    # before the one defined above. This allows the methods for
+    # the objects in the context to work properly
     Negotiator.send(:prepend, Surrounded)
   end
 end

data/lib/surrounded/context/role_builders.rb

@@ -5,7 +5,7 @@ module Surrounded
       # Define behaviors for your role players
       def role(name, type=default_role_type, &block)
         if type == :module
-          mod_name = RoleBuilders.mod_name(name)
+          mod_name = RoleName(name)
           mod = Module.new(&block).send(:include, ::Surrounded)
           private_const_set(mod_name, mod)
         else
@@ -20,7 +20,7 @@ module Surrounded
       # Create a named behavior for a role using the standard library SimpleDelegator.
       def wrap(name, &block)
         require 'delegate'
-        wrapper_name = RoleBuilders.mod_name(name)
+        wrapper_name = RoleName(name)
         klass = private_const_set(wrapper_name, Class.new(SimpleDelegator, &block))
         klass.send(:include, Surrounded)
       end
@@ -30,7 +30,7 @@ module Surrounded
       # This ties the implementation of the role to a specific class or module API.
       def delegate_class(name, class_name, &block)
         require 'delegate'
-        wrapper_name = RoleBuilders.mod_name(name)
+        wrapper_name = RoleName(name)
         klass = private_const_set(wrapper_name, DelegateClass(Object.const_get(class_name.to_s)))
         klass.class_eval(&block)
         klass.send(:include, Surrounded)
@@ -38,19 +38,23 @@ module Surrounded
 
       # Create an object which will bind methods to the role player
       def interface(name, &block)
-        interface_name = RoleBuilders.mod_name(name) + 'Interface'
-
+        # AdminInterface
+        interface_name = RoleName(name, 'Interface')
         behavior = private_const_set(interface_name, Module.new(&block))
 
         require 'surrounded/context/negotiator'
         undef_method(name)
+
+        # AdminInterfaceProxy
+        proxy = private_const_set(RoleName(interface_name, 'Proxy'), Negotiator.for_role(behavior))
         define_method(name) do
-          instance_variable_set("@#{name}", Negotiator.new(role_map.assigned_player(name), behavior))
+          instance_variable_set("@#{name}", proxy.new(role_map.assigned_player(name), behavior))
         end
       end
       
-      def self.mod_name(name)
-        name.to_s.gsub(/(?:^|_)([a-z])/){ $1.upcase }
+      private
+      def RoleName(text, suffix=nil)
+        RoleName.new(text, suffix)
       end
 
     end

data/lib/surrounded/context/role_map.rb

@@ -2,7 +2,27 @@ require 'triad'
 require 'surrounded/context_errors'
 module Surrounded
   module Context
-    class RoleMap < Triad
+    class RoleMap
+
+      class << self
+        def from_base(klass=::Triad)
+          role_mapper = Class.new(::Surrounded::Context::RoleMap)
+          num = __LINE__; role_mapper.class_eval %{
+            def container
+              @container ||= #{klass}.new
+            end
+          }, __FILE__, num
+          %w{ update each values keys }.each do |meth|
+            num = __LINE__; role_mapper.class_eval %{
+              def #{meth}(*args, &block)
+                container.send(:#{meth}, *args, &block)
+              end
+            }, __FILE__, num
+          end
+          role_mapper
+        end
+      end
+
       def role?(role)
         keys.include?(role)
       end

data/lib/surrounded/context.rb

@@ -88,6 +88,14 @@ module Surrounded
       end
     end
 
+    # Allow alternative implementations for the role map
+    # This requires that the specified mapper klass have an
+    # initializer method called 'from_base' which accepts a
+    # class name used to initialize the base object
+    def role_mapper_class(mapper: RoleMap, base: ::Triad)
+      @role_mapper_class ||= mapper.from_base(base)
+    end
+
     module InstanceMethods
       # Check whether a given name is a role inside the context.
       # The provided block is used to evaluate whether or not the caller
@@ -111,7 +119,7 @@ module Surrounded
       private
 
       def role_map
-        @role_map ||= RoleMap.new
+        @role_map ||= role_mapper_class.new
       end
 
       def map_roles(role_object_array)
@@ -189,14 +197,14 @@ module Surrounded
       def apply_behaviors
         role_map.each do |role, mod_name, object|
           player = apply_behavior(role, mod_name, object)
-          player.send(:store_context, self) do; end
+          player.__send__(:store_context) do; end
         end
       end
 
       def remove_behaviors
         role_map.each do |role, mod_name, player|
           if player.respond_to?(:remove_context, true)
-            player.send(:remove_context) do; end
+            player.__send__(:remove_context) do; end
           end
           remove_behavior(role, mod_name, player)
         end
@@ -223,7 +231,7 @@ module Surrounded
       end
 
       def role_behavior_name(role)
-        role.to_s.gsub(/(?:^|_)([a-z])/) { $1.upcase }.sub(/_\d+/,'')
+        RoleName.new(role)
       end
 
       def role_module_basename(mod)
@@ -238,6 +246,10 @@ module Surrounded
         self.class.send(:role_const_defined?, name)
       end
 
+      def role_mapper_class
+        self.class.send(:role_mapper_class)
+      end
+
       def singularize_name(name)
         if name.respond_to?(:singularize)
           name.singularize
@@ -253,5 +265,27 @@ module Surrounded
         end
       end
     end
+
+    class RoleName
+      def initialize(string, suffix=nil)
+        @string = string.
+                    to_s.
+                    split(/_/).
+                    map{|part|
+                      part.capitalize
+                    }.
+                    join.
+                    sub(/_\d+/,'') + suffix.to_s
+      end
+
+      def to_str
+        @string
+      end
+      alias to_s to_str
+
+      def to_sym
+        @string.to_sym
+      end
+    end
   end
 end

data/lib/surrounded/version.rb

@@ -1,5 +1,5 @@
 module Surrounded
-  VERSION = "0.9.1"
+  VERSION = "0.9.2"
   
   def self.version
     VERSION

data/lib/surrounded.rb

@@ -11,19 +11,15 @@ module Surrounded
 
   private
 
-  def store_context(ctxt, &block)
+  def store_context(&block)
     accessor = block.binding.eval('self')
-    if accessor.role_player?(self)
-      surroundings.unshift(ctxt)
-    end
+    surroundings.unshift(accessor)
     self
   end
 
   def remove_context(&block)
     accessor = block.binding.eval('self')
-    if accessor.role_player?(self)
-      surroundings.shift
-    end
+    surroundings.shift if surroundings.include?(accessor)
     self
   end
 

data/test/example_proxy_test.rb

@@ -36,8 +36,13 @@ class ProxyContext
   end
 end
 
-ProxyUser = Struct.new(:name)
-ProxyUser.send(:include, Surrounded)
+ProxyUser = Class.new do
+  include Surrounded
+  def initialize(name)
+    @name = name
+  end
+  attr_reader :name
+end
 
 describe ProxyContext do
   let(:user){
@@ -60,7 +65,7 @@ describe ProxyContext do
   it 'passes missing methods up the ancestry of the object' do
     err = ->{ context.admin_missing_method }.must_raise(NoMethodError)
 
-    assert_match 'ProxyUser name="Jim"', err.message
+    assert_match /ProxyUser.*name="Jim"/, err.message
   end
 
   it 'allows access to other objects in the context' do

data/test/role_context_method_test.rb

@@ -83,7 +83,7 @@ describe Surrounded::Context, '.role' do
     end
  
     it 'creates a private accessor method' do
-      assert_respond_to(context, :admin)
+      assert context.respond_to?(:admin, true)
     end
   end
  

data/test/surrounded_context_test.rb

@@ -258,3 +258,22 @@ describe Surrounded::Context, 'auto-assigning roles for collections' do
     assert_equal "member show, member show", context.get_member_show
   end
 end
+
+class Keyworder
+  extend Surrounded::Context
+
+  keyword_initialize :this, :that
+end
+
+describe Surrounded::Context, 'keyword initializers' do
+  it 'works with keyword arguments' do
+    assert context = Keyworder.new(this: User.new('Jim'), that: User.new('Guille'))
+  end
+
+  it 'raises errors with missing keywords' do
+    err = assert_raises(ArgumentError){
+      Keyworder.new(this: User.new('Amy'))
+    }
+    assert_match /missing keyword: that/, err.message
+  end
+end

data/test/surrounded_test.rb

@@ -40,7 +40,7 @@ describe "Surrounded", "added to an existing object" do
     thing.name = 'Jim'
 
     assert_raises(NoMethodError){
-      thing.send(:store_context)
+      thing.__send__(:store_context)
     }
     thing.extend(Surrounded)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: surrounded
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - "'Jim Gay'"
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-18 00:00:00.000000000 Z
+date: 2015-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: triad