dci-ruby 1.0.0 → 2.0.0

data/.gitignore

@@ -0,0 +1,52 @@
+# rcov generated
+coverage
+coverage.data
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore:
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+
+# For TextMate
+#*.tmproj
+#tmtags
+
+# For emacs:
+#*~
+#\#*
+#.\#*
+
+# For vim:
+#*.swp
+
+# For redcar:
+#.redcar
+
+# For rubinius:
+#*.rbc
+
+# RVM
+.rvmrc

data/Gemfile

@@ -1,14 +1,5 @@
 source "http://rubygems.org"
-# Add dependencies required to use your gem here.
-# Example:
-#   gem "activesupport", ">= 2.3.5"
 
-# Add dependencies to develop your gem here.
-# Include everything needed to run rake, tests, features, etc.
-group :development do
-  gem "rspec", "~> 2"
-  gem "rdoc",  "~> 3.12"
-  gem "bundler", "~> 1.0.0"
-  gem "jeweler", "~> 1.8.4"
-  gem "rcov", ">= 0"
-end
+# It's better to specify your gem's dependencies (both, those of development and those of production) in foodie.gemspec
+gemspec  # This makes bundle read dci-ruby.gemspec file to add its dependencies in their corresponding groups
+

data/Gemfile.lock

@@ -1,18 +1,12 @@
+PATH
+  remote: .
+  specs:
+    dci-ruby (2.0.0)
+
 GEM
   remote: http://rubygems.org/
   specs:
     diff-lcs (1.1.3)
-    git (1.2.5)
-    jeweler (1.8.4)
-      bundler (~> 1.0)
-      git (>= 1.2.5)
-      rake
-      rdoc
-    json (1.7.5)
-    rake (0.9.2.2)
-    rcov (1.0.0)
-    rdoc (3.12)
-      json (~> 1.4)
     rspec (2.11.0)
       rspec-core (~> 2.11.0)
       rspec-expectations (~> 2.11.0)
@@ -26,8 +20,5 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.0.0)
-  jeweler (~> 1.8.4)
-  rcov
-  rdoc (~> 3.12)
-  rspec (~> 2)
+  dci-ruby!
+  rspec (~> 2.0)

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Lorenzo Tello
+Copyright (c) 2012, 2013 Lorenzo Tello
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -8,65 +8,64 @@ This gem makes Data-Context-Interaction paradigm ready to be used in your Ruby a
 
 Install as usual, either with rubygems
     gem install dci-ruby
-or including it in your Gemfile and then running bundle install:
+
+or including it in your Gemfile and running bundle install:
     # Gemfile
     gem "dci-ruby"
 
 
 == Use
 
-dci-ruby gives you the class Context to inherit from to create your own contexts:
+dci-ruby gives you the class DCI::Context to inherit from to create your own contexts:
 
-    class MoneyTransfer < Context
+    class MoneyTransfer < DCI::Context
 
       # Roles
           role :source_account do
             def transfer(amount)
-               balance -= amount
-               target_account.get_transfer(amount)
+              player.balance -= amount
             end
           end
 
           role :target_account do
             def get_transfer(amount)
-              balance += amount
+              player.balance += amount
             end
           end
 
       # Interactions
-          def run(amount)
+          def run(amount=default_amount)
             source_account.transfer(amount)
-          end
-
-          def run_default
-            source_account.transfer(default_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 the whole agents and operations in a user case wrapped in just one entity instead of spreaded througout the
-whole application code.
+you have all the agents and operations in a user case wrapped in just one entity instead of spreaded throughout the
+application code.
 
-Use the defined contexts in your application, instantiating them wherever you need them 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)
 
-Role player objects (the two account instances above) respond to their corresponding role methods inside the context.
-Moreover, every role player has access to the rest of role players. That's why target_account is reachable inside source_account#transfer
-rolemethod.
+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.
+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.
+
 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_default
+                      :default_amount => 500).run
 
-here, default_amount is not a roleplayer (has no associated role) but is still accessible in the interactions.
+here, default_amount is not a player (has no associated role) but is still accessible in the interactions.
 
 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.
 
 == Copyright
 
