surrounded 1.0.0 → 1.1.1

data/test/context_access_test.rb

@@ -1,62 +1,63 @@
-require 'test_helper'
-require 'minitest/mock'
+require "test_helper"
+require "minitest/mock"
 
 class FilteredContext
   extend Surrounded::Context
+
   protect_triggers
-  
+
   initialize :user, :other_user
-  
+
   trigger :if_ready do
-    'ready'
+    "ready"
   end
-  
+
   guard :if_ready do
-    user.name != 'Amy'
+    user.name != "Amy"
   end
-  
+
   trigger :check_disallow_behavior do
     # used for disallow check
   end
-  
+
   disallow :check_disallow_behavior do
     user.special
   end
-  
+
   trigger :unguarded do
     # used for disallow check
   end
 
   role :user do
     def special
-      'special user method'
+      "special user method"
     end
   end
 end
 
-describe Surrounded::Context, 'access control' do
-  let(:user){ User.new("Jim") }
-  let(:other_user){ User.new("Guille") }
-  let(:context){ FilteredContext.new(user: user, other_user: other_user) }
-  
-  it 'includes triggers when allowed' do
+describe Surrounded::Context, "access control" do
+  let(:user) { User.new("Jim") }
+  let(:other_user) { User.new("Guille") }
+  let(:context) { FilteredContext.new(user: user, other_user: other_user) }
+
+  it "includes triggers when allowed" do
     context.stub(:disallow_if_ready?, false) do
       assert context.triggers.include?(:if_ready)
     end
   end
 
-  it 'excludes triggers when not allowed' do
+  it "excludes triggers when not allowed" do
     refute context.triggers.include?(:if_ready)
   end
