surrounded 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 152c9c728084be8069384cf825cedf5ab827d4fd28b0710cbdd19229d8284bc7
-  data.tar.gz: 82a50b285aa5328084481c438d78f8ed3e17ba362bcad45c14efaf5ad1bf0fc3
+  metadata.gz: e6cd923340dae45ac571dd98abf41be26d111f4569c59d98c27cd4e71f6204d1
+  data.tar.gz: a5d11c76eccb01b30fdec8aaced90571449d96c21fe4eced13e55dc1603241da
 SHA512:
-  metadata.gz: 9f7cf841bf2c4ceeb27fd6bd2f11c4041cad7c28e1ce71574b5bbc1c201b0944a2481966b1c2349b3cbfd465a98f7627f1621fae0e0e8d2c2c9fcde42859577f
-  data.tar.gz: aa91c16fefb0cdc19f1b597d2fffd876c2f0bce15bcbcaacb3a713570acac350d8ff434a8c3d6177d4c9e1a79c620611f012d1aff2bcd24fef10ddf696bcd13b
+  metadata.gz: 90659aa84b6565797f5b45fb4b637d0dfa21190dfed5366c20b586c4351ca1d0f02fdc5f8d6c45620ac6c9b36dccac28a842ce74b93a2d0a9258297db3d9e0e4
+  data.tar.gz: 4831ec1fe6a7dda8a9578776ecb0b2e2030ff37490d15f7e7f35351253bfe7f2c52c9ae1aa8fb7172cb471236b3d5c639f7eae8ef8c5510668a56542ba0fe014

data/Changelog.md

@@ -1,28 +1,19 @@
-# Change Log
+# Changelog
 
 All notable changes to this project will be documented in this file.
 
-## [1.1.0]
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
 
-- Dropped support for Ruby below 2.7 to take advantage of the ellipsis for argument forwarding
-- Memoize the Negotiator methods for interface
+## [1.1.1] - 2025-10-17
 
-## [1.0.1]
+### Changed
 
-- Fix a bug where shortcut_triggers would not work with keyword initialize
+- Version and changelog management with Reissue. (c919a3a)
+- Set the gemspec to use a file list rather than depending on git (69b9a43)
+- Update singularize_name to duplicate a string before altering the value. (3487d0d)
+- Alter the list of identity methods in Negotiator to include __id__. (b98fb5a)
 
-## [1.0.0]
+### Removed
 
-- Drop deprecations around Context initialize method. It now requires keyword arguments. Non-keyword argumennts may be used with initialize_without_keywords
-- Remove code supporting exception cause it InvalidRoleType prior to ruby 2.1
-
-## [0.9.11]
-
-- Rely on the standard library Forwardable to setup how the RoleMap forwards messages to the container.
-- Update RoleMap role_player? method to rescue from StandardError, a non-implementation-specific exception.
-- Move to using triad 0.3.0 which relies on concurrent-ruby 0.9+ and moves off of thread_safe 0.3.5
-
-## [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.
+- Code Climate and Pull Review configuration. (46f0057)

data/LICENSE.txt

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

data/README.md

@@ -1,8 +1,8 @@
 # ![Surrounded](http://saturnflyer.github.io/surrounded/images/surrounded.png "Surrounded")
