surrounded 0.8.3 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fcd5a235a5131c97780460591911ce275b460907
-  data.tar.gz: e5662f4dfbfdae0f22f3832b7d259c7bb6daa9e0
+  metadata.gz: ea4a7bea400ebf873e76985cffb1ddff7aa481ff
+  data.tar.gz: 5baeada83ee58583aa93f3e5764565e18983f2a5
 SHA512:
-  metadata.gz: 6ee26aa514d524c218dde785998a696b90686e3d3952a094613920ff987e2da1abf387c1d6e44b114e8f5093299979a9d7c26f721956ab036a4a67e55a32bcfb
-  data.tar.gz: f16d747a27f0af4fdfe0b4b9376a87d3d1a2a026b91d6c8019fc89ca9256805a9ad6bc911405677b19c89d1089a5310f3fed375046d6734b5249b724ad5698f5
+  metadata.gz: f2d4bc4c9435035b92a93fb78f51942e1b8223c0012c5e48d61cb1b0a11c674144604e32e22c9c7a7e94b00721625e47c38b79e9157fb0e82d6a43ef686f3f3b
+  data.tar.gz: a5273eca6dbfb05540166d248ffb9d4b8434721f7e6241fc4682d051f823356f547f0ef4a25ebfa6f8a35d975e25c09a9d28257639fbcafef81c235b83d3fbed

data/lib/surrounded/access_control.rb

@@ -16,7 +16,7 @@ module Surrounded
     end
     alias_method :guard, :disallow
     