-Copyright (c) 2012 Lorenzo Tello. See LICENSE.txt for
-further details.
+Copyright (c) 2012, 2013 Lorenzo Tello. See LICENSE.txt for further details.
 

data/Rakefile

@@ -1,49 +1 @@
-# encoding: utf-8
-
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rake'
-
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name        = "dci-ruby"
-  gem.homepage    = "http://github.com/ltello/dci-ruby"
-  gem.license     = "MIT"
-  gem.summary     = %Q{Make DCI paradigm available to Ruby applications by enabling developers defining contexts suclassing the new class Context. You define roles inside the definition. Match roles and player objects in context instanciation.}
-  gem.description = %Q{Make DCI paradigm available to Ruby applications}
-  gem.email       = "ltello8a@gmail.com"
-  gem.authors     = ["Lorenzo Tello"]
-  # dependencies defined in Gemfile
-end
-Jeweler::RubygemsDotOrgTasks.new
-
-require 'rspec/core'
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = FileList['spec/**/*_spec.rb']
-end
-
-RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
-task :default => :spec
-
-require 'rdoc/task'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "dci-ruby #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+require "bundler/gem_tasks"

data/dci-ruby.gemspec

@@ -1,68 +1,25 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dci-ruby/version"
 
 Gem::Specification.new do |s|
-  s.name = "dci-ruby"
-  s.version = "1.0.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Lorenzo Tello"]
-  s.date = "2012-10-25"
+  s.name        = "dci-ruby"
+  s.version     = DCI::VERSION
+  s.authors     = ["Lorenzo Tello"]
+  s.email       = ["ltello8a@gmail.com"]
+  s.homepage    = "http://github.com/ltello/dci-ruby"
+  s.summary     = "Make DCI paradigm available to Ruby applications by enabling developers defining contexts subclassing the class DCI::Context. You define roles inside the definition. Match roles and player objects in context instantiation."
   s.description = "Make DCI paradigm available to Ruby applications"
-  s.email = "ltello8a@gmail.com"
-  s.extra_rdoc_files = [
-    "LICENSE.txt",
-    "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-    ".rspec",
-    "Gemfile",
-    "Gemfile.lock",
-    "LICENSE.txt",
-    "README.rdoc",
-    "Rakefile",
-    "VERSION",
-    "dci-ruby.gemspec",
-    "examples/money_transfer.rb",
-    "lib/dci-ruby.rb",
-    "lib/dci-ruby/kernel.rb",
-    "spec/context_spec.rb",
-    "spec/interaction_spec.rb",
-    "spec/role_spec.rb",
-    "spec/roleplayers_spec.rb",
-    "spec/spec_helper.rb"
-  ]
-  s.homepage = "http://github.com/ltello/dci-ruby"
   s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.24"
-  s.summary = "Make DCI paradigm available to Ruby applications by enabling developers defining contexts suclassing the new class Context. You define roles inside the definition. Match roles and player objects in context instanciation."
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
+  s.rubyforge_project = "dci-ruby"
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, ["~> 2"])
-      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
-      s.add_development_dependency(%q<rcov>, [">= 0"])
-    else
-      s.add_dependency(%q<rspec>, ["~> 2"])
-      s.add_dependency(%q<rdoc>, ["~> 3.12"])
-      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
-      s.add_dependency(%q<rcov>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<rspec>, ["~> 2"])
-    s.add_dependency(%q<rdoc>, ["~> 3.12"])
-    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
-    s.add_dependency(%q<rcov>, [">= 0"])
-  end
-end
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
 
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec", "~> 2.0"
+  # s.add_runtime_dependency "rest-client"
+end

data/examples/money_transfer.rb

@@ -1,3 +1,4 @@
+require 'forwardable'
 require 'dci-ruby'
 
 
@@ -5,27 +6,36 @@ class CheckingAccount
   attr_reader   :account_id
   attr_accessor :balance
 
-  def initialize(account_id)
-    @account_id, @balance = account_id, 0
+  def initialize(account_id, initial_balance=0)
+    @account_id, @balance = account_id, initial_balance
   end
 end
 
 
