bandy-dci 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 30ad5219182fae98adeba5f1eb7880047078001f
+  data.tar.gz: 2284100d33e40d98f2ed53b5fa9b1647f9178ae8
+SHA512:
+  metadata.gz: 6d033acd944220f29b6c200200c84a49b44f0897f26c8e3d4dd48d663c334671b80cce044cac713bb8a6864b7acfb4ab8e2a40de1e8f920960ccc2157f9e6561
+  data.tar.gz: b6b61532643781f831dc46dffd1bff8482e629a2624435810a030de9423eac256ebf2483af4b1e8ed503a6dc48354f03e945fea5e3f584c631c1d5b94f109f2a

data/lib/dci.rb

@@ -0,0 +1,4 @@
+module DCI
+end
+
+require 'dci/context'

data/lib/dci/castable.rb

@@ -0,0 +1,49 @@
+require 'dci/context'
+
+module DCI
+  module Castable
+    def self.module_method_rebinding?
+      sample_method = Enumerable.instance_method(:to_a)
+      begin
+        !!sample_method.bind(Object.new)
+      rescue TypeError
+        false
+      end
+    end
+
+    private
+
+    if module_method_rebinding?
+      def delegated_method(role, method)
+        role.instance_method(method)
+      end
+    else
+      def delegated_method(role, method)
+        clone.extend(role).method(method).unbind
+      end
+    end
+
+    def method_missing(method, *arguments, &block)
+      role = participating_role_with_method(method)
+      role ? delegated_method(role, method).bind(self).call(*arguments, &block) : super
+    end
+
+    def participating_role_with_method(method)
+      context = DCI::Context.current
+      return unless context
+
+      roles = context[self]
+      return unless roles
+
+      roles.find do |role|
+        role.public_instance_methods.include?(method) ||
+          role.protected_instance_methods.include?(method) ||
+          role.private_instance_methods.include?(method)
+      end
+    end
+
+    def respond_to_missing?(method, include_private)
+      !!participating_role_with_method(method) || super
+    end
+  end
+end

data/lib/dci/context.rb

@@ -0,0 +1,99 @@
+require 'dci/castable'
+
+module DCI
+  module Context
+    # The currently executing context
+    def self.current
+      Thread.current[:'DCI::Context.current']
+    end
+
+    def self.included(calling_module)
+      calling_module.extend(DSL)
+    end
+
+    def cast(actor, roles)
+      actor.extend(Castable) unless actor.is_a?(Castable)
+
+      @roles ||= {}
+      @roles[actor] ||= []
+      @roles[actor] |= roles.values
+
+      actor
+    end
+
+    def [](actor)
+      @roles && @roles[actor]
+    end
+
+    module DSL
+      private
+
+      # Replace an existing method with a wrapper that advertises the current context
+      def define_entry_using_method(name)
+        method = instance_method(name)
+        define_method(name) do |*arguments, &block|
+          begin
+            # Swap out the currently executing context
+            Thread.current[:'DCI::Context.current'], old_context = self, Thread.current[:'DCI::Context.current']
+            method.bind(self).call(*arguments, &block)
+          ensure
+            # Reinstate the previously executing context
+            Thread.current[:'DCI::Context.current'] = old_context
+          end
+        end
+      end
+
+      # Create a method that executes the provided definition while advertising the current context
+      def define_entry_using_proc(name, definition)
+        define_method(name, &definition)
+        define_entry_using_method(name)
+      end
+
+      # Define a context entry point
+      def entry(name, proc = nil, &block)
+        if block_given?
+          define_entry_using_proc(name, block)
+        elsif proc.respond_to?(:to_proc)
+          define_entry_using_proc(name, proc)
+        elsif method_defined?(name)
+          define_entry_using_method(name)
+        else
+          @entries ||= []
+          @entries |= [name]
+        end
+      end
+
+      # Listen for new methods that are intended to be entry points
+      def method_added(name)
+        if @entries && @entries.delete(name)
+          define_entry_using_method(name)
+        end
+      end
+
+      # Define a context role
+      def role(name, *args, &block)
+        attr_reader name
+        public name
+
+        if block_given?
+          role_module = Module.new
+          role_module.module_eval(&block)
+
+          define_method("#{name}=") do |actor|
+            instance_variable_set("@#{name}", cast(actor, :as => role_module))
+          end
+        else
+          attr_writer name
+        end
+
+        protected "#{name}="
+      end
+
+      def trigger(name, delegate, method = name)
+        entry(name) do |*arguments, &block|
+          __send__(delegate).__send__(method, *arguments, &block)
+        end
+      end
+    end
+  end
+end

