surrounded 1.0.0 → 1.1.1

data/test/initialization_test.rb

@@ -1,34 +1,33 @@
-require 'test_helper'
+require "test_helper"
 
 class KeywordContext
   extend Surrounded::Context
 
   keyword_initialize(:user, :other_user) do
-    @defined_by_initializer_block = 'yup'
+    @defined_by_initializer_block = "yup"
   end
 end
 
-describe Surrounded::Context, '.initialize' do
-
-  it 'applies a provided block to the instance' do
-    context = KeywordContext.new(user: User.new('Jim'), other_user: User.new('Amy'))
-    assert_equal 'yup', context.instance_variable_get(:@defined_by_initializer_block)
+describe Surrounded::Context, ".initialize" do
+  it "applies a provided block to the instance" do
+    context = KeywordContext.new(user: User.new("Jim"), other_user: User.new("Amy"))
+    assert_equal "yup", context.instance_variable_get(:@defined_by_initializer_block)
   end
 
-  it 'keeps track of the original initialize arguments' do
-    jim = User.new('Jim')
-    amy = User.new('Amy')
+  it "keeps track of the original initialize arguments" do
+    jim = User.new("Jim")
+    amy = User.new("Amy")
     context = KeywordContext.new(user: jim, other_user: amy)
     tracked = context.send(:initializer_arguments)
     assert_equal jim, tracked[:user]
     assert_equal amy, tracked[:other_user]
   end
 