-class MoneyTransferContext < Context
+class MoneyTransferContext < DCI::Context
 
   # Roles Definitions
 
     role :source_account do
+      extend ::Forwardable
+      def_delegators :player, :account_id, :balance, :balance=
+
       def run_transfer_of(amount)
         self.balance -= amount
-        puts "Source Account #{account_id} sent $#{amount} to Target Account #{target_account.account_id}."
+        puts "\tAccount(\##{account_id}) sent #{amount}€ to Account(\##{target_account.account_id})."
       end
     end
 
     role :target_account do
+      #[:account_id, :balance, :balance=].each {|field| define_method(field) {|*args| player.send(field, *args)}}
+      def account_id;      player.account_id       end
+      def balance;         player.balance          end
+      def balance=(amount) player.balance=(amount) end
+      private :balance=
+
       def run_transfer_of(amount)
         self.balance += amount
-        puts "Target Account #{account_id} received $#{amount} from Source Account #{source_account.account_id}."
+        puts "\tAccount(\##{account_id}) received #{amount}€ from Account(\##{source_account.account_id})."
       end
     end
 
@@ -47,10 +57,10 @@ class MoneyTransferContext < Context
     end
 
     def balances
-      accounts.map {|account| "$#{account.balance}"}.join(' - ')
+      accounts.map {|account| "#{account.balance}€"}.join(' - ')
     end
 end
 
-MoneyTransferContext.new(:source_account => CheckingAccount.new(1),
+MoneyTransferContext.new(:source_account => CheckingAccount.new(1, 500),
                          :target_account => CheckingAccount.new(2),
                          :amount         => 500).run

data/lib/dci-ruby.rb

@@ -1,96 +1,7 @@
-require 'forwardable'
+require 'dci-ruby/version'
 require 'dci-ruby/kernel'
+require 'dci-ruby/dci/context'
 
-
-class Context
-
-  class << self
-
-    # Every subclass of Context has is own class and instance method roles defined.
-    # The instance method delegates value to the class.
-    def inherited(subklass)
-      subklass.class_eval do
-        def self.roles; {} end
-        def roles; self.class.roles end
-      end
-    end
-
-
-    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)
-        updated_roles = roles.merge(role_key => Module.new(&block))
-        singleton_class.class_exec(updated_roles) do |new_roles|
-          remove_method(:roles) rescue nil
-          define_method(:roles) { new_roles }
-        end
-        attr_reader role_key
-      end
-
-  end
-
-
-  # Instances of a defined subclass of Context are initialized checking first that all subclass defined roles
-  # are provided in the creation invocation raising an error if any of them is missing.
-  # Once the previous check is met, every object playing in the context instance is associated to the stated role.
-  # 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.keys.include?(key)}.map {|group| Hash[*group.flatten]}
-    assign_roles_to_players(players)
-    define_attr_readers_for_no_players(noplayers)
-  end
-
-
-  private
-
-    # Checks there is an intented player for every 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?
-    end
-
-    # The list of roles with no player provided
-    def missing_roles(players={})
-      (roles.keys - players.keys)
-    end
-
-    # 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])
-      end
-    end
-
-    # Associates a role to an intended player:
-    #   - The object to play the role extends the defined module for that role, so it now respond to the methods
-    #       defined in the role definition.
-    #   - The object to play the role has access to the context it is playing.
-    #   - The object to play the role has access to the rest of players in its context.
-    #   - The context instance has access to this new player through a new instance variable defined with the name of the role.
-    def assign_role_to_player(role_key, player)
-      role_module     = roles[role_key]
-      other_role_keys = roles.keys - [role_key]
-      player.extend(role_module, ::SingleForwardable)
-      player.singleton_class.class_exec(self) do |context|
-        define_method(:context) {context}
-      end
-      player.def_delegators(:context, *other_role_keys)
-      instance_variable_set(:"@#{role_key}", player)
-    end
-
-    def define_attr_readers_for_no_players(vars={})
-      vars.each do |name, value|
-        instance_variable_set(:"@#{name}", value)
-        singleton_class.class_exec(name.to_sym) do |varkey|
-          attr_reader varkey
-        end
-      end
-
-    end
+module DCI
 end