-  
-  it 'raises error specific to the context class when trigger method not allowed' do
-    error = assert_raises(::FilteredContext::AccessError){
+
+  it "raises error specific to the context class when trigger method not allowed" do
+    error = assert_raises(::FilteredContext::AccessError) {
       context.if_ready
     }
     assert_match(/access to FilteredContext#if_ready is not allowed/i, error.message)
   end
-  
-  it 'supports rescuing from Surrounded defined error when trigger method not allowed' do
+
+  it "supports rescuing from Surrounded defined error when trigger method not allowed" do
     begin
       context.if_ready
     rescue ::Surrounded::Context::AccessError => error
@@ -64,20 +65,20 @@ describe Surrounded::Context, 'access control' do
     end
     assert_match(/access to FilteredContext#if_ready is not allowed/i, error.message)
   end
-  
-  it 'applies roles in disallow blocks' do
-    assert_equal 'special user method', context.disallow_check_disallow_behavior?
+
+  it "applies roles in disallow blocks" do
+    assert_equal "special user method", context.disallow_check_disallow_behavior?
   end
 
-  it 'lets you ask if the object will allow a method' do
+  it "lets you ask if the object will allow a method" do
     assert context.allow?(:unguarded)
     refute context.allow?(:check_disallow_behavior)
   end
 
-  it 'complains if you ask about an undefined method' do
-    error = assert_raises(NoMethodError){
+  it "complains if you ask about an undefined method" do
+    error = assert_raises(NoMethodError) {
       context.allow?(:not_a_defined_method)
     }
     assert_match(/undefined method `not_a_defined_method' for #<#{context.class}/, error.message)
   end
-end
+end

data/test/context_forwarding_test.rb

@@ -1,32 +1,32 @@
-require 'test_helper'
+require "test_helper"
 
 class Sending
   extend Surrounded::Context
-  
+
   initialize :one, :two
-  
+
   forwarding [:hello, :goodbye] => :one
   forward_trigger :two, :ping
   forward_trigger :two, :argumentative
   forwards :two, :blockhead
-  
+
   role :one do
     def hello
-      'hello'
+      "hello"
     end
-    
+
     def goodbye
-      'goodbye'
+      "goodbye"
     end
   end
-  
+
   role :two do
     def ping
       one.hello
     end
 
     def argumentative(yes, no)
-      [yes, no].join(' and ')
+      [yes, no].join(" and ")
     end
 
     def blockhead
@@ -35,31 +35,31 @@ class Sending
   end
 end
 
-describe Surrounded::Context, 'forwarding triggers' do
-  let(:user){ User.new("Jim") }
-  let(:other_user){ User.new("Guille") }
-  let(:context){ Sending.new(one: user, two: other_user) }
-  
-  it 'forwards multiple configured instance methods as triggers' do
-    assert_equal 'hello', context.hello
-    assert_equal 'goodbye', context.goodbye
+describe Surrounded::Context, "forwarding triggers" do
+  let(:user) { User.new("Jim") }
+  let(:other_user) { User.new("Guille") }
+  let(:context) { Sending.new(one: user, two: other_user) }
+
+  it "forwards multiple configured instance methods as triggers" do
+    assert_equal "hello", context.hello
+    assert_equal "goodbye", context.goodbye
   end
-  
-  it 'forwards individual configured instance methods as triggers' do
-    assert_equal 'hello', context.ping
+
+  it "forwards individual configured instance methods as triggers" do
+    assert_equal "hello", context.ping
   end
-  
-  it 'does not forward __id__' do
-    error = assert_raises(ArgumentError){
+
+  it "does not forward __id__" do
+    error = assert_raises(ArgumentError) {
       Sending.class_eval do
         forward_trigger :one, :__id__
       end
     }
     assert_match(/you may not forward '__id__`/i, error.message)
   end
-  
-  it 'does not forward __send__' do
-    error = assert_raises(ArgumentError){
+
+  it "does not forward __send__" do
+    error = assert_raises(ArgumentError) {
       Sending.class_eval do
         forward_trigger :one, :__send__
       end
@@ -67,14 +67,14 @@ describe Surrounded::Context, 'forwarding triggers' do
     assert_match(/you may not forward '__send__/i, error.message)
   end
 
-  it 'passes arguments' do
-    assert_equal 'YES and NO', context.argumentative('YES','NO')
+  it "passes arguments" do
+    assert_equal "YES and NO", context.argumentative("YES", "NO")
   end
 
-  it 'passes blocks' do
+  it "passes blocks" do
     result = context.blockhead do
       "Put them in the iron maiden. Excellent!"
     end
     assert_equal "Put them in the iron maiden. Excellent!", result
   end
-end
+end

data/test/context_reuse_test.rb

@@ -1,22 +1,22 @@
-require 'test_helper'
+require "test_helper"
 
-describe Surrounded::Context, 'reusing context object' do
-  let(:user){ User.new("Jim") }
-  let(:other_user){ User.new("Guille") }
-  let(:context){ TestContext.new(user: user, other_user: other_user) }
+describe Surrounded::Context, "reusing context object" do
+  let(:user) { User.new("Jim") }
+  let(:other_user) { User.new("Guille") }
+  let(:context) { TestContext.new(user: user, other_user: other_user) }
 
-  it 'allows rebinding new players' do
-    expect(context.access_other_object).must_equal 'Guille'
-    context.rebind(user: User.new('Amy'), other_user: User.new('Elizabeth'))
-    expect(context.access_other_object).must_equal 'Elizabeth'
+  it "allows rebinding new players" do
+    expect(context.access_other_object).must_equal "Guille"
+    context.rebind(user: User.new("Amy"), other_user: User.new("Elizabeth"))
+    expect(context.access_other_object).must_equal "Elizabeth"
   end
 
-  it 'clears internal storage when rebinding' do
-    originals = context.instance_variables.map{|var| context.instance_variable_get(var) }
-    context.rebind(user: User.new('Amy'), other_user: User.new('Elizabeth'))
-    new_ivars = context.instance_variables.map{|var| context.instance_variable_get(var) }
+  it "clears internal storage when rebinding" do
+    originals = context.instance_variables.map { |var| context.instance_variable_get(var) }
+    context.rebind(user: User.new("Amy"), other_user: User.new("Elizabeth"))
+    new_ivars = context.instance_variables.map { |var| context.instance_variable_get(var) }
     originals.zip(new_ivars).each do |original_ivar, new_ivar|
       expect(original_ivar).wont_equal new_ivar
     end
   end
-end
+end

data/test/context_shortcuts_test.rb

@@ -1,26 +1,53 @@
-require 'test_helper'
+require "test_helper"
 
 class ShortcutContext
   extend Surrounded::Context
+
   shortcut_triggers
-  
+
   initialize :user, :other
-  
+
   trigger :shorty do
     user.speak
   end
-  
+
   role :user do
     def speak
-      'it works, shorty!'
+      "it works, shorty!"
     end
   end
 end
 
-describe Surrounded::Context, 'shortcuts' do
-  let(:user){ User.new("Jim") }
-  let(:other){ User.new("Guille") }
-  it 'creates shortcut class methods for triggers' do
-    assert_equal 'it works, shorty!', ShortcutContext.shorty(user: user, other: other)
+class ShortcutContextNoKeywords
+  extend Surrounded::Context
+
+  shortcut_triggers
+
+  initialize_without_keywords :user, :other
+
+  trigger :shorty do
+    user.speak
   end
-end
+
+  role :user do
+    def speak
+      "it works, shorty!"
+    end
+  end
+end
+
+describe Surrounded::Context, "shortcuts" do
+  let(:user) { User.new("Jim") }
+  let(:other) { User.new("Guille") }
+  it "creates shortcut class methods for triggers" do
+    assert_equal "it works, shorty!", ShortcutContext.shorty(user: user, other: other)
+  end
+end
+
+describe Surrounded::Context, "shortcuts with initialize_without_keywords" do
+  let(:user) { User.new("Jim") }
+  let(:other) { User.new("Guille") }
+  it "creates shortcut class methods for triggers" do
+    assert_equal "it works, shorty!", ShortcutContextNoKeywords.shorty(user, other)
+  end
+end

data/test/east_oriented_triggers_test.rb

@@ -1,36 +1,37 @@
-require 'test_helper'
+require "test_helper"
 
 class EastTestContext
   extend Surrounded::Context
+
   east_oriented_triggers
-  
+
   initialize :user, :other_user
-  
+
   trigger :ask? do
     "asking a question..."
   end
 end
 
-describe Surrounded::Context, '.east_oriented_triggers' do
-  let(:user){ User.new("Jim") }
-  let(:other_user){ User.new("Guille") }
-  let(:context){ EastTestContext.new(user: user, other_user: other_user) }
+describe Surrounded::Context, ".east_oriented_triggers" do
+  let(:user) { User.new("Jim") }
+  let(:other_user) { User.new("Guille") }
+  let(:context) { EastTestContext.new(user: user, other_user: other_user) }
 
-  it 'returns the context object from trigger methods' do
+  it "returns the context object from trigger methods" do
     assert_equal context, context.ask?
   end
 end
 
-describe Surrounded::Context, '.east_oriented_triggers with protect_triggers' do
-  let(:user){ User.new("Jim") }
-  let(:other_user){ User.new("Guille") }
-  let(:context){
+describe Surrounded::Context, ".east_oriented_triggers with protect_triggers" do
+  let(:user) { User.new("Jim") }
+  let(:other_user) { User.new("Guille") }
+  let(:context) {
     ctxt = EastTestContext.new(user: user, other_user: other_user)
     ctxt.singleton_class.send(:protect_triggers)
     ctxt
   }
 
-  it 'returns the context object from trigger methods' do
+  it "returns the context object from trigger methods" do
     assert_equal context, context.ask?
   end
 end

data/test/example_delegate_class_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 # If you want to use wrappers, here's how you could
 class DelegateClassContext
@@ -6,9 +6,9 @@ class DelegateClassContext
 
   initialize(:user, :task)
 
-  delegate_class :user, 'User' do
+  delegate_class :user, "User" do
     def some_admin_method
-      'hello from the admin DelegateClass wrapper!'
+      "hello from the admin DelegateClass wrapper!"
     end
   end
   wrap :task do
@@ -20,10 +20,10 @@ class DelegateClassContext
 end
 
 describe DelegateClassContext do
-  let(:context){
-    DelegateClassContext.new(user: User.new('jim'), task: Object.new)
+  let(:context) {
+    DelegateClassContext.new(user: User.new("jim"), task: Object.new)
   }
-  it 'wraps objects using DelegateClass' do
-    assert_equal 'hello from the admin DelegateClass wrapper!', context.do_something
+  it "wraps objects using DelegateClass" do
+    assert_equal "hello from the admin DelegateClass wrapper!", context.do_something
   end
-end
+end

data/test/example_proxy_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class ProxyContext
   extend Surrounded::Context
@@ -58,57 +58,59 @@ ProxyUser = Class.new do
   attr_reader :name
 end
 
+ProxyTask = Data.define(:name)
+
 describe ProxyContext do
-  let(:user){
-    ProxyUser.new('Jim')
+  let(:user) {
+    ProxyUser.new("Jim")
   }
-  let(:task){
-    OpenStruct.new(name: 'GTD')
+  let(:task) {
+    ProxyTask.new(name: "GTD")
   }
-  let(:context){
+  let(:context) {
     ProxyContext.new(admin: user, task: task)
   }
-  it 'proxys methods between objects and its interface' do
-    assert_equal 'hello from Jim, the admin interface!', context.do_something
+  it "proxys methods between objects and its interface" do
+    assert_equal "hello from Jim, the admin interface!", context.do_something
   end
 
-  it 'forwards methods that the object responds to' do
-    assert_equal 'Jim', context.admin_name
+  it "forwards methods that the object responds to" do
+    assert_equal "Jim", context.admin_name
   end
 
-  it 'passes missing methods up the ancestry of the object' do
-    err = ->{ context.admin_missing_method }.must_raise(NoMethodError)
+  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/, err.message)
   end
 
-  it 'fails access to other objects in the context' do
-    err = _{ context.talking }.must_raise NameError
-    assert_match(%r{undefined local variable or method `task'}, err.message)
+  it "fails access to other objects in the context" do
+    err = _ { context.talking }.must_raise NameError
+    assert_match(/undefined local variable or method [`']task['`]/, err.message)
   end
 
-  it 'sets roles to respond to role methods' do
+  it "sets roles to respond to role methods" 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){
+  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
+  it "is able to grab methods from the object" do
     assert_equal :talking_to_others, context.get_admin_method.name
   end
 
-  it 'allows Surrounded objects to interact with others' do
-    assert context.rebind(admin: User.new('Surrounded'), task: task).talking
+  it "allows Surrounded objects to interact with others" do
+    assert context.rebind(admin: User.new("Surrounded"), task: task).talking
   end
 
-  it 'works with frozen and primitive objects' do
+  it "works with frozen and primitive objects" do
     context.rebind(admin: "brrr".freeze, task: task)
     assert context.get_admin_method
     context.rebind(admin: nil, task: task)

data/test/example_threaded_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class ThreadedContext
   extend Surrounded::Context
@@ -16,7 +16,7 @@ class ThreadedContext
       result << members.concurrent_map do |member|
         result << member.greet
       end
-      result.flatten.join(' ')
+      result.flatten.join(" ")
     end
 
     def greet
@@ -44,21 +44,21 @@ class ThreadedContext
 end
 
 describe ThreadedContext do
-  let(:jim){ User.new('Jim') }
-  let(:amy){ User.new('Amy') }
-  let(:guille){ User.new('Guille') }
-  let(:jason){ User.new('Jason') }
-  let(:dave){ User.new('Dave') }
+  let(:jim) { User.new("Jim") }
+  let(:amy) { User.new("Amy") }
+  let(:guille) { User.new("Guille") }
+  let(:jason) { User.new("Jason") }
+  let(:dave) { User.new("Dave") }
 
-  let(:greeter){ jim }
-  let(:members){ [amy, guille, jason, dave] }
+  let(:greeter) { jim }
+  let(:members) { [amy, guille, jason, dave] }
 
-  it 'works in multi-threaded environments' do
+  it "works in multi-threaded environments" do
     meeting = ThreadedContext.new(leader: jim, members: members)
 
     result = meeting.meet
 
-    assert_includes result, 'Hello everyone. I am Jim'
-    assert_includes result, 'Hello Jim, I am Amy'
+    assert_includes result, "Hello everyone. I am Jim"
+    assert_includes result, "Hello Jim, I am Amy"
   end
-end
+end

data/test/example_wrapper_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 # If you want to use wrappers, here's how you could
 class WrapperContext
@@ -8,10 +8,10 @@ class WrapperContext
 
   wrap :admin do
     def some_admin_method
-      'hello from the admin wrapper!'
+      "hello from the admin wrapper!"
     end
   end
-  wrap :task do; end
+  wrap :task, &proc {}
 
   trigger :do_something do
     admin.some_admin_method
@@ -19,10 +19,10 @@ class WrapperContext
 end
 
 describe WrapperContext do
-  let(:context){
+  let(:context) {
     WrapperContext.new(admin: Object.new, task: Object.new)
   }
-  it 'wraps objects and allows them to respond to new methods' do
-    assert_equal 'hello from the admin wrapper!', context.do_something
+  it "wraps objects and allows them to respond to new methods" do
+    assert_equal "hello from the admin wrapper!", context.do_something
   end
-end
+end