dci-ruby 2.0.0 → 2.1.0

data/README.rdoc

@@ -34,34 +34,37 @@ dci-ruby gives you the class DCI::Context to inherit from to create your own con
           end
 
       # Interactions
-          def run(amount=default_amount)
+          def run(amount=settings(:amount))
             source_account.transfer(amount)
             target_account.get_transfer(amount)
           end
     end
 
 Every context defines some roles to be played by external objects (players) and their interactions. This way
-you have all the agents and operations in a user case wrapped in just one entity instead of spreaded throughout the
+you have all the agents and operations in a user case wrapped in just one entity instead of spread out throughout the
 application code.
 
-Use the defined contexts, instantiating them wherever you need in your code:
+Use the defined contexts, instantiating them, wherever you need in your code:
 
     MoneyTransfer.new(:source_account => Account.new(1),
                       :target_account => Account.new(2)).run(100)
 
-In a context instance, every role instanciates an object (roleplayer) that gathers the behaviour defined inside its role,
-and that roleplayer object has private access to the original object adopting the role (player): the Account instances above are players.
+In a context instance, every role instantiates an object (roleplayer) that gathers the behaviour defined inside its role,
+and has private access to the original object adopting the role (player): the Account instances above are players.
 Instances of MoneyTransfer::SourceAccount and MoneyTransfer::TargetAccount accessible inside MoneyTransfer.new via
 the private instance_methods #source_account and #target_account are roleplayers.
 Also, every roleplayer has private access to the rest of roleplayers in its context.
 
+Unlike extending players with role modules this Presenter approach gets on well with ruby method call caching mechanism.
+(see Tony Arcieri's article {DCI in Ruby is completely broken}[http://tonyarcieri.com/dci-in-ruby-is-completely-broken])
+
 When instanciating a Context, the extra no-role pairs given as arguments are read-only attributes accessible inside the instance:
 
     MoneyTransfer.new(:source_account => Account.new(1),
                       :target_account => Account.new(2),
-                      :default_amount => 500).run
+                      :amount => 500).run
 