+

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

@@ -0,0 +1,95 @@
+require 'dci-ruby/dci/role'
+
+module DCI
+
+  class Context
+
+    class << self
+
+      # Every subclass of Context has is own class and instance method roles defined.
+      # The instance method delegates value to the class.
+      def inherited(subklass)
+        subklass.class_eval do
+          @roles ||= {}
+          def self.roles; @roles end
+          def roles; self.class.roles end
+        end
+      end
+
+
+      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('')
+          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
+
+    end
+
+
+    # Instances of a defined subclass of Context are initialized checking first that all subclass defined roles
+    # are provided in the creation invocation raising an error if any of them is missing.
+    # Once the previous check is met, every object playing in the context instance is associated to the stated role.
+    # 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]}
+      assign_roles_to_players(players)
+      define_readers_for_no_players(noplayers)
+    end
+
+
+    private
+
+      # 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?
+      end
+
+      # The list of roles with no player provided
+      def missing_roles(players={})
+        (roles.keys - players.keys)
+      end
+
+      # 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])
+        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.
+      #   - 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)
+      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
+
+end

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

@@ -0,0 +1,49 @@
+module DCI
+
+  class Role
+
+    class << self
+
+      # Make this class abstract: will not allow create instances.
+      def new(*args, &block)
+        raise 'This class is meant to be abstract and not instantiable' if self == DCI::Role
+        super
+      end
+
+    end
+
+    # Opts:
+    #  player         => the object to adquire this role,
+    #  context        => the context instance in which this role instance will play
+    #  role_mate_keys => list of keys of the rest of roles playing in the given context
+    def initialize(opts={})
+      @player  = opts[:player]
+      @context = opts[:context]
+      define_role_mate_methods!(opts[:role_mate_keys])
+    end
+
+
+    private
+
+      # Make the original object playing the role accessible only inside role definition code!
+      def player
+        @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

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

data/spec/context_spec.rb

@@ -1,12 +1,14 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe Context do
+describe DCI::Context do
 
-  context "Definition" do
-    context "When Inherit from Context" do
+  context "Definition:" do
+    context "When Inheriting from DCI::Context..." do
       before(:all) do
-        class ExampleContext < Context
-          role :rolename do
+        class TestingDefinitionContext < DCI::Context
+          role :role_name do
+            def role_name_method
+            end
           end
 
           def interaction1
@@ -14,17 +16,42 @@ describe Context do
         end
       end
 
-      it("A new context subclass is ready to be used...") {ExampleContext.superclass.should be(Context)}
-      it("...in which the developer can define roles...") {ExampleContext.private_methods.should include("role")}
-      it("...but privately inside the class.") {ExampleContext.should_not respond_to(:role)}
-      it("He can also define contextmethods (instance methods) that acts as interactions.") {ExampleContext.public_instance_methods(false).should include('interaction1')}
+      it("...a new dci context is ready to be used...") {TestingDefinitionContext.superclass.should be(DCI::Context)}
+      it("...in which the developer can define roles...") do
+        TestingDefinitionContext.private_methods.should include("role")
+      end
+      it("...but privately inside the subclass.") {TestingDefinitionContext.should_not respond_to(:role)}
+
+      it("A role is defined calling the private macro #role with a role_key and a block defining the specific methods of the role.") do
+        TestingDefinitionContext.roles.size.should be(1)
+        TestingDefinitionContext.roles.keys.should include(:role_name)
+      end
+
+      it("The #roles public class_and_instance_method will return a hash with pairs (role_key => ContextSubclass::Rolekey)...") do
+        TestingDefinitionContext.roles.should eq({:role_name => TestingDefinitionContext::RoleName})
+        TestingDefinitionContext.new(:role_name => Object.new).roles.should eq(:role_name => TestingDefinitionContext::RoleName)
+      end
+      it("... where every ContextSubclass::Rolekey is a new class created at load time,...") do
+        TestingDefinitionContext.roles[:role_name].should be_a(Class)
+        TestingDefinitionContext.roles[:role_name].should be(TestingDefinitionContext::RoleName)
+      end
+      it("... named after the associated role_key...") do
+        TestingDefinitionContext.const_defined?(:RoleName).should be(true)
+      end
+      it("... and defined after the block given to the associated role in its definition.") do
+        TestingDefinitionContext::RoleName.public_instance_methods.should include("role_name_method")
+      end
+
+      it("Inside the context subclass, the developer defines context methods (instance methods) that act as interactions.") do
+        TestingDefinitionContext.public_instance_methods(false).should include('interaction1')
+      end
     end
   end
 
