drsi 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11309067339e57a0aa6717ea6034208661896539
-  data.tar.gz: 139fd79736dea05182ac7ec019a5d4d7a98648cd
+  metadata.gz: 92ea1b7d7874b1e6ee6596e7d1ff74934ff7faaf
+  data.tar.gz: e2da03ccffe38c5d4a07b47c4ade629daa5daf37
 SHA512:
-  metadata.gz: c4aae9e60790998f6f1e194d3dd1b0aff8d1c85012bad35e4ef118d982d40254983be9868754714b7f465c2292a8e878c46a4243b79977b1245e9a131f9dcee7
-  data.tar.gz: c21408e5e63dc26e2ea4cb9d687208ae6b33e9506f5c55ef3c02fcb7f47cb26181a6fbb43d2f6ee5b92ae62e9bec0bd67d2d1be9f9aa3af17f73e1caaa9babda
+  metadata.gz: bff09ba36627ace4931fde461587d988b6cb46033af254d5445d4494711f8254e90821303a40a4437af06627d5437124f65b9e81cb49fcc62e3189fdaf52d150
+  data.tar.gz: 917f13107b5a9ee8abc8459434a91421ff150d4e7c970d064e625151eee619d6f3386b62b98b0a7657fe316d9500dddf5045661536ad61d7496c73049dda7f70

data/lib/drsi/dci/context.rb

@@ -1,4 +1,5 @@
 require 'drsi/dci/role'
+require 'drsi/dci/multiplayer'
 
 module DCI
   class Context
@@ -154,14 +155,14 @@ module DCI
       #   - This context instance get access to this new role player through an instance method named after the role key.
       def assign_role_to_player!(rolekey, player)
         role_mod = roles[rolekey]
-        player.__play_role!(role_mod, self)
+        ::DCI::Multiplayer(player).each {|roleplayer| roleplayer.__play_role!(role_mod, self)}
         instance_variable_set(:"@#{rolekey}", player)
       end
 
       # Disassociates every role from the playing object.
       def players_unplay_role!
         roles.keys.each do |rolekey|
-          @_players[rolekey].__unplay_last_role!
+          ::DCI::Multiplayer(@_players[rolekey]).each {|roleplayer| roleplayer.__unplay_last_role!}
           # 'instance_variable_set(:"@#{rolekey}", nil)
         end
       end

data/lib/drsi/dci/multiplayer.rb

@@ -0,0 +1,40 @@
+module DCI
+
+  # The intend of this method is to create something similar to Array():
+  # When called with a Multiplayer object, returns the object unmodified.
+  # Otherwise, retuns a new Multiplayer object wrapping the given argument.
+  def self.Multiplayer(obj)
+    obj.is_a?(::DCI::Multiplayer) ? obj : Multiplayer.new(obj)
+  end
+
+
+  # This simple class lets collect together a list of any type of objects.
+  # If you pass a multiplayer collection instance as the role player when instantiating a context,
+  # every object of the collection get the role instead of the multiplayer instance itself.
+  # So this is the way for different objects to play the similar roles at the same time in a DCI Context.
+  class Multiplayer
+
+    # Syntax sugar to easy the creation of Multiplayer instances.
+    def self.[](*args)
+      new(*args)
+    end
+
+    def each(&block)
+      @players.each {|player| block.call(player)}
+    end
+
+    # Give access to the players of this instance in a way similar to an array:
+    # multiplayer[1], multiplayer[1..5], multiplayer[-2], ...
+    def [](index)
+      @players[index]
+    end
+
+    def initialize(*args)
+      @players = args
+    end
+
+  end
+
+end
+
+

data/lib/drsi/dci/role.rb

@@ -4,14 +4,14 @@ module DCI
     private
 
       def context
-        raise 'This method must be redefined in every module including DCI::Role'
+        raise 'This method must be redefined in every module extending DCI::Role'
       end
 
       # Defines a new private reader instance method for a context mate role, delegating it to the context object.
       def add_role_reader_for!(rolekey)
         return if private_method_defined?(rolekey)
-        private
         define_method(rolekey) {context.send(rolekey)}
+        private rolekey
       end
 
   end

