drsi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2e2a89f6f00a413fd3ae85e494e75e0f4bcc4aac
+  data.tar.gz: b44a051e6678c13077ae65a55e8c11ba36530128
+SHA512:
+  metadata.gz: abd2d518e9b8952cfff3d150e323e0c440529aadf51c5dc2d2df388c8e93353d86bdd542faeaaeb276635ca503ce1cfa48b7bc8a43f1a8c94fa3facf18a7fb40
+  data.tar.gz: eae8418a3b0e7949b569cc73a510998d6a7a358ce4836d1548eb5c713b31ee0b79fca8c69cf51b7641c93bfa72c41e547b9edf2bc5393108e7faf01b487ec7aa

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format nested

data/.ruby-gemset

@@ -0,0 +1 @@
+drsi

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in drsi.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Lorenzo Tello
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,100 @@
+# drsi
+
+**_Trygve Reenskaug_**, the parent of MVC, proposes an evolution to traditional OO paradigm: [The DCI Architecture: A New Vision of Object-Oriented Programming](http://www.artima.com/articles/dci_vision.html "The DCI Architecture: A New Vision of Object-Oriented Programming").
+
+This gem makes Data-Context-Interaction paradigm ready to be used in your Ruby application. See also [Data Context Interaction: The Evolution of the Object Oriented Paradigm](http://rubysource.com/dci-the-evolution-of-the-object-oriented-paradigm/ "Data Context Interaction: The Evolution of the Object Oriented Paradigm").
+
+## Installation
+
+Install as usual, either with rubygems
+
+    gem install drsi
+
+or including it in your Gemfile and running bundle install:
+
+    # Gemfile
+    gem "drsi"
+
+    $ bundle install
+
+_**Note**: only **ruby 2.1+** compatible._
+
+
+## Usage
+
+dci-ruby gives you the class DCI::Context to inherit from to create your own contexts:
+
+    class MoneyTransfer < DCI::Context
+
+      # Roles
+
+      role :source_account do
+        def transfer(amount)
+          self.balance -= amount
+          target_account.get_transfer(amount)
+        end
+      end
+
+      role :target_account do
+        def get_transfer(amount)
+          self.balance += amount
+        end
+      end
+
+
+      # Interactions
+
+      def run(amount = settings(:amount))
+        source_account.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 use 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:
+
+    MoneyTransfer.new(:source_account => Account.new(1),
+                      :target_account => Account.new(2)).run(100)
+
+or the short preferred way:
+
+    MoneyTransfer[:source_account => Account.new(1),
+                  :target_account => Account.new(2),
+                  :amount         => 100]
+
+Inside a context instance, every player object incorporates the behaviour (methods) defined by its role while keeping its own.
+
+The Account instances above are players. They are accesible inside #run through #source_account and #target_account private methods.
+Also, every role player has private access to the rest of role players in the context.
+
+Unlike the Presenter approach in dci-ruby (where the object to play a role and the one inside the context playing it are associated but different), this extending/unextending approach preserves unique identity of objects playing roles.
+
+When instanciating a Context, the extra no-role pairs given as arguments are read-only attributes accessible via #settings:
+
+    MoneyTransfer[:source_account => Account.new(1),
+                  :target_account => Account.new(2),
+                  :amount => 500]
+
+here, :amount is not a player (has no associated role) but is still privately accessible both in the interactions and the roles
+via #settings(:amount).
+
+
+See the [examples](https://github.com/ltello/drsi/tree/master/examples) folder for examples of use and the [drsi-DCI-Sample](https://github.com/ltello/drsi-DCI-Sample) repository for a sample Rails application using DCI through this gem.
+
+Notice how your models and controllers are not overloaded anymore. They are thinner and simpler.
+Also note how now most of the functionality of the system is isolated, totally dry-ied and easily maintainable in the different context classes.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+## Copyright
+
+Copyright (c) 2012, 2013 Lorenzo Tello. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/drsi.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/drsi/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "drsi"
+  gem.version       = Drsi::VERSION
+  gem.authors       = ["Lorenzo Tello"]
+  gem.email         = ["ltello8a@gmail.com"]
+  gem.homepage      = "http://github.com/ltello/drsi"
+  gem.description   = "Make DCI paradigm available to Ruby applications"
+  gem.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. Single Identity approach."
+  gem.licenses      = ["MIT"]
+
+  gem.rubyforge_project = "drsi"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  gem.add_development_dependency "rspec", "~> 2.0"
+  # s.add_runtime_dependency "rest-client"
+
+end

data/examples/money_transfer.rb

@@ -0,0 +1,80 @@
+require 'drsi'
+
+
+class CheckingAccount
+  attr_reader   :account_id, :currency
+  attr_accessor :balance
+
+  def initialize(account_id, initial_balance)
+    @account_id  = account_id
+    b, @currency = initial_balance.split(' ')
+    @balance     = b.to_i
+  end
+end
+
+class Amount
+  attr_reader :quantity, :currency
+
+  def initialize(data)
+    q, @currency = data.split(' ')
+    @quantity    = q.to_i
+  end
+
+  def to_s
+    "#{quantity}#{currency}"
+  end
+end
+
+
+class MoneyTransferContext < DCI::Context
+
+  # Roles Definitions
+
+    role :source_account do
+      def run_transfer
+        self.balance -= amount.quantity
+        puts "\t\tAccount(\##{account_id}) sent #{amount} to Account(\##{target_account.account_id})."
+      end
+    end
+
+    role :target_account do
+      def run_transfer
+        self.balance += amount.quantity
+        puts "\t\tAccount(\##{account_id}) received #{amount} from Account(\##{source_account.account_id})."
+      end
+    end
+
+    role :amount
+
+
+  # Interactions
+
+    def run
+      puts "\nMoney Transfer of #{amount} between Account(\##{source_account.account_id}) and Account(\##{target_account.account_id})"
+      puts "\tBalances Before: #{balances}"
+      source_account.run_transfer
+      target_account.run_transfer
+      puts "\tBalances After:  #{balances}"
+    end
+
+
+  private
+
+    def accounts
+      [source_account, target_account]
+    end
+
+    def balances
+      accounts.map {|account| "#{account.balance}#{account.currency}"}.join(' - ')
+    end
+end
+
+acc1   = CheckingAccount.new(1, '1000 €')
+acc2   = CheckingAccount.new(2, '0 €')
+amount = Amount.new('200 €')
+
+5.times do
+  MoneyTransferContext.new(:source_account => acc1,
+                           :target_account => acc2,
+                           :amount         => amount).run
+end

data/lib/drsi/dci/context.rb

@@ -0,0 +1,170 @@
+require 'drsi/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
+          private :roles
+          assign_unplay_roles_within_klass_instance_methods!(subklass)
+        end
+      end
+
+      # A short way for ContextSubclass.new(players_and_extra_args).run(extra_args)
+      def [](*args)
+        new(*args).run
+      end
+
+
+      private
+
+        # 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_module_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_module_from(rolekey, &block)
+          new_mod_name = rolekey.to_s.split(/\_+/).map(&:capitalize).join('')
+          const_set(new_mod_name, Module.new(&block))
+          const_get(new_mod_name).tap {|mod| mod.send(:extend, ::DCI::Role)}
+        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)
+          private
+          attr_reader 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 mod for each of the other roles in the context.
+        # This method does exactly this.
+        def define_mate_roleplayers_readers_after_newrole(new_rolekey)
+          new_role_mod = roles[new_rolekey]
+          mate_roles   = mate_roles_of(new_rolekey)
+          mate_roles.each do |mate_rolekey, mate_role_mod|
+            mate_role_mod.send(:add_role_reader_for!, new_rolekey)
+            new_role_mod.send(:add_role_reader_for!,  mate_rolekey)
+          end
+        end
+
+        # For a give role key, returns a hash with the rest of the roles (pair :rolekey => role_mod) in the context it belongs to.
+        def mate_roles_of(rolekey)
+          roles.dup.tap do |roles|
+            roles.delete(rolekey)
+          end
+        end
+
+        # Wraps every existing public/protected instance_method of klass (not superclasses methods) to assign roles to
+        # player objects before the execution and to un-assign roles from player objects at the end of execution just
+        # before returning control.
+        # Also inject code to magically do the same to every new method defined in klass.
+        def assign_unplay_roles_within_klass_instance_methods!(klass)
+          klass.instance_methods(false).each do |existing_methodname|
+            assign_unplay_roles_within_klass_instance_method!(klass, existing_methodname)
+          end
+          def klass.method_added(methodname)
+            if not @context_internals and public_method_defined?(methodname)
+              @context_internals = true
+              assign_unplay_roles_within_klass_instance_method!(self, methodname)
+              @context_internals = false
+            end
+          end
+        end
+
+        # Wraps the given klass's methodname to assign/un-assign roles to player objects before and after actual method
+        # execution.
+        def assign_unplay_roles_within_klass_instance_method!(klass, methodname)
+          klass.class_eval do
+            method_object = instance_method(methodname)
+            define_method(methodname) do |*args, &block|
+              players_play_role!
+              method_object.bind(self).call(*args, &block).tap {players_unplay_role!}
+            end
+          end
+        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, *| roles.has_key?(key)}.map {|group| Hash[*group.flatten]}
+      @_players = players
+      @settings = noplayers
+    end
+
+
+    private
+
+      # Private access to the extra args received in the instantiation.
+      # Returns a hash (copy of the instantiation extra args) with only the args included in 'keys' or all of them
+      # when called with no args.
+      def settings(*keys)
+        return @settings.dup if keys.empty?
+        entries = @settings.reject {|k, v| !keys.include?(k)}
+        keys.size == 1 ? entries.values.first : entries
+      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_rolekeys = missing_roles(players)
+        raise "missing roles #{missing_rolekeys}" unless missing_rolekeys.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 players_play_role!
+        roles.keys.each do |rolekey|
+          assign_role_to_player!(rolekey, @_players[rolekey])
+        end
+      end
+
+      # Associates a role to an intended player:
+      #   - The player object is 'extended' with the methods of the role to play.
+      #   - The player get access to the context it is playing.
+      #   - The player get access to the rest of players in its context through instance methods named after their role keys.
+      #   - 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)
+        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!
+          # 'instance_variable_set(:"@#{rolekey}", nil)
+        end
+      end
+
+  end
+end

data/lib/drsi/dci/role.rb

@@ -0,0 +1,18 @@
+module DCI
+  module Role
+
+    private
+
+      def context
+        raise 'This method must be redefined in every module including 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)}
+      end
+
+  end
+end

data/lib/drsi/module.rb

@@ -0,0 +1,28 @@
+class Module
+
+  # Define instance methods delegating execution to the corresponding ones in 'mod'.
+  def __copy_instance_methods_from(mod)
+    [:public_instance_methods, :protected_instance_methods, :private_instance_methods].each do |methods_type|
+      methods = mod.send(methods_type, false).map {|methodname| mod.instance_method(methodname)}
+      type    = methods_type.to_s.split('_').first.to_sym
+      __add_instance_methods(methods, type)
+    end
+  end
+
+
+  private
+
+    # Define instance methods binding to self the unbound ones received in 'methods'.
+    # Also, set their visibility from 'type' (:public, :protected, :private).
+    def __add_instance_methods(methods, type)
+      module_exec(methods, type) do |methods, type|
+        methods.each do |method|
+          define_method(method.name) do |*args, &block|
+            method.bind(self).call(*args, &block)
+          end
+        end
+        send(type, *methods.map(&:name))
+      end
+    end
+
+end

data/lib/drsi/object.rb

@@ -0,0 +1,6 @@
+require 'drsi/rolable'
+
+class Object
+  include Rolable
+end
+

data/lib/drsi/rolable.rb

@@ -0,0 +1,66 @@
+require 'drsi/module'
+
+# This module defines a mechanism to extend and 'unextend' modules in an object.
+#
+# The idea is to provide an object with a heap of extended modules:
+#   the highest ones filled with the methods associated to the roles the object currently plays,
+#   and the lowest ones, clean (no methods) when the object finishes playing roles.
+# reusing the empty ones or adding and extending new ones when it is needed.
+module Rolable
+
+  # Make an object play the role defined as a module in 'mod'
+  def __play_role!(role_klass, context)
+    new_role = __next_empty_role
+    new_role.__copy_instance_methods_from(role_klass)
+    new_role.send(:define_method, :context) {context}
+  end
+
+  # Make an object stop playing the last role it plays, if any.
+  def __unplay_last_role!
+    if role = __last_role
+      methods = role.public_instance_methods(false) + role.protected_instance_methods(false) + role.private_instance_methods(false)
+      methods.each {|name| role.send(:remove_method, name)}
+      @__last_role_index = __last_role_index - 1
+    end
+  end
+
+
+  private
+
+    def __roles
+      @__roles ||= Array.new
+    end
+
+    def __last_role_index
+      @__last_role_index ||= -1
+    end
+
+    def __last_role
+      __roles[__last_role_index]
+    end
+
+    # Returns the highest role module free of methods. If none, creates a new empty module ready to be filled with
+    # role instance methods.
+    def __next_empty_role
+      @__last_role_index = __last_role_index + 1
+      __add_empty_role! unless __last_role
+      __last_role
+    end
+
+    # Creates and extends a new module ready to be filled with role instance methods.
+    def __add_empty_role!
+      role = Module.new
+      extend(role)
+      __roles << role
+    end
+
+    # The context a role is played within. This method must be overidden in every __role definition module.
+    def context
+      nil
+    end
+
+    # The role definition code also have private access to the extra args given in the context instantiation.
+    def settings(*keys)
+      context.send(:settings, *keys) if context
+    end
+end

data/lib/drsi/version.rb

@@ -0,0 +1,3 @@
+module Drsi
+  VERSION = "0.0.1"
+end

data/lib/drsi.rb

@@ -0,0 +1,6 @@
+require 'drsi/version'
+require 'drsi/object'
+require 'drsi/dci/context'
+
+module Drsi
+end

data/spec/context_spec.rb

@@ -0,0 +1,117 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe DCI::Context do
+
+  context "Definition:" do
+    context "When Inheriting from DCI::Context..." do
+      before(:all) do
+        class TestingDefinitionContext < DCI::Context
+          role :role_name do
+            def role_name_method
+            end
+          end
+
+          def interaction1
+          end
+        end
+      end
+
+      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.map(&:to_s).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).send(:roles).should eq(:role_name => TestingDefinitionContext::RoleName)
+      end
+      it("... where every ContextSubclass::Rolekey is a new module created at load time,...") do
+        TestingDefinitionContext.roles[:role_name].should be_a(Module)
+        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.map(&:to_s).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).map(&:to_s).should include('interaction1')
+      end
+    end
+  end
+
+  context "Use:" do
+    context "To use a Context..." do
+      before(:all) do
+        class TestingUseContext < DCI::Context
+          role :role1 do
+            def role1_method
+              :role1_method
+            end
+          end
+          role :role2 do
+          end
+
+          def run
+            role1.role1_method
+          end
+
+          def interaction2
+            role1
+          end
+
+          def interaction3
+            role1.object_id - role2.object_id
+          end
+        end
+        @player1, @player2 = Object.new, Object.new
+        @context_instance_1 = TestingUseContext.new(:role1 => @player1, :role2 => @player2)
+        @context_instance_2 = TestingUseContext.new(:role1 => @player1, :role2 => @player2, :extra_arg => :extra)
+      end
+
+      it("...instanciate it from its correspondig DCI::Context subclass as usual...") do
+        @context_instance_1.should be_a(TestingUseContext)
+      end
+      it("...providing pairs of type :rolekey1 => player1 as arguments...") do
+        expect {TestingUseContext.new(@player1, @player2)}.to raise_error
+      end
+      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
+        @context_instance_1.interaction2
+        [@player1, @player2].should include(@context_instance_1.send(:role1), @context_instance_1.send(:role2))
+      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("A shorter way to instantiate a context is through the class method []...") do
+        expect {TestingUseContext[:role1 => @player1, :role2 => @player2, :extra_arg => :extra]}.not_to raise_error
+      end
+      it("...which is equivalent to create a new instance and call #run on it.") do
+        TestingUseContext[:role1 => @player1, :role2 => @player2].should be(:role1_method)
+      end
+
+
+      it("Once instantiated...") {@context_instance_1.should be_a(TestingUseContext)}
+      it("...you call an interaction (instance method) on it") do
+        @context_instance_1.should respond_to(:interaction2)
+      end
+      it("...to start interaction among roleplayers inside the context.") do
+        @context_instance_1.interaction3.should be_instance_of(Fixnum)
+      end
+
+    end
+  end
+
+end