data/lib/dci/role_lookup.rb

@@ -0,0 +1,13 @@
+require 'dci/context'
+
+module DCI
+  module RoleLookup
+    private
+
+    # Forward references to constants to the currently executing context
+    def const_missing(name)
+      context = DCI::Context.current
+      context.respond_to?(name) ? context.__send__(name) : super
+    end
+  end
+end

data/spec/dci/castable_spec.rb

@@ -0,0 +1,77 @@
+require 'dci/castable'
+
+describe DCI::Castable do
+  let(:something) { Class.new { include DCI::Castable; def greet; 'hello'; end } }
+  subject(:actor) { something.new }
+
+  context 'when the actor is not participating in the current context' do
+    specify 'calling a nonexistent method raises NoMethodError' do
+      expect { actor.smile }.to raise_error(NoMethodError)
+    end
+
+    specify 'calling an implemented method works' do
+      expect(actor.greet).to eq 'hello'
+    end
+  end
+
+  context 'when the actor is participating in the current context' do
+    let(:context_participants) { { actor => [role] } }
+    let(:role) { Module.new }
+
+    before do
+      allow(DCI::Context).to receive(:current).and_return(context_participants)
+    end
+
+    specify 'calling a method implemented by none of its roles raises NoMethodError' do
+      expect(actor).to_not respond_to(:smile)
+      expect { actor.smile }.to raise_error(NoMethodError)
+    end
+
+    context 'when one of its roles implements a public method' do
+      let(:role) { Module.new { def eat; :yum; end } }
+
+      specify 'calling that method works' do
+        expect(actor).to respond_to(:eat)
+        expect(actor.eat).to be :yum
+      end
+    end
+
+    context 'when one of its roles implements a protected method' do
+      let(:role) { Module.new { protected; def eat; :yum; end } }
+
+      specify 'calling that method works' do
+        expect(actor).to respond_to(:eat)
+        expect(actor.eat).to be :yum
+      end
+    end
+
+    context 'when one of its roles implements a private method' do
+      let(:role) { Module.new { private; def eat; :yum; end } }
+
+      specify 'calling that method works' do
+        expect(actor).to respond_to(:eat)
+        expect(actor.eat).to be :yum
+      end
+    end
+
+    context 'when one of its role methods takes arguments' do
+      let(:role) { Module.new { def sing(song); song; end } }
+
+      specify 'calling that method without arguments raises ArgumentError' do
+        expect { actor.sing }.to raise_error(ArgumentError)
+      end
+
+      specify 'calling that method with arguments works' do
+        expect(actor.sing(:song)).to be :song
+      end
+    end
+
+    context 'when one of its role methods takes a block' do
+      let(:role) { Module.new { def sing(&block); block.call; end } }
+
+      specify 'calling that method with a block works' do
+        expect(actor.sing { :song }).to be :song
+      end
+    end
+  end
+end

data/spec/dci/context_spec.rb