-here, default_amount is not a player (has no associated role) but is still accessible in the interactions.
+here, :amount is not a player (has no associated role) but is still privately accessible in the interactions via settings(:amount).
 
 See the examples[https://github.com/ltello/dci-ruby/tree/master/examples] folder for examples of use and the DCI-Sample[https://github.com/ltello/DCI-Sample] repository for a sample application using DCI through this gem.
 

data/examples/money_transfer.rb

@@ -42,7 +42,7 @@ class MoneyTransferContext < DCI::Context
 
   # Interactions
 
-    def run
+    def run(amount=settings(:amount))
       puts "Balances Before: #{balances}"
       source_account.run_transfer_of(amount)
       target_account.run_transfer_of(amount)
@@ -61,6 +61,13 @@ class MoneyTransferContext < DCI::Context
     end
 end
 
-MoneyTransferContext.new(:source_account => CheckingAccount.new(1, 500),
-                         :target_account => CheckingAccount.new(2),
-                         :amount         => 500).run
+acc1 = CheckingAccount.new(1, 1000)
+acc2 = CheckingAccount.new(2)
+
+MoneyTransferContext.new(:source_account => acc1,
+                         :target_account => acc2,
+                         :amount         => 200).run
+4.times do
+  MoneyTransferContext.new(:source_account => acc1,
+                           :target_account => acc2).run(200)
+end

data/lib/dci-ruby/dci/context.rb

@@ -19,16 +19,51 @@ module DCI
 
       private
 
-        # The macro role is defined to allow a subclass of Context to define roles in its definition.
-        # Every new role redefines the role class method to contain a hash accumulating all defined roles in that subclass.
-        # An accessor to the object playing the new role is also defined and available in every instance of the context subclass.
-        def role(role_key, &block)
-          raise "role name must be a symbol" unless role_key.is_a?(Symbol)
-          new_klass_name = role_key.to_s.split(/\_+/).map(&:capitalize).join('')
+        # The macro role is defined to allow a subclass of Context to define roles in its definition body.
+        # Every new role is added to the hash of roles in that Context subclass.
+        # A reader to access the object playing the new role is also defined and available in every instance of the context subclass.
+        # Also, readers to allow each other role access are defined.
+        def role(rolekey, &block)
+          raise "role name must be a symbol" unless rolekey.is_a?(Symbol)
+          create_role_from(rolekey, &block)
+          define_reader_for_role(rolekey)
+          define_mate_roleplayers_readers_after_newrole(rolekey)
+        end
+
+        # Adds a new entry to the roles accumulator hash.
+        def create_role_from(key, &block)
+          roles.merge!(key => create_role_subclass_from(key, &block))
+        end
+
+        # Defines and return a new subclass of DCI::Role named after the given rolekey and with body the given block.
+        def create_role_subclass_from(rolekey, &block)
+          new_klass_name = rolekey.to_s.split(/\_+/).map(&:capitalize).join('')
           const_set(new_klass_name, Class.new(::DCI::Role, &block))
-          roles.merge!(role_key => const_get(new_klass_name.to_sym))
-          attr_reader role_key
-          private role_key
+        end
+
+        # Defines a private reader to allow a context instance access to the roleplayer object associated to the given rolekey.
+        def define_reader_for_role(rolekey)
+          attr_reader rolekey
+          private rolekey
+        end
+
+        # After a new role is defined, you've got to create a reader method for this new role in the rest of context
+        # roles, and viceverse: create a reader method in the new role klass for each of the other roles in the context.
+        # This method does exactly this.
+        def define_mate_roleplayers_readers_after_newrole(new_rolekey)
+          new_roleklass = roles[new_rolekey]
+          mate_roles    = mate_roles_of(new_rolekey)
+          mate_roles.each do |mate_rolekey, mate_roleklass|
+            mate_roleklass.add_role_reader_for!(new_rolekey)
+            new_roleklass.add_role_reader_for!(mate_rolekey)
+          end
+        end
+
+        # For a give role key, returns a hash with the rest of the roles (pair :rolekey => roleklass) in the context it belongs to.
+        def mate_roles_of(rolekey)
+          roles.dup.tap do |roles|
+            roles.delete(rolekey)
+          end
         end
 
     end
@@ -40,19 +75,24 @@ module DCI
     # Non players args are associated to instance_variables and readers defined.
     def initialize(args={})
       check_all_roles_provided_in!(args)
-      players, noplayers = args.partition {|key, value| roles.has_key?(key)}.map {|group| Hash[*group.flatten]}
+      players, noplayers = args.partition {|key, *| roles.has_key?(key)}.map {|group| Hash[*group.flatten]}
       assign_roles_to_players(players)
-      define_readers_for_no_players(noplayers)
+      @settings = noplayers
     end
 
 
     private
 
+      # Private access to the extra args received in the instantiation.
+      def settings(key)
+        @settings[key]
+      end
+
       # Checks there is a player for each role.
       # Raises and error message in case of missing roles.
       def check_all_roles_provided_in!(players={})
-        missing_roles = missing_roles(players)
-        raise "missing roles #{missing_roles}" unless missing_roles.empty?
+        missing_rolekeys = missing_roles(players)
+        raise "missing roles #{missing_rolekeys}" unless missing_rolekeys.empty?
       end
 
       # The list of roles with no player provided
@@ -62,33 +102,32 @@ module DCI
 
       # Associates every role to the intended player.
       def assign_roles_to_players(players={})
-        roles.keys.each do |role_key|
-          assign_role_to_player(role_key, players[role_key])
+        roles.keys.each do |rolekey|
+          assign_role_to_player(rolekey, players[rolekey])
         end
       end
 
       # Associates a role to an intended player:
-      #   - A new role instance is created from the associated role_key class and the player to get that role.
+      #   - A new role instance is created from the associated rolekey class and the player to get that role.
       #   - The new role instance has access to the context it is playing.
       #   - The new role instance has access to the rest of players in its context through instance methods named after their role keys.
       #   - The context instance has access to this new role instance through an instance method named after the role key.
-      def assign_role_to_player(role_key, player)
-        role_klass      = roles[role_key]
-        other_role_keys = roles.keys - [role_key]
-        role_instance   = role_klass.new(:player => player, :context => self, :role_mate_keys => other_role_keys)
-        instance_variable_set(:"@#{role_key}", role_instance)
+      def assign_role_to_player(rolekey, player)
+        role_klass    = roles[rolekey]
+        role_instance = role_klass.new(:player => player, :context => self)
+        instance_variable_set(:"@#{rolekey}", role_instance)
       end
 
-      # For each given pair in vars, define a private method named the key that returns the entry associated value.
-      def define_readers_for_no_players(vars={})
-        vars.each do |name, value|
-          instance_variable_set(:"@#{name}", value)
-          singleton_class.class_exec(name.to_sym) do |varkey|
-            private
-              attr_reader varkey
-          end
-        end
-      end
+      # # For each given pair in vars, define a private method named the key that returns the entry associated value.
+      # def define_readers_for_no_players(vars={})
+      #   vars.each do |name, value|
+      #     instance_variable_set(:"@#{name}", value)
+      #     singleton_class.class_exec(name.to_sym) do |varkey|
+      #       private
+      #         attr_reader varkey
+      #     end
+      #   end
+      # end
 
   end
 

data/lib/dci-ruby/dci/role.rb

@@ -10,6 +10,13 @@ module DCI
         super
       end
 
+      # Defines a new 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)
+        define_method(rolekey) {@context.send(rolekey)}
+        private rolekey
+      end
+
     end
 
     # Opts:
@@ -19,7 +26,6 @@ module DCI
     def initialize(opts={})
       @player  = opts[:player]
       @context = opts[:context]
-      define_role_mate_methods!(opts[:role_mate_keys])
     end
 
 
@@ -30,20 +36,5 @@ module DCI
         @player
       end
 
-      # For each role in the context, define a method so inside a role you can access all the others.
-      def define_role_mate_methods!(role_mate_keys)
-        self.class.class_exec(role_mate_keys) do |other_role_keys|
-          other_role_keys.each do |role_key|
-            if not private_method_defined?(role_key)
-              define_method(role_key) do
-                @context.send(role_key)
-              end
-              private role_key
-            end
-          end
-        end
-      end
-
   end
-
 end

data/lib/dci-ruby/version.rb

@@ -1,3 +1,3 @@
 module DCI
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end

data/spec/interaction_spec.rb

@@ -15,7 +15,7 @@ describe 'Interaction:' do
         end
       end
       @player1, @player2 = Object.new, Object.new
-      @test_interactions_context = TestingInteractionsContext.new(:role1 => @player1, :role2 => @player2, :extra_arg => :extra)
+      @test_interactions_context = TestingInteractionsContext.new(:role1 => @player1, :role2 => @player2, :setting1 => :one)
     end
 
     it("...the developer has access to all the roleplayers...") do
@@ -26,11 +26,11 @@ describe 'Interaction:' do
       @test_interactions_context.private_methods(false).should include('role1', 'role2')
     end
 
-    it("He also have access to extra args received in the instantiation of its context...") do
-      @test_interactions_context.send(:extra_arg).should be(:extra)
+    it("He also have private access to extra args received in the instantiation of its context...") do
+      @test_interactions_context.private_methods.should include('settings')
     end
-    it("...through private methods named after their keys.") do
-      @test_interactions_context.private_methods(false).should include('extra_arg')
+    it("...calling #settings(key)") do
+      @test_interactions_context.send(:settings, :setting1).should be(:one)
     end
   end
 

data/spec/roleplayers_spec.rb

@@ -63,11 +63,11 @@ describe 'RolePlayers' do
       @testing_roleplayers_context.send(:role2).send(:player).name.should eq('player2')
     end
 
-    it("Roleplayers have private access to other roleplayers in their context...") do
-      @testing_roleplayers_context.send(:role2).private_methods(false).should include('role1')
-      @testing_roleplayers_context.send(:role2).rolemethod2.should eql(@testing_roleplayers_context.send(:role1))
+    it("Roleplayers have private access to other roleplayers in their context through methods named after their keys.") do
+      @testing_roleplayers_context.send(:role2).private_methods.should include('role1')
+      @testing_roleplayers_context.send(:role2).rolemethod2.should be(@testing_roleplayers_context.send(:role1))
     end
-    it("...and even the context itself.") do
+    it("However, they dont have a method to access the context.") do
       expect {@testing_roleplayers_context.send(:role2).send(:context)}.to raise_error(NoMethodError)
       @testing_roleplayers_context.send(:role2).instance_variables.should include('@context')
       @testing_roleplayers_context.send(:role2).instance_variable_get(:@context).should be(@testing_roleplayers_context)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dci-ruby
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: 
   segments: 
   - 2
+  - 1
   - 0
-  - 0
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors: 
 - Lorenzo Tello