-  context "Use" do
-    context "To use a Context" do
+  context "Use:" do
+    context "To use a Context..." do
       before(:all) do
-        class AnotherContext < Context
+        class TestingUseContext < DCI::Context
           role :role1 do
           end
           role :role2 do
@@ -39,23 +66,32 @@ describe Context do
           end
         end
         @player1, @player2 = Object.new, Object.new
-        @example_context   = AnotherContext.new(:role1 => @player1, :role2 => @player2)
+        @context_instance_1 = TestingUseContext.new(:role1 => @player1, :role2 => @player2)
+        @context_instance_2 = TestingUseContext.new(:role1 => @player1, :role2 => @player2, :extra_arg => :extra)
       end
 
-      it("You instanciate it...") {@example_context.class.should be(AnotherContext)}
-      it("...providing a hash of type {:rolename1 => player1, ... }") do
-        expect {AnotherContext.new(@player1, @player2)}.to raise_error
+      it("...instanciate it from its correspondig DCI::Context subclass...") {@context_instance_1.should be_a(TestingUseContext)}
+      it("...providing pairs of type :rolekey1 => player1 as arguments...") do
+        expect {TestingUseContext.new(@player1, @player2)}.to raise_error
       end
-      it("...with ALL rolenames as keys...") do
-        expect {AnotherContext.new(:role1 => @player1)}.to raise_error('missing roles role2')
+      it("...with ALL the role_keys in the subclass as keys...") do
+        expect {TestingUseContext.new(:role1 => @player1)}.to raise_error('missing roles role2')
       end
       it("...and the objects to play those roles as values.") do
-        [@player1, @player2].should include(@example_context.role1, @example_context.role2)
+        [@player1, @player2].should include(@context_instance_1.send(:role1).send(:player), @context_instance_1.send(:role2).send(:player))
+      end
+
+      it("...You can also include other extra pairs as arguments...") do
+        expect {TestingUseContext.new(:role1 => @player1, :role2 => @player2, :extra_arg => :extra)}.not_to raise_error
+      end
+
+
+      it("Once instanciated...") {@context_instance_1.should be_a(TestingUseContext)}
+      it("...you call an interaction (instance method) on it") do
+        @context_instance_1.should respond_to(:interaction1)
       end
-      it("Once instanciated...") {@example_context.class.should be(AnotherContext)}
-      it("...you call an interaction (instance method) on it") {@example_context.should respond_to(:interaction1)}
-      it("...to start interaction among roleplayers inside the context") do
-        @example_context.interaction2.should be_instance_of(Fixnum)
+      it("...to start interaction among roleplayers inside the context.") do
+        @context_instance_1.interaction2.should be_instance_of(Fixnum)
       end
 
     end

data/spec/interaction_spec.rb

@@ -1,10 +1,10 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe 'Interaction' do
+describe 'Interaction:' do
 
-  context "Inside a contextmethod(interaction)" do
+  context "Inside a Context instance method(interaction)..." do
     before(:all) do
-      class AnotherContext < Context
+      class TestingInteractionsContext < DCI::Context
         role :role1 do
         end
         role :role2 do
@@ -15,12 +15,23 @@ describe 'Interaction' do
         end
       end
       @player1, @player2 = Object.new, Object.new
-      @example_context = AnotherContext.new(:role1 => @player1, :role2 => @player2)
+      @test_interactions_context = TestingInteractionsContext.new(:role1 => @player1, :role2 => @player2, :extra_arg => :extra)
     end
 