-  it 'raises errors with missing keywords' do
-    err = assert_raises(ArgumentError){
-      KeywordContext.new(other_user: User.new('Amy'))
+  it "raises errors with missing keywords" do
+    err = assert_raises(ArgumentError) {
+      KeywordContext.new(other_user: User.new("Amy"))
     }
-    assert_match(/missing keyword: user/, err.message)
+    assert_match(/missing keyword: :?user/, err.message)
   end
 end
 
@@ -36,7 +35,7 @@ class NonKeyworder
   extend Surrounded::Context
 
   initialize_without_keywords :this, :that do
-    self.instance_variable_set(:@defined_by_initializer_block, 'yes')
+    instance_variable_set(:@defined_by_initializer_block, "yes")
   end
 
   trigger :access_other_object do
@@ -44,23 +43,23 @@ class NonKeyworder
   end
 end
 
-describe Surrounded::Context, 'non-keyword initializers' do
-  it 'defines an initialize method accepting the same arguments' do
+describe Surrounded::Context, "non-keyword initializers" do
+  it "defines an initialize method accepting the same arguments" do
     assert_equal 2, NonKeyworder.instance_method(:initialize).arity
   end
 
-  it 'works without keyword arguments' do
-    assert NonKeyworder.new(User.new('Jim'), User.new('Guille'))
+  it "works without keyword arguments" do
+    assert NonKeyworder.new(User.new("Jim"), User.new("Guille"))
   end
 
-  it 'evaluates a given block' do
-    assert_equal 'yes', NonKeyworder.new(User.new('Jim'), User.new('Guille')).instance_variable_get(:@defined_by_initializer_block)
+  it "evaluates a given block" do
+    assert_equal "yes", NonKeyworder.new(User.new("Jim"), User.new("Guille")).instance_variable_get(:@defined_by_initializer_block)
   end
 
-  it 'allows rebinding with a hash' do
-    context = NonKeyworder.new(User.new('Jim'), User.new('Guille'))
-    expect(context.access_other_object).must_equal 'Guille'
-    context.rebind(this: User.new('Amy'), that: User.new('Elizabeth'))
-    expect(context.access_other_object).must_equal 'Elizabeth'
+  it "allows rebinding with a hash" do
+    context = NonKeyworder.new(User.new("Jim"), User.new("Guille"))
+    expect(context.access_other_object).must_equal "Guille"
+    context.rebind(this: User.new("Amy"), that: User.new("Elizabeth"))
+    expect(context.access_other_object).must_equal "Elizabeth"
   end
 end

data/test/name_collisions_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+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
@@ -13,19 +13,22 @@ require 'test_helper'
 class HasNameCollision
   include Surrounded
 
-  attr_accessor :will_collide # should always return nil
+  attr_reader :will_collide # should always return nil
 
   def assert_has_role
     true
   end
 
-  def will_collide=(_); end
+  def will_collide=(_)
+    @will_collide = nil
+  end
 end
 
 class ShouldCollide
   include Surrounded
+
   def collide
-    return 'Method called in ShouldCollide'
+    "Method called in ShouldCollide"
   end
 end
 
@@ -66,111 +69,114 @@ class ContextWithMultipleCollisions
 end
 
 class First
+  def second
+  end
 
-  def second;end
-  def third;end
+  def third
+  end
 end
 
 class Second
-  def first;end
+  def first
+  end
 
-  def third;end
+  def third
+  end
 end
 
 class Third
-  def first;end
-  def second;end
+  def first
+  end
 
+  def second
+  end
 end
 
-describe 'handling name collisions' do
-
-  let(:new_context_with_collision){
+describe "handling name collisions" do
+  let(:new_context_with_collision) {
     ContextOverridesName.new(base: HasNameCollision.new, will_collide: ShouldCollide.new)
   }
 
   after do
-    ContextOverridesName.instance_eval{
+    ContextOverridesName.instance_eval {
       remove_instance_variable :@handler if defined?(@handler)
     }
   end
 
   def set_handler(handler)
-    ContextOverridesName.instance_eval{
+    ContextOverridesName.instance_eval {
       on_name_collision handler
     }
   end
 
-  it 'is works properly without handling collisions' do
+  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){
+  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)
+    assert_match(/undefined method [`']collide['`] for nil/, err.message)
   end
 
-  it 'can raise an exception' do
+  it "can raise an exception" do
     set_handler :raise
-    assert_raises(ContextOverridesName::NameCollisionError){
+    assert_raises(ContextOverridesName::NameCollisionError) {
       new_context_with_collision
     }
   end
 
-  it 'can print a warning' do
+  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
 
-  it 'can ignore collisions' do
+  it "can ignore collisions" do
     set_handler :nothing
     assert_output(nil, nil) {
       new_context_with_collision
     }
   end
 
-  it 'raises an error with an unknown handler' do
+  it "raises an error with an unknown handler" do
     set_handler :barf
     err = assert_raises(ArgumentError) {
       new_context_with_collision
     }
-    expect(err.message).must_match(/your name collision handler was set to \`barf' but there is no instance nor class method of that name/)
+    expect(err.message).must_match(/your name collision handler was set to `barf' but there is no instance nor class method of that name/)
   end
 
-  let(:create_context_with_multiple_collisions){
+  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){
+  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 self.class_method_handler(message)
-        puts message
-      end
+  it "can use a class method" do
+    ContextOverridesName.define_singleton_method(:class_method_handler) do |message|
+      puts message
     end
     set_handler :class_method_handler
-    assert_output("base has name collisions with [:will_collide]\n"){
+    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"){
+  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

data/test/non_surrounded_role_player_test.rb

@@ -1,16 +1,16 @@
-require 'test_helper'
+require "test_helper"
 
 class BareObjectContext
   extend Surrounded::Context
 
   def initialize(number, string, user)
-    map_roles(:number => number, :string => string, :user => user)
+    map_roles(number: number, string: string, user: user)
   end
   private_attr_reader :number, :string, :user
 
   role :user do
     def output
-      [number.to_s, string, name].join(' - ')
+      [number.to_s, string, name].join(" - ")
     end
   end
 
@@ -19,9 +19,9 @@ class BareObjectContext
   end
 end
 
-describe Surrounded::Context, 'skips affecting non-surrounded objects' do
-  it 'works with non-surrounded objects' do
-    context = BareObjectContext.new(123,'hello', User.new('Jim'))
-    assert_equal '123 - hello - Jim', context.output
+describe Surrounded::Context, "skips affecting non-surrounded objects" do
+  it "works with non-surrounded objects" do
+    context = BareObjectContext.new(123, "hello", User.new("Jim"))
+    assert_equal "123 - hello - Jim", context.output
   end
-end
+end

data/test/override_methods_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class PrependedRoles
   extend Surrounded::Context
@@ -45,18 +45,18 @@ class PrependedRoles
   end
 end
 
-describe Surrounded::Context, 'custom role application' do
-  let(:user){ User.new('Jim') }
-  let(:other){ User.new('Amy') }
+describe Surrounded::Context, "custom role application" do
+  let(:user) { User.new("Jim") }
+  let(:other) { User.new("Amy") }
 
-  let(:context){ PrependedRoles.new(user: user, other: other) }
+  let(:context) { PrependedRoles.new(user: user, other: other) }
 
-  it 'allows you to override existing methods on a role player' do
+  it "allows you to override existing methods on a role player" do
     assert_equal "Not what you thought, Jim", context.get_name
     assert_equal "Jim", user.name
   end
 
-  it 'allows you to override the way a role is mapped' do
-    assert_equal 'OtherStuff Amy', context.other_title
+  it "allows you to override the way a role is mapped" do
+    assert_equal "OtherStuff Amy", context.other_title
   end
-end
+end

data/test/role_context_method_test.rb

@@ -1,99 +1,142 @@
-require 'test_helper'
+require "test_helper"
 
-describe Surrounded::Context, '.role' do
-  class RoleContextTester
-    extend Surrounded::Context
- 
-    role_methods :admin do
-    end
+class RoleContextTester
+  extend Surrounded::Context
+
+  role_methods :admin do
   end
- 
-  describe 'modules' do
-    it 'creates a module' do
+end
+
+describe Surrounded::Context, ".role" do
+  describe "modules" do
+    it "creates a module" do
       role = RoleContextTester.const_get(:Admin)
       refute_instance_of Class, role
       assert_kind_of Module, role
     end
- 
-    it 'marks the constant private' do
-      error = assert_raises(NameError){
+
+    it "marks the constant private" do
+      error = assert_raises(NameError) {
         RoleContextTester::Admin
       }
       assert_match(/private constant/i, error.message)
     end
   end
- 
-  class WrapperRoleContext
-    extend Surrounded::Context
- 
-    role :admin, :wrap do
- 
-    end
+end
+
+class WrapperRoleContext
+  extend Surrounded::Context
+
+  role :admin, :wrap do
   end
- 
-  describe 'wrappers' do
-    it 'creates a wrapper' do
-      role = WrapperRoleContext.const_get('Admin')
+end
+
+describe Surrounded::Context, ".role" do
+  describe "wrappers" do
+    it "creates a wrapper" do
+      role = WrapperRoleContext.const_get(:Admin)
       assert_includes(role.ancestors, SimpleDelegator)
     end
- 
-    it 'marks the constant private' do
-      error = assert_raises(NameError){
+
+    it "marks the constant private" do
+      error = assert_raises(NameError) {
         WrapperRoleContext::Admin
       }
       assert_match(/private constant/i, error.message)
     end
   end
-  class InterfaceContext
-    extend Surrounded::Context
- 
-    initialize(:admin, :other)
- 
-    role :admin, :interface do
-      def hello
-        'hello from admin'
-      end
+end
+
+class InterfaceContext
+  extend Surrounded::Context
+
+  initialize(:admin, :other)
+
+  role :admin, :interface do
+    def hello
+      "hello from admin"
     end
- 
-    trigger :admin_hello do
-      admin.hello
+
+    def splat_args(*args)
+      args
     end
-  end
- 
-  class Hello
-    include Surrounded
-    def hello
-      'hello'
+
+    def keyword_args(**kwargs)
+      kwargs
+    end
+
+    def mixed_args(*args, **kwargs)
+      [args, kwargs]
     end
   end
- 
-  describe 'interfaces' do
-    let(:context){
+
+  trigger :admin_hello do
+    admin.hello
+  end
+
+  trigger :splat_args do |*args|
+    admin.splat_args(*args)
+  end
+
+  trigger :keyword_args do |**kwargs|
+    admin.keyword_args(**kwargs)
+  end
+
+  trigger :mixed_args do |*args, **kwargs|
+    admin.mixed_args(*args, **kwargs)
+  end
+end
+
+class Hello
+  include Surrounded
+
+  def hello
+    "hello"
+  end
+end
+
+describe Surrounded::Context, ".role" do
+  describe "interfaces" do
+    let(:context) {
       InterfaceContext.new(admin: Hello.new, other: Hello.new)
     }
-    it 'sets interface objects to use interface methods before singleton methods' do
-      assert_equal 'hello from admin', context.admin_hello
+    it "sets interface objects to use interface methods before singleton methods" do
+      assert_equal "hello from admin", context.admin_hello
     end
- 
-    it 'marks the inteface constant private' do
-      error = assert_raises(NameError){
+
+    it "marks the inteface constant private" do
+      error = assert_raises(NameError) {
         InterfaceContext::AdminInterface
       }
       assert_match(/private constant/i, error.message)
     end
- 
-    it 'creates a private accessor method' do
+
+    it "creates a private accessor method" do
       assert context.respond_to?(:admin, true)
     end
+
+    it "works with multiple args" do
+      assert_equal context.splat_args("one", "two"), %w[one two]
+    end
+
+    it "works with multiple keyword args" do
+      assert_equal context.keyword_args(one: "one", two: "two"), {one: "one", two: "two"}
+    end
+
+    it "works with multiple mixed args" do
+      assert_equal context.mixed_args("one", :two, three: "three", four: "four"), [["one", :two], {three: "three", four: "four"}]
+    end
   end
- 
-  describe 'unknown' do
-    it 'raises an error' do
-      class UnknownRole
-        extend Surrounded::Context
-      end
+end
+
+class UnknownRole
+  extend Surrounded::Context
+end
 
-      err = _{
+describe Surrounded::Context, ".role" do
+  describe "unknown" do
+    it "raises an error" do
+      err = _ {
         UnknownRole.instance_eval do
           role :admin, :unknown do
           end
@@ -102,51 +145,54 @@ describe Surrounded::Context, '.role' do
       _(err.cause).must_be_kind_of NameError
     end
   end
- 
-  describe 'custom default' do
+end
+
+class CustomDefaultWrap
+  extend Surrounded::Context
+
+  self.default_role_type = :wrap
+
+  initialize(:admin, :the_test)
+
+  role :admin do
+  end
+
+  trigger :check_admin_type do
+    the_test.assert_kind_of SimpleDelegator, admin
+  end
+end
+
+describe Surrounded::Context, ".role" do
+  describe "custom default" do
     include Surrounded # the test is a role player here
- 
-    it 'allows the use of custom default role types' do
-      class CustomDefaultWrap
+
+    it "allows the use of custom default role types" do
+      context = CustomDefaultWrap.new(admin: Object.new, the_test: self)
+      context.check_admin_type
+    end
+
+    it "allows the setting of custom default role type for all Surrounded::Contexts" do
+      old_default = Surrounded::Context.default_role_type
+      Surrounded::Context.default_role_type = :wrap
+
+      # Define the class after setting the global default so it picks up the new default
+      custom_global_default_class = Class.new do
         extend Surrounded::Context
- 
-        self.default_role_type = :wrap
- 
+
         initialize(:admin, :the_test)
- 
+
         role :admin do
         end
- 
+
         trigger :check_admin_type do
           the_test.assert_kind_of SimpleDelegator, admin
         end
       end
-      context = CustomDefaultWrap.new(admin: Object.new, the_test: self)
+
+      context = custom_global_default_class.new(admin: Object.new, the_test: self)
       context.check_admin_type
-    end
- 
-    it 'allows the setting of custom default role type for all Surrounded::Contexts' do
-      begin
-        old_default = Surrounded::Context.default_role_type
-        Surrounded::Context.default_role_type = :wrap
-        class CustomGlobalDefault
-          extend Surrounded::Context
- 
-          initialize(:admin, :the_test)
- 
-          role :admin do
-          end
- 
-          trigger :check_admin_type do
-            the_test.assert_kind_of SimpleDelegator, admin
-          end
-        end
- 
-        context = CustomGlobalDefault.new(admin: Object.new, the_test: self)
-        context.check_admin_type
-      ensure
-        Surrounded::Context.default_role_type = old_default
-      end
+    ensure
+      Surrounded::Context.default_role_type = old_default
     end
   end
-end
+end