+
 ## Be in control of business logic.
 
 [![Build Status](https://github.com/saturnflyer/surrounded/actions/workflows/test.yml/badge.svg)](https://github.com/saturnflyer/surrounded/actions)
-[![Code Climate](https://codeclimate.com/github/saturnflyer/surrounded.png)](https://codeclimate.com/github/saturnflyer/surrounded)
 
 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.
 
@@ -920,7 +920,7 @@ end
 
 If you'd like to use a special approach for just a single role, you may do that too.
 
-When applying behaviors from a role to your role players, your Surrounded context will first look for a method named  `"apply_behavior_#{role}"`. Define your own method and set it to accept 2 arguments: the role constant and the role player.
+When applying behaviors from a role to your role players, your Surrounded context will first look for a method named `"apply_behavior_#{role}"`. Define your own method and set it to accept 2 arguments: the role constant and the role player.
 
 ```ruby
 class MyCustomContext
@@ -982,7 +982,6 @@ Lets say that you wish to create a context as below, intending to use instances
       postcode.send
     end
 
-    end
     role :postcode do
       def send
         # do things...
@@ -991,6 +990,7 @@ Lets say that you wish to create a context as below, intending to use instances
     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:

data/Rakefile

@@ -1,17 +1,24 @@
 require "bundler/gem_tasks"
 
-require 'rake/testtask'
+require "rake/testtask"
 
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = FileList['test/*_test.rb']
-  t.ruby_opts = ["-w"]
+  t.test_files = FileList["test/*_test.rb"]
   t.verbose = true
+  t.warning = true
 end
-task :default => :test
 
+task default: :test
+
+require "reissue/gem"
+
+Reissue::Task.create :reissue do |task|
+  task.version_file = "lib/surrounded/version.rb"
+  task.fragment = :git
+end
 
 # task :mutant, [:class] do |task, args|
 #   klass = args[:class] || 'Surrounded'
 #   sh "bundle exec mutant --include lib --require surrounded --use minitest #{klass}"
-# end
+# end

data/lib/surrounded/access_control.rb

@@ -2,33 +2,34 @@ module Surrounded
   module Context
     class AccessError < ::StandardError; end
   end
+
   module AccessControl
     def self.extended(base)
       base.send(:include, AccessMethods)
       Surrounded::Exceptions.define(base, exceptions: :AccessError)
     end
-    
+
     private
-    
+
     def disallow(*names, &block)
       names.map do |name|
         define_access_method(name, &block)
       end
     end
-    alias guard disallow
-    
+    alias_method :guard, :disallow
+
     def trigger_return_content(name, *args, &block)
       %{
 
         method_restrictor = "disallow_#{name}?"
         if self.respond_to?(method_restrictor, true) && self.send(method_restrictor)
-          raise ::#{self.to_s}::AccessError.new("access to #{self.name}##{name} is not allowed")
+          raise ::#{self}::AccessError.new("access to #{self.name}##{name} is not allowed")
         end
 
       #{super}
       }
     end
-    
+
     def define_access_method(name, &block)
       mod = Module.new
       mod.class_eval {
@@ -42,26 +43,26 @@ module Surrounded
       const_set("SurroundedAccess#{name}", mod)
       include mod
     end
-    
+
     module AccessMethods
       # Return a Set of all defined triggers regardless of any disallow blocks
       def all_triggers
         self.class.triggers
       end
-    
+
       # Return a Set of triggers which may be run according to any restrictions defined
       # in disallow blocks.
       def triggers
-        all_triggers.select {|name|
+        all_triggers.select { |name|
           allow?(name)
         }.to_set
       end
 
       # Ask if the context will allow access to a trigger given the current players.
       def allow?(name)
-        raise NoMethodError, %{undefined method `#{name}' for #{self.inspect}} unless self.respond_to?(name)
+        raise NoMethodError, %(undefined method `#{name}' for #{inspect}) unless respond_to?(name)
         predicate = "disallow_#{name}?"
-        !self.respond_to?(predicate) || !self.public_send(predicate)
+        !respond_to?(predicate) || !public_send(predicate)
       end
     end
   end

data/lib/surrounded/context/forwarding.rb

@@ -1,27 +1,27 @@
 module Surrounded
   module Context
     module Forwarding
-      def forward_trigger(receiver, message, alternate=message)
-        raise(ArgumentError, %{you may not forward '%{m}`} % {m: message}) if ['__id__','__send__'].include?(message.to_s)
-        trigger alternate do |*args, &block|
-          self.send(receiver).public_send(message,*args, &block)
+      def forward_trigger(receiver, message, alternate = message)
+        raise(ArgumentError, %(you may not forward '%{m}`) % {m: message}) if ["__id__", "__send__"].include?(message.to_s)
+        trigger alternate do |*args, **kwargs, &block|
+          send(receiver).public_send(message, *args, **kwargs, &block)
         end
       end
-      
+
       def forward_triggers(receiver, *messages)
         messages.each do |message|
           forward_trigger(receiver, message)
         end
       end
-      
+
       def forwarding(hash)
         hash.each { |messages, receiver|
           forward_triggers(receiver, *messages)
         }
       end
-      
-      alias forward forward_trigger
-      alias forwards forward_triggers
+
+      alias_method :forward, :forward_trigger
+      alias_method :forwards, :forward_triggers
     end
   end
-end
+end

data/lib/surrounded/context/initializing.rb

@@ -2,19 +2,20 @@ module Surrounded
   module Context
     module Initializing
       extend Seclusion
+
       # Shorthand for creating an instance level initialize method which
       # handles the mapping of the given arguments to their named role.
       def initialize_without_keywords(*setup_args, &block)
-        parameters = setup_args.join(',')
+        parameters = setup_args.join(",")
         default_initializer(parameters, setup_args, &block)
       end
 
       def initialize(*setup_args, &block)
-        parameters = setup_args.map{|a| "#{a}:"}.join(',')
+        parameters = setup_args.map { |a| "#{a}:" }.join(",")
         default_initializer(parameters, setup_args, &block)
       end
-      alias keyword_initialize initialize
-      alias initialize_with_keywords keyword_initialize
+      alias_method :keyword_initialize, :initialize
+      alias_method :initialize_with_keywords, :keyword_initialize
 
       def initializer_block
         @initializer_block
@@ -31,13 +32,14 @@ module Surrounded
         line = __LINE__; mod.class_eval %{
           def initialize(#{params})
             @role_map = role_mapper_class.new
-            @initializer_arguments = Hash[#{setup_args.to_s}.zip([#{setup_args.join(',')}])]
+            @initializer_arguments = Hash[#{setup_args}.zip([#{setup_args.join(",")}])]
             map_roles(@initializer_arguments)
             self.class.apply_initializer_block(self)
           end
         }, __FILE__, line
-        const_set("ContextInitializer", mod)
+        const_set(:ContextInitializer, mod)
         include mod
+
         private_attr_reader :initializer_arguments
       end
     end

data/lib/surrounded/context/name_collision_detector.rb

@@ -1,56 +1,56 @@
 module Surrounded
   module Context
-    class NameCollisionError <::StandardError; end
-    module NameCollisionDetector
+    class NameCollisionError < ::StandardError; end
 
+    module NameCollisionDetector
       attr_reader :handler
 
       def self.extended(base)
         base.send :include, NameCollisionHandler
         Surrounded::Exceptions.define(base, exceptions: :NameCollisionError)
       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|
+          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)
+          }.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 nothing(*)
+        end
 
         def handler
           self.class.handler
         end
-    
+
         def handler_method
           if handler.respond_to?(:call)
             handler
@@ -59,10 +59,10 @@ module Surrounded
           elsif self.class.respond_to?(handler, true)
             self.class.method(handler)
           else
-            raise ArgumentError, %{your name collision handler was set to `#{handler}' but there is no instance nor class method of that name}
+            raise ArgumentError, %(your name collision handler was set to `#{handler}' but there is no instance nor class method of that name)
           end
         end
       end
     end
   end
-end
+end

data/lib/surrounded/context/negotiator.rb

@@ -14,25 +14,24 @@ module Surrounded
           # For each method in the module, directly forward to the wrapped object to
           # circumvent method_missing
           mod.instance_methods(false).each do |meth|
-            num = __LINE__; klass.class_eval %{
+            klass.class_eval <<~MOD, __FILE__, __LINE__ + 1
               def #{meth}(...)
                 @#{meth}_method ||= __behaviors__.instance_method(:#{meth}).bind(@object)
                 @#{meth}_method.call(...)
               end
-            }, __FILE__, num
+            MOD
           end
           klass
         end
       end
 
-
-      identity = %w[__send__ object_id equal?]
+      identity = %w[__send__ __id__ object_id equal?]
       method_access = %w[respond_to? method __behaviors__]
 
-      reserved_methods = (identity + method_access).join('|')
+      reserved_methods = (identity + method_access).join("|")
 
       # Remove all methods except the reserved methods
-      instance_methods.reject{ |m|
+      instance_methods.reject { |m|
         m.to_s =~ /#{reserved_methods}/
       }.each do |meth|
         undef_method meth
@@ -52,7 +51,7 @@ module Surrounded
         self
       end
       # These only differ in the message they send
-      alias remove_context store_context
+      alias_method :remove_context, :store_context
 
       def initialize(object)
         @object = object
@@ -62,7 +61,7 @@ module Surrounded
         @object.send(meth, ...)
       end
 
-      def respond_to_missing?(meth, include_private=false)
+      def respond_to_missing?(meth, include_private = false)
         @object.respond_to?(meth, include_private)
       end
     end

data/lib/surrounded/context/role_builders.rb

@@ -10,7 +10,7 @@ module Surrounded
       end
 
       # Define behaviors for your role players
-      def role(name, type=default_role_type, &block)
+      def role(name, type = default_role_type, &block)
         if type == :module
           mod_name = RoleName(name)
           mod = Module.new(&block).send(:include, ::Surrounded)
@@ -26,7 +26,7 @@ module Surrounded
 
       # Create a named behavior for a role using the standard library SimpleDelegator.
       def wrap(name, &block)
-        require 'delegate'
+        require "delegate"
         wrapper_name = RoleName(name)
         klass = private_const_set(wrapper_name, Class.new(SimpleDelegator, &block))
         klass.send(:include, Surrounded)
@@ -36,7 +36,7 @@ module Surrounded
       # Create a named behavior for a role using the standard library DelegateClass.
       # This ties the implementation of the role to a specific class or module API.
       def delegate_class(name, class_name, &block)
-        require 'delegate'
+        require "delegate"
         wrapper_name = RoleName(name)
         klass = private_const_set(wrapper_name, DelegateClass(Object.const_get(class_name.to_s)))
         klass.class_eval(&block)
@@ -53,19 +53,19 @@ module Surrounded
       # access them from any of its methods.
       def interface(name, &block)
         # AdminInterface
-        interface_name = RoleName(name, 'Interface')
+        interface_name = RoleName(name, "Interface")
         behavior = private_const_set(interface_name, Module.new(&block))
 
-        require 'surrounded/context/negotiator'
+        require "surrounded/context/negotiator"
         # Admin
         private_const_set(RoleName(name), Negotiator.for_role(behavior))
       end
 
       private
-      def RoleName(text, suffix=nil)
+
+      def RoleName(text, suffix = nil)
         RoleName.new(text, suffix)
       end
-
     end
   end
 end

data/lib/surrounded/context/role_map.rb

@@ -1,5 +1,5 @@
-require 'triad'
-require 'forwardable'
+require "triad"
+require "forwardable"
 module Surrounded
   module Context
     class RoleMap
@@ -8,19 +8,17 @@ module Surrounded
       class << self
         # Get the role map container and provide an alternative if desired
         # Ex: RoleMap.from_base(SomeCustomContainer)
-        def from_base(klass=::Triad)
+        def from_base(klass = ::Triad)
           unless const_defined?(:Container)
             role_mapper = Class.new(self)
-            role_mapper.container_class=(klass)
+            role_mapper.container_class = (klass)
             Surrounded::Exceptions.define(role_mapper, exceptions: :ItemNotPresent, namespace: klass)
             const_set(:Container, role_mapper)
           end
           const_get(:Container)
         end
 
-        def container_class=(klass)
-          @container_class = klass
-        end
+        attr_writer :container_class
       end
 
       def_delegators :container, :update, :each, :values, :keys
@@ -37,7 +35,7 @@ module Surrounded
       # Check if an object is playing a role in this map
       def role_player?(object)
         !values(object).empty?
-      rescue self.container.class::ItemNotPresent
+      rescue container.class::ItemNotPresent
         false
       end
 

data/lib/surrounded/context/trigger_controls.rb

@@ -1,24 +1,23 @@
 module Surrounded
   module Context
     module TriggerControls
-
       # Provides a Set of all available trigger methods where
       # behaviors will be applied to the roles before execution
       # and removed afterward.
       def triggers
         @triggers.dup
       end
-          
+
       def store_trigger(*names)
         @triggers.merge(names)
       end
-      
+
       # Creates a context instance method which will apply behaviors to role players
       # before execution and remove the behaviors after execution.
       #
       # Alternatively you may define your own methods then declare them as triggers
       # afterward.
-      # 
+      #
       # Example:
       #   trigger :some_event do
       #     # code here
@@ -41,7 +40,7 @@ module Surrounded
           store_trigger(name)
         end
       end
-      
+
       def convert_method_to_trigger(name)
         unless triggers.include?(name) || name.nil?
           alias_method :"__trigger_#{name}", :"#{name}"
@@ -53,7 +52,7 @@ module Surrounded
       end
 
       def define_trigger(name)
-        line = __LINE__; self.class_eval %{
+        class_eval <<~MOD, __FILE__, __LINE__ + 1
           def #{name}(...)
             begin
               apply_behaviors
@@ -64,24 +63,23 @@ module Surrounded
               remove_behaviors
             end
           end
-        }, __FILE__, line
+        MOD
       end
-    
+
       def trigger_return_content(name)
         if method_defined?(name)
-          %{super}
+          %(super)
         else
           %{self.send("__trigger_#{name}", ...)}
         end
       end
-      
-      
+
       def define_trigger_action(*name_and_args, &block)
         trigger_action_module.send(:define_method, *name_and_args, &block)
       end
-      
+
       def trigger_action_module
-        self.const_get('TriggerMethods', false)
+        const_get(:TriggerMethods, false)
       end
     end
   end