-    it("The developer has access to all the roleplayers...") {@example_context.interaction1.should be(@player1)}
-    it("...named after the rolenames.") {@example_context.methods.should include('role1', 'role2')}
-  end
+    it("...the developer has access to all the roleplayers...") do
+      @test_interactions_context.interaction1.should be_a(TestingInteractionsContext::Role1)
+      @test_interactions_context.send(:role2).should be_a(TestingInteractionsContext::Role2)
+    end
+    it("...via private instance methods named after their role keys.") 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)
+    end
+    it("...through private methods named after their keys.") do
+      @test_interactions_context.private_methods(false).should include('extra_arg')
+    end
+  end
 
 end

data/spec/role_spec.rb

@@ -2,19 +2,32 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe 'Role' do
 
-  context "When defining roles inside a Context subclass..." do
+  context "When defining roles inside a DCI::Context subclass..." do
     before(:all) do
-      class ExampleContext < Context
+      class TestingRoleContext < DCI::Context
         role :rolename do
         end
         role :anotherrolename do
         end
       end
     end
-    it("You can define as many as you want") {ExampleContext.roles.keys.size.should eql(2)}
-    it("Each rolename must be provided as a symbol...") {ExampleContext.roles.keys.should include(:rolename)}
-    it("...and not as a string") {expect {class ExampleContext < Context; role "rolename" do; end; end}.to raise_error}
-    it("A block defining rolemethods can also be provided.") {ExampleContext.roles[:rolename].class.should be(Module)}
+    it("...you can define as many as you want.") do
+      TestingRoleContext.roles.keys.size.should eql(2)
+    end
+    it("Each rolename must be provided as a symbol...") do
+      TestingRoleContext.roles.keys.should include(:rolename, :anotherrolename)
+    end
+    it("...and not as a string.") do
+      expect do
+        class TestingRoleContext < DCI::Context
+          role "rolename" do
+          end
+        end
+      end.to raise_error
+    end
+    it("A block defining rolemethods must be provided as well.") do
+      TestingRoleContext.roles[:rolename].should be_a(Class)
+    end
   end
 
 end

data/spec/roleplayers_spec.rb

@@ -3,18 +3,25 @@ require 'ostruct'
 
 describe 'RolePlayers' do
 
-  context "Are Ruby objects inside a context instance" do
+  context "Are Ruby objects inside a context instance..." do
     before(:all) do
-      class AnotherContext < Context
+      class TestingRoleplayersContext < DCI::Context
         role :role1 do
           def rolemethod1
             :rolemethod1_executed
           end
         end
+
         role :role2 do
           def rolemethod2
             role1
           end
+
+          private
+
+          def private_rolemethod2
+            :public_rolemethod_return_value
+          end
         end
 
         def interaction1
@@ -25,21 +32,45 @@ describe 'RolePlayers' do
           role1.object_id - role2.object_id
         end
       end
-      @player1, @player2 = OpenStruct.new(:field1 => 'value1'), OpenStruct.new(:field2 => 'value2')
-      @example_context   = AnotherContext.new(:role1 => @player1, :role2 => @player2)
+      @player1, @player2 = OpenStruct.new(:name => 'player1'), OpenStruct.new(:name => 'player2')
+      @testing_roleplayers_context = TestingRoleplayersContext.new(:role1 => @player1, :role2 => @player2)
+    end
+
+    it("...each one instance of the class defined after the role he plays...") do
+      @testing_roleplayers_context.send(:role1).should be_a(TestingRoleplayersContext::Role1)
+      @testing_roleplayers_context.send(:role2).should be_a(TestingRoleplayersContext::Role2)
+    end
+    it("...so they adquire the public instance methods defined in their role...") do
+      @testing_roleplayers_context.send(:role1).public_methods(false).should include('rolemethod1')
+      @testing_roleplayers_context.send(:role1).should respond_to(:rolemethod1)
+      @testing_roleplayers_context.send(:role1).rolemethod1.should eql(:rolemethod1_executed)
+    end
+    it("...as well as the private ones.") do
+      @testing_roleplayers_context.send(:role2).private_methods(false).should include('private_rolemethod2')
+      @testing_roleplayers_context.send(:role2).should_not respond_to(:private_rolemethod2)
+      @testing_roleplayers_context.send(:role2).send(:private_rolemethod2).should eql(:public_rolemethod_return_value)
     end
 