@@ -0,0 +1,290 @@
+require 'dci/context'
+
+describe DCI::Context do
+  describe 'role implementations' do
+    let(:context) { Class.new { include DCI::Context } }
+    let(:context_instance) { context.new }
+    let(:participating_roles) { context_instance[role_player] }
+    let(:role_implementation) { Module.new }
+    let(:role_player) { double }
+
+    specify 'are applied using #cast' do
+      context_instance.cast(role_player, :as => role_implementation)
+
+      expect(role_player).to be_a(DCI::Castable)
+      expect(participating_roles).to eq [role_implementation]
+    end
+
+    specify 'are nil when not applied' do
+      expect(participating_roles).to be nil
+    end
+  end
+
+  describe 'role identifiers are defined using ::role' do
+    let(:context) do
+      Class.new do
+        include DCI::Context
+
+        role :One
+
+        def initialize(one)
+          self.One = one
+        end
+      end
+    end
+
+    context 'at runtime' do
+      subject(:context_instance) { context.new(one) }
+      let(:one) { double }
+
+      specify 'role players can be assigned' do
+        expect { context_instance }.to_not raise_error
+      end
+
+      specify 'role players can be accessed' do
+        expect(context_instance.One).to be one
+      end
+    end
+
+    describe 'when passed a block, that block becomes the implementation' do
+      let(:context) do
+        Class.new do
+          include DCI::Context
+
+          role :One do
+            def something
+              :expected
+            end
+          end
+
+          def initialize
+            self.One = Object.new
+          end
+        end
+      end
+
+      let(:context_instance) { context.new }
+      let(:participating_roles) { context_instance[role_player] }
+      let(:role_player) { context_instance.One }
+
+      specify 'it is applied when the role is assigned' do
+        expect(role_player).to be_a DCI::Castable
+        expect(participating_roles).to be_an Array
+        expect(participating_roles.first).to be_a Module
+        expect(participating_roles.first.public_instance_methods).to include :something
+      end
+    end
+  end
+
+  describe 'context entry points are identified using ::entry' do
+    subject(:context_instance) { context.new }
+
+    shared_examples 'correctly manages the currently executing context' do
+      specify 'it assigns the executing context' do
+        context_instance.something { expect(DCI::Context.current).to be context_instance }
+      end
+
+      specify 'it restores the previously executing context' do
+        expect { context_instance.something {} }.to_not change { DCI::Context.current }
+      end
+    end
+
+    context 'when the method exists' do
+      let(:context) do
+        Class.new do
+          include DCI::Context
+
+          def something(&block)
+            block.call
+          end
+
+          entry :something
+        end
+      end
+
+      specify 'it can be called' do
+        expect(context_instance).to respond_to :something
+        expect(context_instance.something { :expected }).to be :expected
+      end
+
+      include_examples 'correctly manages the currently executing context'
+    end
+
+    context 'when the method does not exist' do
+      let(:context) do
+        Class.new do
+          include DCI::Context
+
+          entry :something
+        end
+      end
+
+      specify 'it cannot be called' do
+        expect(context_instance).to_not respond_to :something
+        expect { context_instance.something }.to raise_error(NoMethodError, /something/)
+      end
+
+      context 'once the method is defined' do
+        before do
+          context.class_exec do
+            def something(&block)
+              block.call
+            end
+          end
+        end
+
+        specify 'it can be called' do
+          expect(context_instance).to respond_to :something
+          expect(context_instance.something { :expected }).to be :expected
+        end
+
+        include_examples 'correctly manages the currently executing context'
+      end
+    end
+
+    describe 'when passed a block, that block becomes the definition' do
+      let(:context) do
+        Class.new do
+          include DCI::Context
+
+          entry :point do
+            :expected
+          end
+        end
+      end
+
+      specify 'that can be called' do
+        expect(context_instance).to respond_to :point
+        expect(context_instance.point).to be :expected
+      end
+
+      context 'when the block has parameters' do
+        let(:context) do
+          Class.new do
+            include DCI::Context
+
+            entry :parameters do |argument|
+              argument
+            end
+          end
+        end
+
+        specify 'those parameters are required' do
+          expect { context_instance.parameters }.to raise_error ArgumentError
+        end
+
+        specify 'and can be called with arguments' do
+          expect(context_instance.parameters(:expected)).to be :expected
+        end
+      end
+
+      context 'when the block takes a block' do
+        let(:context) do
+          Class.new do
+            include DCI::Context
+
+            entry :block do |&block|
+              block.call
+            end
+          end
+        end
+
+        specify 'it works' do
+          expect(context_instance.block { :expected }).to be :expected
+        end
+      end
+    end
+
+    describe 'when passed a lambda, that lambda becomes the definition' do
+      let(:context) do
+        Class.new do
+          include DCI::Context
+
+          entry :parameters, ->(argument) do
+            argument
+          end
+        end
+      end
+
+      specify 'that can be called' do
+        expect(context_instance).to respond_to :parameters
+        expect { context_instance.parameters }.to raise_error ArgumentError
+        expect(context_instance.parameters(:expected)).to be :expected
+      end
+    end
+  end
+
+  describe 'use case triggers are identified using ::trigger' do
+    let(:context) do
+      Class.new do
+        include DCI::Context
+        trigger :trigger_name, :RoleName, :method_name
+      end
+    end
+    let(:context_instance) { context.new }
+
+    specify 'the trigger is callable' do
+      expect(context_instance).to respond_to :trigger_name
+    end
+
+    context 'when the role does not exist' do
+      specify 'calling the trigger raises a NoMethodError' do
+        expect { context_instance.trigger_name }.to raise_error(NoMethodError, /RoleName/)
+      end
+    end
+
+    context 'when the role method does not exist' do
+      before { context.class_eval { role :RoleName } }
+
+      specify 'calling the trigger raises a NoMethodError' do
+        expect { context_instance.trigger_name }.to raise_error(NoMethodError, /method_name/)
+      end
+    end
+
+    context 'when the role and method exist' do
+      before do
+        context.class_eval do
+          role :RoleName do
+            def method_name(&block)
+              block.call
+            end
+          end
+
+          def initialize
+            self.RoleName = Object.new
+          end
+        end
+      end
+
+      specify 'it can be called' do
+        expect(context_instance.trigger_name { :expected }).to be :expected
+      end
+
+      specify 'it assigns the executing context' do
+        context_instance.trigger_name { expect(DCI::Context.current).to be context_instance }
+      end
+
+      specify 'it restores the previously executing context' do
+        expect { context_instance.trigger_name {} }.to_not change { DCI::Context.current }
+      end
+    end
+
+    context 'with two arguments' do
+      let(:context) do
+        Class.new do
+          include DCI::Context
+
+          trigger :trigger_name, :RoleName
+        end
+      end
+      let(:role_player) { double }
+
+      before { allow(context_instance).to receive(:RoleName).and_return(role_player) }
+
+      specify 'the method defaults to trigger name' do
+        expect(role_player).to receive :trigger_name
+        context_instance.trigger_name
+      end
+    end
+  end
+end