data/spec/interaction_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'Interaction:' do
+
+  context "Inside a Context instance method(interaction)..." do
+    before(:all) do
+      class TestingInteractionsContext < DCI::Context
+        role :role1 do
+        end
+        role :role2 do
+        end
+
+        def interaction1
+          role1
+        end
+      end
+      @player1, @player2 = Object.new, Object.new
+      @test_interactions_context = TestingInteractionsContext.new(:role1 => @player1,
+                                                                  :role2 => @player2,
+                                                                  :setting1 => :one,
+                                                                  :setting2 => :two,
+                                                                  :setting3 => :three)
+    end
+
+    it("...the developer has access to all the roleplayers...") do
+      @test_interactions_context.interaction1.should be(@player1)
+      @test_interactions_context.send(:role2).should be(@player2)
+    end
+    it("...via private instance methods named after their role keys.") do
+      @test_interactions_context.private_methods(false).map(&:to_s).should include('role1', 'role2')
+    end
+
+    it("He also have private access to extra args received in the instantiation of its context...") do
+      @test_interactions_context.private_methods.map(&:to_s).should include('settings')
+      @test_interactions_context.public_methods.map(&:to_s).should_not include('settings')
+    end
+    it("...calling #settings that returns a hash with all the extra args...") do
+      @test_interactions_context.send(:settings).should eq({:setting1 => :one, :setting2 => :two, :setting3 => :three})
+    end
+    it("...or #settings(key) that returns the value of the given extra arg...") do
+      @test_interactions_context.send(:settings, :setting2).should be(:two)
+    end
+    it("...or #settings(key1, key2, ...) that returns a hash with the given extra args.") do
+      @test_interactions_context.send(:settings, :setting1, :setting3).should eq({:setting1 => :one, :setting3 => :three})
+    end
+  end
+
+end