data/lib/drsi/version.rb

@@ -1,3 +1,3 @@
 module Drsi
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/spec/multiplayers_spec.rb

@@ -0,0 +1,134 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'ostruct'
+
+describe 'Role MultiPlayers' do
+
+  context "A role can be played by many objects in the same context at the same time" do
+    before(:all) do
+      class TestingRoleplayersContext < DCI::Context
+        role :role1 do
+          def role1method1; :role1method1_executed end
+          def role1self; self end
+        end
+
+        role :role2 do
+          def role2method1; role1 end
+          def role2self;   self   end
+
+          private
+          def private_role2method2; :private_rolemethod_return_value end
+        end
+
+        def check_role1_identity(obj)
+          [role1 == obj, role1.role1self == obj, role1.respond_to?(:role1method1), obj.respond_to?(:role1method1),
+           role1.role1method1 == :role1method1_executed, obj.role1method1 == :role1method1_executed].uniq == [true]
+        end
+
+        def get_role2_from_role1
+         role1.send(:role2)
+        end
+
+        def multiplayer_dont_get_role
+          [!role2.respond_to?(:role2method1), !role2.private_methods.map(&:to_s).include?('private_role2method2')].uniq == [true]
+        end
+
+        def multiplayer_players_get_their_role?
+          role2players = role2[0..-1]
+          [!role2players.empty?,
+           (role2players.all? {|roleplayer| roleplayer.respond_to?(:role2method1)}),
+           (role2players.all? {|roleplayer| roleplayer.role2method1 == role1}),
+           (role2players.all? {|roleplayer| roleplayer.private_methods.map(&:to_s).include?('private_role2method2')}),
+
+          ].uniq == [true]
+        end
+
+        def check_role2players_identity(*objs)
+          objs.all? do |obj|
+            index = objs.index(obj)
+            [role2 != obj, role2[index] == obj, role2[index].role2self == obj,
+             role2[index].send(:private_role2method2) == :private_rolemethod_return_value,
+             obj.send(:private_role2method2)          == :private_rolemethod_return_value].uniq == [true]
+          end
+        end
+
+        def roles2_external_interfaces_accessible?(*names)
+          names.all? do |name|
+            index = names.index(name)
+            role2[index].name == name
+          end
+        end
+
+        def roles2_have_context_private_access?
+          role2[0..-1].all? do |roleplayer|
+            [!roleplayer.respond_to?(:context), roleplayer.private_methods.map(&:to_s).include?('context'), roleplayer.send(:context) == self].uniq == [true]
+          end
+        end
+
+        def roles2_have_settings_private_access?(settings_copy)
+          role2[0..-1].all? do |roleplayer|
+            [!roleplayer.respond_to?(:settings), roleplayer.private_methods.map(&:to_s).include?('settings'),
+             roleplayer.send(:settings) == settings, roleplayer.send(:settings) == settings_copy,
+             roleplayer.send(:settings, :setting2) == settings_copy[:setting2],
+             roleplayer.send(:settings, :setting1, :setting3) == {:setting1 => settings_copy[:setting1], :setting3 => settings_copy[:setting3]}
+            ].uniq == [true]
+          end
+        end
+
+      end
+
+      @player1, @player2, @player22 = OpenStruct.new(:name => 'player1'), OpenStruct.new(:name => 'player2'), OpenStruct.new(:name => 'player22')
+      @multiplayer = DCI::Multiplayer[@player2, @player22]
+      #puts @multiplayer.instance_variable_get(:@players)
+      @testing_roleplayers_context  = TestingRoleplayersContext.new(:role1    => @player1,
+                                                                    :role2    => @multiplayer,
+                                                                    :setting1 => :one,
+                                                                    :setting2 => :two,
+                                                                    :setting3 => :three)
+    end
+
+    it("For it to work, the developer has to give a rolekey the value of a DCI::Multiplayer instance when instantiating the context...") do
+      @testing_roleplayers_context.get_role2_from_role1.should be(@multiplayer)
+    end
+
+    it("...so now, all the objects wrapped by the multiplayer instance play the role intended") do
+      @testing_roleplayers_context.multiplayer_dont_get_role.should be_true
+      @testing_roleplayers_context.multiplayer_players_get_their_role?.should be_true
+    end
+
+    it("...preserving their identity") do
+      @testing_roleplayers_context.check_role2players_identity(@player2, @player22).should be_true
+    end
+    it("...and therefore, their state and behaviour are accessible inside the context.") do
+      @testing_roleplayers_context.roles2_external_interfaces_accessible?(@player2.name, @player22.name).should be_true
+    end
+
+    it("They have private access to the context.") do
+      @testing_roleplayers_context.roles2_have_context_private_access?.should be_true
+    end
+
+    it("And also private access to extra args received in the instantiation of its context.") do
+      @testing_roleplayers_context.roles2_have_settings_private_access?({:setting1 => :one, :setting2 => :two, :setting3 => :three}).should be_true
+    end
+
+    it("But all these features, are only inside a context. Never out of it!") do
+      @player2.should_not  respond_to(:role1method1)
+      @player22.should_not respond_to(:role1method1)
+      @player2.private_methods.map(&:to_s).should_not include(:private_role2method2)
+      @player22.private_methods.map(&:to_s).should_not include(:private_role2method2)
+      @player2.name.should eq('player2')
+      @player22.name.should eq('player22')
+      @player2.should_not  respond_to(:role1)
+      @player22.should_not respond_to(:role1)
+      @player2.should_not  respond_to(:context)
+      @player22.should_not respond_to(:context)
+      @player2.should_not  respond_to(:settings)
+      @player22.should_not respond_to(:settings)
+      (@player2.private_methods.map(&:to_s) &  ['role1', 'context', 'settings']).should be_empty
+      (@player22.private_methods.map(&:to_s) & ['role1', 'context', 'settings']).should be_empty
+    end
+
+
+
+  end
+
+end