-    def trigger_return_content(name)
+    def trigger_return_content(name, *args, &block)
       %{
 
         method_restrictor = "disallow_#{name}?"
@@ -29,7 +29,8 @@ module Surrounded
     end
     
     def define_access_method(name, &block)
-      class_eval {
+      mod = Module.new
+      mod.class_eval {
         define_method "disallow_#{name}?" do
           begin
             apply_roles if __apply_role_policy == :trigger
@@ -39,6 +40,8 @@ module Surrounded
           end
         end
       }
+      const_set("SurroundedAccess#{name}", mod)
+      include mod
     end
     
     module AccessMethods

data/lib/surrounded/context/initializing.rb

@@ -0,0 +1,33 @@
+module Surrounded
+  module Context
+    module Initializing
+      def new(*args, &block)
+        instance = allocate
+        instance.send(:preinitialize)
+        instance.send(:initialize, *args, &block)
+        instance.send(:postinitialize)
+        instance
+      end
+
+      # Shorthand for creating an instance level initialize method which
+      # handles the mapping of the given arguments to their named role.
+      def initialize(*setup_args)
+        private_attr_reader(*setup_args)
+      
+        mod = Module.new
+        line = __LINE__
+        mod.class_eval "
+          def initialize(#{setup_args.join(',')})
+            preinitialize
+            arguments = method(__method__).parameters.map{|arg| eval(arg[1].to_s) }
+            @role_map = RoleMap.new
+            map_roles(#{setup_args}.zip(arguments))
+            postinitialize
+          end
+        ", __FILE__, line
+        const_set("ContextInitializer", mod)
+        include mod
+      end
+    end
+  end
+end

data/lib/surrounded/context/role_builders.rb

@@ -0,0 +1,64 @@
+# Some features are only available in versions of Ruby
+# where this method is true
+unless defined?(module_method_rebinding?)
+  def module_method_rebinding?
+    return @__module_method_rebinding__ if defined?(@__module_method_rebinding__)
+    sample_method = Enumerable.instance_method(:to_a)
+    @__module_method_rebinding__ = begin
+      !!sample_method.bind(Object.new)
+    rescue TypeError
+      false
+    end
+  end
+end
+
+module Surrounded
+  module Context
+    module RoleBuilders
+
+      # Define behaviors for your role players
+      def role(name, type=nil, &block)
+        role_type = type || default_role_type
+        if role_type == :module
+          mod_name = name.to_s.gsub(/(?:^|_)([a-z])/){ $1.upcase }
+          mod = Module.new(&block)
+          mod.send(:include, ::Surrounded)
+          private_const_set(mod_name, mod)
+        else
+          meth = method(role_type)
+          meth.call(name, &block)
+        end
+      rescue NameError => e
+        raise e.extend(InvalidRoleType)
+      end
+      alias_method :role_methods, :role
+
+      # Create a named behavior for a role using the standard library SimpleDelegator.
+      def wrap(name, &block)
+        require 'delegate'
+        wrapper_name = name.to_s.gsub(/(?:^|_)([a-z])/){ $1.upcase }
+        klass = private_const_set(wrapper_name, Class.new(SimpleDelegator, &block))
+        klass.send(:include, Surrounded)
+      end
+      alias_method :wrapper, :wrap
+
+
+      if module_method_rebinding?
+        # Create an object which will bind methods to the role player
+        def interface(name, &block)
+          class_basename = name.to_s.gsub(/(?:^|_)([a-z])/){ $1.upcase }
+          interface_name = class_basename + 'Interface'
+
+          behavior = private_const_set(interface_name, Module.new(&block))
+
+          require 'surrounded/context/negotiator'
+          undef_method(name)
+          define_method(name) do
+            instance_variable_set("@#{name}", Negotiator.new(role_map.assigned_player(name), behavior))
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/surrounded/context.rb

@@ -1,23 +1,11 @@
 require 'set'
 require 'surrounded/context/role_map'
+require 'surrounded/context/role_builders'
+require 'surrounded/context/initializing'
 require 'surrounded/access_control'
 require 'surrounded/shortcuts'
 require 'surrounded/east_oriented'
 
-# Some features are only available in versions of Ruby
-# where this method is true
-unless defined?(module_method_rebinding?)
-  def module_method_rebinding?
-    return @__module_method_rebinding__ if defined?(@__module_method_rebinding__)
-    sample_method = Enumerable.instance_method(:to_a)
-    @__module_method_rebinding__ = begin
-      !!sample_method.bind(Object.new)
-    rescue TypeError
-      false
-    end
-  end
-end
-
 # Extend your classes with Surrounded::Context to handle their
 # initialization and application of behaviors to the role players
 # passed into the constructor.
@@ -27,20 +15,13 @@ end
 module Surrounded
   module Context
     def self.extended(base)
+      base.extend RoleBuilders, Initializing
       base.class_eval {
         @triggers = Set.new
         include InstanceMethods
       }
     end
 
-    def new(*args, &block)
-      instance = allocate
-      instance.send(:preinitialize)
-      instance.send(:initialize, *args, &block)
-      instance.send(:postinitialize)
-      instance
-    end
-
     # Provides a Set of all available trigger methods where
     # behaviors will be applied to the roles before execution
     # and removed afterward.
@@ -87,64 +68,6 @@ module Surrounded
       @__apply_role_policy ||= :trigger
     end
 
-    # Shorthand for creating an instance level initialize method which
-    # handles the mapping of the given arguments to their named role.
-    def initialize(*setup_args)
-      private_attr_reader(*setup_args)
-
-      class_eval "
-        def initialize(#{setup_args.join(',')})
-          preinitialize
-          arguments = method(__method__).parameters.map{|arg| eval(arg[1].to_s) }
-          @role_map = RoleMap.new
-          map_roles(#{setup_args}.zip(arguments))
-          postinitialize
-        end
-      ", __FILE__, __LINE__
-    end
-
-    # Create a named behavior for a role using the standard library SimpleDelegator.
-    def wrap(name, &block)
-      require 'delegate'
-      wrapper_name = name.to_s.gsub(/(?:^|_)([a-z])/){ $1.upcase }
-      klass = private_const_set(wrapper_name, Class.new(SimpleDelegator, &block))
-      klass.send(:include, Surrounded)
-    end
-    alias_method :wrapper, :wrap
-
-    if module_method_rebinding?
-      # Create an object which will bind methods to the role player
-      def interface(name, &block)
-        class_basename = name.to_s.gsub(/(?:^|_)([a-z])/){ $1.upcase }
-        interface_name = class_basename + 'Interface'
-
-        behavior = private_const_set(interface_name, Module.new(&block))
-
-        require 'surrounded/context/negotiator'
-        undef_method(name)
-        define_method(name) do
-          instance_variable_set("@#{name}", Negotiator.new(role_map.assigned_player(name), behavior))
-        end
-      end
-    end
-
-    # Define behaviors for your role players
-    def role(name, type=nil, &block)
-      role_type = type || default_role_type
-      if role_type == :module
-        mod_name = name.to_s.gsub(/(?:^|_)([a-z])/){ $1.upcase }
-        mod = Module.new(&block)
-        mod.send(:include, ::Surrounded)
-        private_const_set(mod_name, mod)
-      else
-        meth = method(role_type)
-        meth.call(name, &block)
-      end
-    rescue NameError => e
-      raise e.extend(InvalidRoleType)
-    end
-    alias_method :role_methods, :role
-
     # Creates a context instance method which will apply behaviors to role players
     # before execution and remove the behaviors after execution.
     #
@@ -188,8 +111,10 @@ module Surrounded
     end
 
     def define_trigger_wrap_method(name)
-      class_eval %{
-        def #{name}
+      mod = Module.new
+      line = __LINE__
+      mod.class_eval %{
+        def #{name}(*args, &block)
           begin
             apply_roles if __apply_role_policy == :trigger
 
@@ -199,11 +124,13 @@ module Surrounded
             remove_roles if __apply_role_policy == :trigger
           end
         end
-      }, __FILE__, __LINE__
+      }, __FILE__, line
+      const_set("SurroundedTrigger#{name.to_s.upcase.sub(/\?\z/,'Query')}", mod)
+      include mod
     end
     
-    def trigger_return_content(name)
-      %{self.send("__trigger_#{name}")}
+    def trigger_return_content(name, *args, &block)
+      %{self.send("__trigger_#{name}", *args, &block)}
     end
     
     # === Utility shortcuts
@@ -225,11 +152,15 @@ module Surrounded
 
     # Conditional const_get for a named role behavior
     def role_const(name)
-      if const_defined?(name)
+      if role_const_defined?(name)
         const_get(name)
       end
     end
 
+    def role_const_defined?(name)
+      const_defined?(name, false)
+    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
@@ -266,22 +197,28 @@ module Surrounded
 
       def map_roles(role_object_array)
         role_object_array.each do |role, object|
-          map_role(role, role_behavior_name(role), object)
-
-          singular_role_name = singularize_name(role)
-          singular_behavior_name = singularize_name(role_behavior_name(role))
+          if self.respond_to?("map_role_#{role}")
+            self.send("map_role_#{role}", object)
+          else
+            map_role(role, role_behavior_name(role), object)
+            map_role_collection(role, role_behavior_name(role), object)
+          end
+        end
+      end
 
-          if object.respond_to?(:each_with_index) && role_const_defined?(singular_behavior_name)
-            object.each_with_index do |item, index|
-              map_role(:"#{singular_role_name}_#{index + 1}", singular_behavior_name, item)
-            end
+      def map_role_collection(role, mod_name, collection)
+        singular_role_name = singularize_name(role)
+        singular_behavior_name = singularize_name(role_behavior_name(role))
+        if collection.respond_to?(:each_with_index) && role_const_defined?(singular_behavior_name)
+          collection.each_with_index do |item, index|
+            map_role(:"#{singular_role_name}_#{index + 1}", singular_behavior_name, item)
           end
         end
       end
 
       def map_role(role, mod_name, object)
         instance_variable_set("@#{role}", object)
-        role_map.update(role, mod_name, object)
+        role_map.update(role, role_module_basename(mod_name), object)
       end
 
       def __apply_role_policy
@@ -289,12 +226,13 @@ module Surrounded
       end
 
       def add_interface(role, behavior, object)
-        applicator = behavior.is_a?(Class) ? method(:add_class_interface) : method(:add_module_interface)
+        if behavior && role_const_defined?(behavior)
+          applicator = role_const(behavior).is_a?(Class) ? method(:add_class_interface) : method(:add_module_interface)
 
-        role_player = applicator.call(object, behavior)
-        map_role(role, role_module_basename(behavior), role_player) if behavior
-        role_player.send(:store_context, self){}
-        role_player
+          role_player = applicator.call(object, role_const(behavior))
+          map_role(role, behavior, role_player)
+        end
+        role_player || object
       end
 
       def add_module_interface(obj, mod)
@@ -308,34 +246,34 @@ module Surrounded
       def add_class_interface(obj, klass)
         wrapper_name = wrap_methods.find{|meth| klass.respond_to?(meth) }
         return obj if !wrapper_name
-
         klass.method(wrapper_name).call(obj)
       end
 
       def remove_interface(role, behavior, object)
-        remover_name = (module_removal_methods + unwrap_methods).find{|meth| object.respond_to?(meth) }
-        object.send(:remove_context) do; end
+        if behavior && role_const_defined?(behavior)
+          remover_name = (module_removal_methods + unwrap_methods).find{|meth| object.respond_to?(meth) }
+        end
 
         if remover_name
           role_player = object.send(remover_name)
         end
 
-        return role_player || object
+        role_player || object
       end
 
       def apply_roles
-        traverse_map method(:add_interface)
+        role_map.each do |role, mod_name, object|
+          player = add_interface(role, mod_name, object)
+          player.send(:store_context, self) do; end
+        end
       end
 
       def remove_roles
-        traverse_map method(:remove_interface)
-      end
-
-      def traverse_map(applicator)
-        role_map.each do |role, mod_name, object|
-          if role_const_defined?(mod_name)
-            applicator.call(role, role_const(mod_name), object)
+        role_map.each do |role, mod_name, player|
+          if player.respond_to?(:remove_context, true)
+            player.send(:remove_context) do; end
           end
+          remove_interface(role, mod_name, player)
         end
       end
 
@@ -372,7 +310,7 @@ module Surrounded
       end
 
       def role_const_defined?(name)
-        self.class.const_defined?(name)
+        self.class.send(:role_const_defined?, name)
       end
 
       def singularize_name(name)

data/lib/surrounded/east_oriented.rb

@@ -2,7 +2,7 @@ module Surrounded
   module EastOriented
     # Always return the context object to ensure that a context may
     # not be asked for information.
-    def trigger_return_content(name)
+    def trigger_return_content(name, *args, &block)
       %{
         #{super}
         

data/lib/surrounded/version.rb

@@ -1,3 +1,7 @@
 module Surrounded
-  VERSION = "0.8.3"
+  VERSION = "0.8.4"
+  
+  def self.version
+    VERSION
+  end
 end

data/test/example_proxy_test.rb

@@ -14,6 +14,8 @@ class ProxyContext
       "hello from #{name}, the admin interface!"
     end
   end
+  wrap :task do
+  end
 
   trigger :do_something do
     admin.some_admin_method
@@ -29,6 +31,7 @@ class ProxyContext
 end
 
 ProxyUser = Struct.new(:name)
+ProxyUser.send(:include, Surrounded)
 
 describe ProxyContext do
   let(:user){

data/test/example_wrapper_test.rb

@@ -4,7 +4,6 @@ require 'test_helper'
 class WrapperContext
   extend Surrounded::Context
 
-  apply_roles_on(:trigger)
   initialize(:admin, :task)
 
   wrap :admin do
@@ -12,6 +11,7 @@ class WrapperContext
       'hello from the admin wrapper!'
     end
   end
+  wrap :task do; end
 
   trigger :do_something do
     admin.some_admin_method

data/test/role_context_method_test.rb

@@ -62,6 +62,7 @@ describe Surrounded::Context, '.role' do
     end
 
     class Hello
+      include Surrounded
       def hello
         'hello'
       end

data/test/surrounded_context_test.rb

@@ -43,6 +43,20 @@ describe Surrounded::Context, '.trigger' do
     }
     assert_equal "Guille", context.access_other_object
   end
+
+  it 'preserves arguments and blocks' do
+    result = context.block_method('argument') do |*args, obj|
+      "Having an #{args.first} with #{obj}"
+    end
+  end
+
+  it 'allows usage of regular methods for triggers' do
+    assert context.regular_method_trigger
+  end
+
+  it 'ignores nil trigger names' do
+    assert context.class.send(:trigger)
+  end
 end
 
 describe Surrounded::Context, '#role?' do
@@ -110,11 +124,7 @@ class RoleAssignmentContext
     user.respond_to?(:a_method!)
   end
   
-  def regular_method_trigger
-    user.respond_to?(:a_method!)
-  end
-  
-  trigger :user_ancestors, :other_user_ancestors, :regular_method_trigger
+  trigger :user_ancestors, :other_user_ancestors
 
   module User
     def a_method!; end
@@ -124,14 +134,47 @@ class RoleAssignmentContext
   end
 end
 
+class Special; end
+class IgnoreExternalConstantsContext
+  extend Surrounded::Context
+
+  initialize :user, :special, :other
+
+  role :other do
+    def something_or_other; end
+  end
+
+  trigger :check_special do
+    special.class
+  end
+end
+
 describe Surrounded::Context, '.initialize' do
   it 'defines an initialize method accepting the same arguments' do
     assert_equal 2, RoleAssignmentContext.instance_method(:initialize).arity
   end
 end
 
+class ClassRoleAssignmentContext
+  extend Surrounded::Context
+
+  initialize(:thing, :the_test)
+
+  trigger :check_user_response do
+    the_test.assert_respond_to thing, :method_from_class
+  end
+
+  class Thing
+    include Surrounded
+    def initialize(obj); end
+    def method_from_class; end
+  end
+
+end
+
 describe Surrounded::Context, 'assigning roles' do
-  include Surrounded
+  include Surrounded # the test must be context-aware
+
   let(:user){ User.new("Jim") }
   let(:other_user){ CastingUser.new("Guille") }
   let(:context){ RoleAssignmentContext.new(user, other_user) }
@@ -150,23 +193,6 @@ describe Surrounded::Context, 'assigning roles' do
   end
 
   it 'will use classes as roles' do
-    ClassRoleAssignmentContext = Class.new do
-      extend Surrounded::Context
-
-      initialize(:thing, :the_test)
-
-      trigger :check_user_response do
-        the_test.assert_respond_to thing, :method_from_class
-      end
-
-      class Thing
-        include Surrounded
-        def initialize(obj); end
-        def method_from_class; end
-      end
-
-    end
-
     user = User.new('Jim')
 
     context = ClassRoleAssignmentContext.new(user, self)
@@ -174,12 +200,11 @@ describe Surrounded::Context, 'assigning roles' do
     assert context.check_user_response
   end
 
-  it 'allows usage of regular methods for triggers' do
-    assert context.regular_method_trigger
-  end
-
-  it 'ignores nil trigger names' do
-    assert context.class.send(:trigger)
+  it 'does not use constants defined outside the context class' do
+    special = User.new('Special')
+    other = User.new('Other')
+    context = IgnoreExternalConstantsContext.new(user, special, other)
+    assert_equal User, context.check_special
   end
 end
 
@@ -208,6 +233,9 @@ class CollectionContext
     end
   end
 
+  role :others do; end
+  role :other do; end
+
 end
 
 describe Surrounded::Context, 'auto-assigning roles for collections' do

data/test/test_helper.rb

@@ -25,6 +25,16 @@ class TestContext
   trigger :access_other_object do
     user.other_user.name
   end
+
+  def block_method(*args, &block)
+    block.call(*args, self)
+  end
+  trigger :block_method
+
+  def regular_method_trigger
+    true
+  end
+  trigger :regular_method_trigger
 end
 
 # This is a different implementation of module_method_rebinding?

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: surrounded
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.8.4
 platform: ruby
 authors:
-- '''Jim Gay'''
+- "'Jim Gay'"
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-10 00:00:00.000000000 Z
+date: 2014-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: triad
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Gives an object implicit access to other objects in it's environment.
@@ -59,9 +59,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .simplecov
-- .travis.yml
+- ".gitignore"
+- ".simplecov"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -70,7 +70,9 @@ files:
 - lib/surrounded.rb
 - lib/surrounded/access_control.rb
 - lib/surrounded/context.rb
+- lib/surrounded/context/initializing.rb
 - lib/surrounded/context/negotiator.rb
+- lib/surrounded/context/role_builders.rb
 - lib/surrounded/context/role_map.rb
 - lib/surrounded/context_errors.rb
 - lib/surrounded/east_oriented.rb
@@ -97,17 +99,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Create encapsulated environments for your objects.