data/spec/players_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+# require 'ostruct'
+
+
+describe 'Players:' do
+
+  class CheckingAccount
+    attr_reader   :account_id
+    attr_accessor :balance
+
+    def initialize(account_id, initial_balance=0)
+      @account_id, @balance = account_id, initial_balance
+    end
+  end
+
+
+  class MoneyTransferContext < DCI::Context
+
+    # Roles Definitions
+      role :source_account do
+        def run_transfer_of(amount)
+          self.balance -= amount
+        end
+      end
+
+      role :target_account do
+        def run_transfer_of(amount)
+          self.balance += amount
+        end
+      end
+
+    # Interactions
+      def run(amount=settings(:amount))
+        source_account.run_transfer_of(amount)
+        target_account.run_transfer_of(amount)
+        balances
+      end
+
+    private
+      def accounts
+        [source_account, target_account]
+      end
+
+      def balances
+        accounts.map(&:balance)
+      end
+  end
+
+  context "Are common Ruby objects that play roles inside contexts:" do
+    before(:all) do
+      @account1 = CheckingAccount.new(1, 1000)
+      @account2 = CheckingAccount.new(2)
+      @account1_public_interface = @account1.public_methods
+    end
+
+    context "Before becoming roleplayers inside a context..." do
+      it("...they are in an initial state...") do
+        @account1.balance.should be(1000)
+        @account2.balance.should be(0)
+      end
+      it("...and have got a given public interface.") do
+        @account1_public_interface.should be_true
+      end
+    end
+
+    context "After playing a role inside a context..." do
+      before(:all) do
+        MoneyTransferContext.new(:source_account => @account1,
+                                 :target_account => @account2).run(200)
+      end
+      it("...they still preserve their public interface...") do
+        @account1.public_methods.should eql(@account1_public_interface)
+        @account1.should_not respond_to(:run_transfer_of)
+        @account1.private_methods.should_not include(:run_transfer_of)
+      end
+      it("...although their state might have been changed!") do
+        @account1.balance.should_not be(1000)
+        @account2.balance.should_not be(0)
+      end
+    end
+  end
+
+end