data/spec/dci/role_lookup_spec.rb

@@ -0,0 +1,119 @@
+require 'dci/role_lookup'
+
+describe DCI::RoleLookup do
+  context 'when roles are lowercase' do
+    class LowercaseContext
+      include DCI::Context
+      extend DCI::RoleLookup
+
+      role :one
+      role :two do
+        def access_one
+          one
+        end
+      end
+
+      entry :access_one_from_two do
+        two.access_one
+      end
+
+      def initialize
+        self.one = Object.new
+        self.two = Object.new
+      end
+    end
+
+    let(:context_instance) { LowercaseContext.new }
+
+    specify 'role lookup does not work' do
+      expect { context_instance.access_one_from_two }.to raise_error(NameError, /undefined.*one/)
+    end
+  end
+
+  context 'when roles are capitalized' do
+    context 'in an anonymous module' do
+      let(:context) do
+        Class.new do
+          include DCI::Context
+          extend DCI::RoleLookup
+
+          role :One
+
+          entry :access_one do
+            One
+          end
+        end
+      end
+
+      let(:context_instance) { context.new }
+
+      specify 'role lookup does not work' do
+        expect { context_instance.access_one }.to raise_error(NameError, /One/)
+      end
+    end
+
+    context 'in a named module' do
+      class NamedContext
+        include DCI::Context
+        extend DCI::RoleLookup
+
+        role :One
+        role :Two
+        role :Three do
+          def access_one
+            One
+          end
+        end
+
+        module TwoMethods
+          extend DCI::RoleLookup
+
+          def access_one
+            One
+          end
+        end
+
+        entry :access_one_from_two do
+          Two.access_one
+        end
+
+        entry :access_one_from_three do
+          Three.access_one
+        end
+
+        def initialize(one)
+          self.One = one
+          self.Two = cast(Object.new, :as => TwoMethods)
+          self.Three = Object.new
+        end
+      end
+
+      let(:context_instance) { NamedContext.new(one) }
+      let(:one) { double }
+
+      specify 'role lookup works' do
+        expect(context_instance.access_one_from_two).to be == one
+        expect(context_instance.access_one_from_three).to be == one
+      end
+
+      specify 'those roles cannot be referenced by a later executing context' do
+        class FirstContext
+          include DCI::Context
+          role :One
+          entry :call do
+            SecondContext.new.call
+          end
+        end
+
+        class SecondContext
+          include DCI::Context
+          entry :call do
+            One
+          end
+        end
+
+        expect { FirstContext.new.call }.to raise_error(NameError, /One/)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: bandy-dci
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Chris Bandy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '2.14'
+description: Facilitate DCI in Ruby
+email:
+- bandy.chris@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dci.rb
+- lib/dci/castable.rb
+- lib/dci/context.rb
+- lib/dci/role_lookup.rb
+- spec/dci/castable_spec.rb
+- spec/dci/context_spec.rb
+- spec/dci/role_lookup_spec.rb
+homepage: https://github.com/cbandy/ruby-dci
+licenses:
+- Apache License Version 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: DCI
+test_files:
+- spec/dci/castable_spec.rb
+- spec/dci/context_spec.rb
+- spec/dci/role_lookup_spec.rb