-    it("that besides their normal behaviour...") do
-      @player1.field1.should eql('value1')
+    it("Also, through the private method #player") do
+      @testing_roleplayers_context.send(:role1).private_methods.should include('player')
     end
-    it("...also respond to the rolemethods defined in their playing role.") do
-      @example_context.role1.rolemethod1.should eql(:rolemethod1_executed)
+    it("...they have access to the original object playing the role...") do
+      @testing_roleplayers_context.send(:role1).send(:player).should be(@player1)
+      @testing_roleplayers_context.send(:role2).send(:player).should be(@player2)
     end
-    it("Roleplayers can access other roleplayers in their context...") do
-      @example_context.role2.rolemethod2.should eql(@example_context.role1)
+    it("...and, therefore, its public interface.") do
+      @testing_roleplayers_context.send(:role1).send(:player).name.should eq('player1')
+      @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))
     end
     it("...and even the context itself.") do
-      @example_context.role2.context.should eql(@example_context)
+      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)
     end
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dci-ruby
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 15
   prerelease: 
   segments: 
-  - 1
+  - 2
   - 0
   - 0
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Lorenzo Tello
@@ -15,105 +15,48 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-10-25 00:00:00 Z
+date: 2013-10-29 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 2
-        version: "2"
-  version_requirements: *id001
   name: rspec
   prerelease: false
-  type: :development
-- !ruby/object:Gem::Dependency 
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 31
-        segments: 
-        - 3
-        - 12
-        version: "3.12"
-  version_requirements: *id002
-  name: rdoc
-  prerelease: false
-  type: :development
-- !ruby/object:Gem::Dependency 
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 1
-        - 0
-        - 0
-        version: 1.0.0
-  version_requirements: *id003
-  name: bundler
-  prerelease: false
-  type: :development
-- !ruby/object:Gem::Dependency 
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 63
-        segments: 
-        - 1
-        - 8
-        - 4
-        version: 1.8.4
-  version_requirements: *id004
-  name: jeweler
-  prerelease: false
-  type: :development
-- !ruby/object:Gem::Dependency 
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
       - !ruby/object:Gem::Version 
         hash: 3
         segments: 
+        - 2
         - 0
-        version: "0"
-  version_requirements: *id005
-  name: rcov
-  prerelease: false
+        version: "2.0"
   type: :development
+  version_requirements: *id001
 description: Make DCI paradigm available to Ruby applications
-email: ltello8a@gmail.com
+email: 
+- ltello8a@gmail.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- LICENSE.txt
-- README.rdoc
+extra_rdoc_files: []
+
 files: 
 - .document
+- .gitignore
 - .rspec
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.rdoc
 - Rakefile
-- VERSION
 - dci-ruby.gemspec
 - examples/money_transfer.rb
 - lib/dci-ruby.rb
+- lib/dci-ruby/dci/context.rb
+- lib/dci-ruby/dci/role.rb
 - lib/dci-ruby/kernel.rb
+- lib/dci-ruby/version.rb
 - spec/context_spec.rb
 - spec/interaction_spec.rb
 - spec/role_spec.rb
@@ -147,10 +90,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: "0"
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: dci-ruby
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Make DCI paradigm available to Ruby applications by enabling developers defining contexts suclassing the new class Context. You define roles inside the definition. Match roles and player objects in context instanciation.
-test_files: []
-
+summary: Make DCI paradigm available to Ruby applications by enabling developers defining contexts subclassing the class DCI::Context. You define roles inside the definition. Match roles and player objects in context instantiation.
+test_files: 
+- spec/context_spec.rb
+- spec/interaction_spec.rb
+- spec/role_spec.rb
+- spec/roleplayers_spec.rb
+- spec/spec_helper.rb

data/VERSION

@@ -1 +0,0 @@
-1.0.0