data/spec/role_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+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
+      end
+    end
+    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(Module)
+    end
+  end
+
+end

data/spec/roleplayers_spec.rb

@@ -0,0 +1,107 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'ostruct'
+
+describe 'RolePlayers' do
+
+  context "Are Ruby objects inside a context instance..." 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_role_interaccess; role2.role2method1 == role1 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 check_role2_identity(obj)
+          [role2 == obj, role2.role2self == obj, role2.respond_to?(:role2method1), obj.respond_to?(:role2method1),
+           role2.send(:private_role2method2) == :private_rolemethod_return_value,
+           obj.send(:private_role2method2)   == :private_rolemethod_return_value,
+           role2.role2method1 == role1, obj.role2method1 == role1].uniq == [true]
+        end
+
+        def access_role1_external_interface
+          role1.name
+        end
+
+        def check_role1_context_access
+          role1.context == self
+        end
+
+        def check_role1_settings_access
+         [!role1.respond_to?(:settings), role1.private_methods.map(&:to_s).include?('settings'),
+          role1.send(:settings) == settings].uniq == [true]
+        end
+      end
+
+      @player1, @player2 = OpenStruct.new(:name => 'player1'), OpenStruct.new(:name => 'player2')
+      @testing_roleplayers_context = TestingRoleplayersContext.new(:role1    => @player1,
+                                                                   :role2    => @player2,
+                                                                   :setting1 => :one,
+                                                                   :setting2 => :two,
+                                                                   :setting3 => :three)
+    end
+
+    it("...that adquire the public instance methods defined in their role...") do
+      @testing_roleplayers_context.check_role1_identity(@player1).should be_true
+    end
+    it("...as well as the private ones.") do
+      @testing_roleplayers_context.check_role2_identity(@player2).should be_true
+    end
+
+    it("They still preserve their identity") do
+      @testing_roleplayers_context.check_role1_identity(@player1).should be_true
+    end
+    it("...and therefore, their state and behaviour are accessible inside the context.") do
+      @testing_roleplayers_context.access_role1_external_interface.should eq('player1')
+    end
+
+    it("Inside the context, roleplayers have private access to other roleplayers through methods named after their keys.") do
+      @testing_roleplayers_context.check_role_interaccess.should be_true
+    end
+    it("...and offer a public_method to access the context.") do
+      @testing_roleplayers_context.check_role1_context_access.should be_true
+    end
+
+    it("They also have private access to extra args received in the instantiation of its context...") do
+      @testing_roleplayers_context.check_role1_settings_access.should be_true
+    end
+    it("...calling #settings that returns a hash with all the extra args...") do
+      @testing_roleplayers_context.send(:settings).should eq({:setting1 => :one, :setting2 => :two, :setting3 => :three})
+    end
+    it("...or #settings(key) that returns the value of the given extra arg...") do
+      @testing_roleplayers_context.send(:settings, :setting2).should be(:two)
+    end
+    it("...or #settings(key1, key2, ...) that returns a hash with the given extra args.") do
+      @testing_roleplayers_context.send(:settings, :setting1, :setting3).should eq({:setting1 => :one, :setting3 => :three})
+    end
+
+    it("But all these features, are only inside a context. Never out of it!") do
+      @player1.should_not respond_to(:role1method1)
+      @player2.private_methods.map(&:to_s).should_not include(:private_role2method2)
+      @player1.name.should eq('player1')
+      @player2.should_not respond_to(:role1)
+      @player2.should_not respond_to(:context)
+      @player1.should_not respond_to(:settings)
+      @player1.private_methods.map(&:to_s).should include('settings')
+      @player1.send(:settings).should be_nil
+    end
+
+
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'drsi'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: drsi
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Lorenzo Tello
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Make DCI paradigm available to Ruby applications
+email:
+- ltello8a@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- drsi.gemspec
+- examples/money_transfer.rb
+- lib/drsi.rb
+- lib/drsi/dci/context.rb
+- lib/drsi/dci/role.rb
+- lib/drsi/module.rb
+- lib/drsi/object.rb
+- lib/drsi/rolable.rb
+- lib/drsi/version.rb
+- spec/context_spec.rb
+- spec/interaction_spec.rb
+- spec/players_spec.rb
+- spec/role_spec.rb
+- spec/roleplayers_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/ltello/drsi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: drsi
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+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. Single Identity approach.
+test_files:
+- spec/context_spec.rb
+- spec/interaction_spec.rb
+- spec/players_spec.rb
+- spec/role_spec.rb
+- spec/roleplayers_spec.rb
+- spec/spec_helper.rb