data/spec/role_spec.rb

@@ -5,10 +5,8 @@ describe 'Role' do
   context "When defining roles inside a DCI::Context subclass..." do
     before(:all) do
       class TestingRoleContext < DCI::Context
-        role :rolename do
-        end
-        role :anotherrolename do
-        end
+        role :rolename
+        role :anotherrolename do end
       end
     end
     it("...you can define as many as you want.") do
@@ -25,8 +23,9 @@ describe 'Role' do
         end
       end.to raise_error
     end
-    it("A block defining rolemethods must be provided as well.") do
+    it("A block defining rolemethods can be provided as well.") do
       TestingRoleContext.roles[:rolename].should be_a(Module)
+      TestingRoleContext.roles[:anotherrolename].should be_a(Module)
     end
   end
 

data/spec/roleplayers_spec.rb

@@ -19,7 +19,9 @@ describe 'RolePlayers' do
           def private_role2method2; :private_rolemethod_return_value end
         end
 
-        def check_role_interaccess; role2.role2method1 == role1 end
+        def check_role_interaccess
+          [role2.role2method1 == role1, !role2.respond_to?(:role1)].uniq == [true]
+        end
 
         def check_role1_identity(obj)
           [role1 == obj, role1.role1self == obj, role1.respond_to?(:role1method1), obj.respond_to?(:role1method1),

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: drsi
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Lorenzo Tello
@@ -43,6 +43,7 @@ files:
 - examples/money_transfer.rb
 - lib/drsi.rb
 - lib/drsi/dci/context.rb
+- lib/drsi/dci/multiplayer.rb
 - lib/drsi/dci/role.rb
 - lib/drsi/module.rb
 - lib/drsi/object.rb
@@ -50,6 +51,7 @@ files:
 - lib/drsi/version.rb
 - spec/context_spec.rb
 - spec/interaction_spec.rb
+- spec/multiplayers_spec.rb
 - spec/players_spec.rb
 - spec/role_spec.rb
 - spec/roleplayers_spec.rb
@@ -83,6 +85,7 @@ summary: Make DCI paradigm available to Ruby applications by enabling developers
 test_files:
 - spec/context_spec.rb
 - spec/interaction_spec.rb
+- spec/multiplayers_spec.rb
 - spec/players_spec.rb
 - spec/role_spec.rb
 - spec/roleplayers_spec.rb