rietveld 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0f831ee5bab34effe5e45935530fa692b5148d03
+  data.tar.gz: 7249be7df3e42e3a8cc62872ea36c3ec8dfad061
+SHA512:
+  metadata.gz: 5bb4ddb9985c21de6e899c26f6f2e4f6f2dbeb383bf73a65bd9490612a04292c5eaed5fe36c555ca267d7621877dee9a2443f53055eebc13fdf49895666f86f7
+  data.tar.gz: fa16fccfea98bc912b3601b6862ab6edec15369d15b72bb04fdc3060c5944bbb31b1d36311df7ad86b9307f30dac6ac726eacd53a6bf145ab97aaab62ecbef53

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 progress

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Marten Schilstra
+
+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,13 @@
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rietveld'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rietveld

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/rietveld/context.rb

@@ -0,0 +1,32 @@
+module Rietveld
+  class Context
+    class << self
+      def roles
+        @roles ||= {}
+      end
+
+      def role(role_name, &block)
+        roles[role_name] = Class.new(Rietveld::Role, &block)
+
+        define_method(role_name) do
+          instance_variable_get("@#{role_name}")
+        end
+      end
+    end
+
+    def roles
+      self.class.roles
+    end
+
+    def role?(name)
+      roles.key?(name)
+    end
+
+    def initialize(**args)
+      roles.each do |role_name, role_klass|
+        role_object = role_klass.new(args[role_name], self)
+        instance_variable_set("@#{role_name}", role_object)
+      end
+    end
+  end
+end

data/lib/rietveld/role.rb

@@ -0,0 +1,365 @@
+module Rietveld # :nodoc:
+
+  ##
+  # The Role class implements a DCI Role with the Delegator pattern.
+  #
+  # It tries to be as transparent as possible to the object it delegates to. For
+  # instance most BasicObject and Kernel methods are directly forwarded. Though
+  # methods concerning methods and / or instance variables return values from
+  # the delegator and the object it delegates to.
+
+  class Role < BasicObject
+    # Inherit from Basic Object and include Kernel, this is to avoid Rails
+    # injecting unwanted methods into our precious Role class
+    include ::Kernel
+
+    # The object acting out this role
+    attr_accessor :__role_player__
+
+    # Returns the context this role is playing in
+    attr_accessor :__context__
+
+    def initialize(role_player, context = nil)
+      self.__role_player__ = role_player
+      self.__context__     = context
+    end
+
+    # Returns the __role_player__ without its role object wrapping it.
+    def unwrap
+      __role_player__
+    end
+
+    # Returns the class of the role itself
+    alias_method :role_class, :class
+
+    # Gets a method defined on the role itself
+    alias_method :role_method, :method
+
+    # Get an array of methods defined on the role itself
+    alias_method :role_methods, :methods
+
+    # Get an array of protected methods defined on the role itself
+    alias_method :role_protected_methods, :protected_methods
+
+    # Get an array of public methods defined on the role itself
+    alias_method :role_public_methods, :public_methods
+
+    # Get an array of private methods defined on the role itself
+    alias_method :role_private_methods, :private_methods
+
+    # Is the other role equal? to this one
+    alias_method :role_equal?, :equal?
+
+    # Is the other role eql? to this one
+    alias_method :role_eql?, :eql?
+
+    # Get the hash for the role
+    alias_method :role_hash, :hash
+
+    # Gets the instance variables defined on the role itself
+    alias_method :role_instance_variables,         :instance_variables
+
+    # Get an instance variable defined on the role
+    alias_method :role_instance_variable_get,      :instance_variable_get
+
+    # Set an instance variable defined on the role
+    alias_method :role_instance_variable_set,      :instance_variable_set
+
+    # Remove an instance variable defined on the role
+    alias_method :remove_role_instance_variable,   :remove_instance_variable
+
+    # Is given instance variable defined on the role
+    alias_method :role_instance_variable_defined?, :instance_variable_defined?
+
+    # Get the singleton class of the role
+    alias_method :role_singleton_class,            :singleton_class
+
+    # Gets the singleton methods defined on the role itself
+    alias_method :role_singleton_methods,          :singleton_methods
+
+    # Gets a singleton method defined on the role itself
+    alias_method :role_singleton_method,           :singleton_method
+
+    ##--
+    ## From BasicObject
+    ##++
+
+    # See BasicObject#==, forwarded to __role_player__
+    def ==(other)
+      __role_player__ == other
+    end
+
+    # See BasicObject#equal?, forwarded to __role_player__
+    def equal?(other)
+      __role_player__.equal?(other)
+    end
+
+    # See BasicObject#class, forwarded to __role_player__
+    def class
+      __role_player__.class
+    end
+
+    # See BasicObject#!, forwarded to __role_player__
+    def !
+      !__role_player__
+    end
+
+    # See BasicObject#!=, forwarded to __role_player__
+    def !=(other)
+      __role_player__ != other
+    end
+
+    private
+
+    # See BasicObject#singleton_method_added, forwarded to __role_player__
+    def singleton_method_added(sym)
+      __role_player__.singleton_method_added(sym)
+    end
+
+    # See BasicObject#singleton_method_removed, forwarded to __role_player__
+    def singleton_method_removed(sym)
+      __role_player__.singleton_method_removed(sym)
+    end
+
+    # See BasicObject#singleton_method_undefined, forwarded to __role_player__
+    def singleton_method_undefined(sym)
+      __role_player__.singleton_method_undefined(sym)
+    end
+
+    # If the role itself does not have a given method defined, it will try to
+    # delegate it to the role_player
+    def method_missing(name, *args, &block)
+      if __role_player__.respond_to?(name)
+        __role_player__.__send__(name, *args, &block)
+      elsif __context__.role?(name)
+        __context__.send(name)
+      else
+        super
+      end
+    end
+
+    public
+
+    # True if either role object or role_player responds to given method
+    def respond_to?(name, include_all = false)
+      __role_player__.respond_to?(name, include_all) || super
+    end
+
+    # True if either role object or role_player responds to given missing method
+    def respond_to_missing?(name, include_private = false)
+      __role_player__.respond_to_missing?(name, include_private) || super
+    end
+
+    ##--
+    ## From Kernel
+    ##++
+
+    # See Kernel#nil?, forwarded to __role_player__
+    def nil?
+      __role_player__.nil?
+    end
+
+    # See Kernel#===, forwarded to __role_player__
+    def ===(other)
+      __role_player__ === other
+    end
+
+    # See Kernel#=~, forwarded to __role_player__
+    def =~(other)
+      __role_player__ =~ other
+    end
+
+    # See Kernel#!~, forwarded to __role_player__
+    def !~(other)
+      __role_player__ !~ other
+    end
+
+    # See Kernel#eql?, forwarded to __role_player__
+    def eql?(other)
+      __role_player__.eql?(other)
+    end
+
+    # See Kernel#hash, forwarded to __role_player__
+    def hash
+      __role_player__.hash
+    end
+
+    # See Kernel#<=>, forwarded to __role_player__
+    def <=>(other)
+      __role_player__ <=> other
+    end
+
+    # Returns the class of the __role_player__
+    def class
+      __role_player__.class
+    end
+
+    # Returns the singleton_class of the __role_player__
+    def singleton_class
+      __role_player__.singleton_class
+    end
+
+    # Returns a clone of role object with a clone of the __role_player__
+    def clone
+      role_clone = super
+      role_clone.__role_player__ = __role_player__.clone
+      role_clone
+    end
+
+    # Returns a dup of __role_player__
+    def dup
+      __role_player__.dup
+    end
+
+    # See Kernel#taint, forwarded to __role_player__
+    def taint
+      super
+      __role_player__.taint
+    end
+
+    # See Kernel#tainted?, forwarded to __role_player__
+    def tainted?
+      super || __role_player__.tainted?
+    end
+
+    # See Kernel#untaint, forwarded to __role_player__
+    def untaint
+      super
+      __role_player__.untaint
+    end
+
+    # See Kernel#freeze, forwarded to __role_player__
+    def freeze
+      super
+      __role_player__.freeze
+    end
+
+    # See Kernel#unfreeze, forwarded to __role_player__
+    def unfreeze
+      super || __role_player__.frozen?
+    end
+
+    # See Kernel#to_s, forwarded to __role_player__
+    def to_s
+      __role_player__.to_s
+    end
+
+    # See Kernel#inspect, forwarded to __role_player__
+    #
+    # Returns a string in the form of:
+    #     #<ExampleRole:0x37d837e #<ExampleObject>>
+    def inspect
+      "#<#{role_class.name}:0x#{__id__.to_s(16)} #{__role_player__.inspect}>"
+    end
+
+    # See Kernel#methods, returns the union of the methods from the role object
+    # and __role_player__
+    def methods
+      super | __role_player__.methods
+    end
+
+    # See Kernel#singleton_methods, returns the union of the singleton methods
+    # from the role object and __role_player__
+    def singleton_methods
+      __role_player__.singleton_methods
+    end
+
+    # See Kernel#protected_methods, returns the union of the protected_methods
+    # from the role object and __role_player__
+    def protected_methods
+      super | __role_player__.protected_methods
+    end
+
+    # See Kernel#private_methods, returns the union of the private_methods
+    # from the role object and __role_player__
+    def private_methods
+      super | __role_player__.private_methods
+    end
+
+    # See Kernel#private_methods, returns the union of the private_methods
+    # from the role object and __role_player__
+    def public_methods
+      super | __role_player__.public_methods
+    end
+
+    # See Kernel#instance_variables, returns the union of the instance_variables
+    # from the role object and __role_player__
+    def instance_variables
+      super | __role_player__.instance_variables
+    end
+
+    # See Kernel#instance_variable_get, prefers to return an instance variable
+    # defined on __role_player__, otherwise will lookup instance variables on
+    # role
+    def instance_variable_get(name)
+       __role_player__.instance_variable_get(name) || super
+    end
+
+    # See Kernel#instance_variable_set, prefers to set an instance variable
+    # on __role_player__, if an instance variable with the same name on the role
+    # object is already set, it wil set one on the role.
+    def instance_variable_set(name, value)
+      if role_instance_variable_defined?(name)
+        super
+      else
+        __role_player__.instance_variable_set(name, value)
+      end
+    end
+
+    # See Kernel#instance_variable_defined?, returns true if an instance
+    # variable is defined on either __role_player__ or the role object
+    def instance_variable_defined?(name)
+      super || __role_player__.instance_variable_defined?(name)
+    end
+
+    # See Kernel#remove_instance_variable, if the instance variable is defined
+    # on the role object, it wil remove that one, else it will remove one
+    # defined on __role_player__
+    def remove_instance_variable(name)
+      if role_instance_variable_defined?(name)
+        super
+      else
+        __role_player__.remove_instance_variable(name)
+      end
+    end
+
+    # See Kernel#instance_of?, forwarded to __role_player__
+    def instance_of?(type)
+      __role_player__.instance_of?(type)
+    end
+
+    # See Kernel#kind_of?, forwarded to __role_player__
+    def kind_of?(type)
+      __role_player__.kind_of?(type)
+    end
+
+    # See Kernel#is_a?, forwarded to __role_player__
+    def is_a?(type)
+      __role_player__.is_a?(type)
+    end
+
+    # See Kernel#method, if given method is defined on role object, it will
+    # return that one, otherwise the one from __role_player__
+    def method(name)
+      super
+    rescue
+      __role_player__.method(name)
+    end
+
+    # See Kernel#public_method, if given public_method is defined on role
+    # object, it will return that one, otherwise the one from __role_player__
+    def public_method(name)
+      super
+    rescue
+      __role_player__.public_method(name)
+    end
+
+    # See Kernel#singleton_method, if given singleton_method is defined on role
+    # object, it will return that one, otherwise the one from __role_player__
+    def singleton_method(name)
+      super
+    rescue
+      __role_player__.singleton_method(name)
+    end
+  end
+end

data/lib/rietveld/version.rb

@@ -0,0 +1,3 @@
+module Rietveld
+  VERSION = "1.0.0"
+end

data/lib/rietveld.rb

@@ -0,0 +1,6 @@
+require 'rietveld/version'
+require 'rietveld/role'
+require 'rietveld/context'
+
+module Rietveld
+end

data/rietveld.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rietveld/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rietveld"
+  spec.version       = Rietveld::VERSION
+  spec.authors       = ["Marten Schilstra"]
+  spec.email         = ["mail@martenschilstra.nl"]
+  spec.summary       = %q{
+    A practical implementation of DCI for Ruby
+  }
+  spec.description   = ""
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0.0beta'
+end

data/spec/example_context_specs/money_transfer_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+class BankAccount
+  attr_accessor :balance
+
+  def initialize(initial_balance = 0)
+    self.balance = initial_balance
+  end
+
+  def increase_balance(amount)
+    self.balance += amount
+  end
+
+  def decrease_balance(amount)
+    increase_balance(-amount)
+  end
+end
+
+class MoneyTransferContext < Rietveld::Context
+  role :source_account do
+    def withdraw(amount)
+      if balance >= amount
+        decrease_balance(amount)
+        amount
+      else
+        raise 'Insufficient funds'
+      end
+    end
+
+    def transfer(amount)
+      destination_account.deposit(withdraw(amount))
+    end
+  end
+
+  role :destination_account do
+    def deposit(amount)
+      increase_balance(amount)
+    end
+  end
+
+  def transfer(amount)
+    source_account.transfer(amount)
+  end
+end
+
+
+describe MoneyTransferContext do
+  let(:source_account)      { BankAccount.new(200) }
+  let(:destination_account) { BankAccount.new(100) }
+
+  let(:context) { MoneyTransferContext.new(
+                    source_account: source_account,
+                    destination_account: destination_account) }
+
+  context 'when transfering' do
+    before { context.transfer(50) }
+
+    it 'deposits given amount into destination account' do
+      expect(destination_account.balance).to be(150)
+    end
+
+    it 'withdraws given amount from source account' do
+      expect(source_account.balance).to be(150)
+    end
+  end
+end

data/spec/role_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+class ExampleClass
+  def object_method
+    "object_method"
+  end
+
+  def set_object_instance_variable(val)
+    @object_instance_var = val
+  end
+
+  def get_object_instance_variable
+    @object_instance_var
+  end
+end
+
+class ExampleRole < Rietveld::Role
+  def role_method
+    object_method
+  end
+
+  def set_role_instance_variable(val)
+    @role_instance_var = val
+  end
+
+  def get_role_instance_variable
+    @role_instance_var
+  end
+end
+
+describe Rietveld::Role do
+  let(:object) { ExampleClass.new }
+  let(:role)   { ExampleRole.new(object) }
+
+  context 'straight delegates' do
+    example '#==' do
+      expect(role == object).to be(object == object)
+    end
+
+    example '#equal?' do
+      expect(role.equal?(object)).to be(object.equal?(object))
+    end
+
+    example '#eql?' do
+      expect(role.eql?(object)).to be(object.eql?(object))
+    end
+
+    example '#class' do
+      expect(role.class).to be(object.class)
+      expect(role.class).to be(ExampleClass)
+    end
+  end
+
+  context 'hybrid delegates' do
+    describe '#methods' do
+      it 'should include methods of the role_player' do
+        expect(role.methods).to include(*object.methods)
+      end
+
+      it 'should include methods of the role' do
+        expect(role.methods).to include(*role.role_methods)
+      end
+
+      it 'should be a union of role_player and role methods' do
+        methods = role.role_methods | object.methods
+        expect(role.methods).to contain_exactly(*methods)
+      end
+    end
+  end
+
+  context 'delegation' do
+    it 'delegates to object methods' do
+      expect(role.object_method).to eq(object.object_method)
+    end
+
+    it 'responds to object methods' do
+      expect(role).to respond_to(:object_method)
+    end
+  end
+
+  context 'ivars' do
+    context 'belonging to object' do
+      before { object.set_object_instance_variable('test') }
+
+      it 'has #instance_variable_defined?' do
+        expect(role).to be_instance_variable_defined('@object_instance_var')
+      end
+
+      it 'can access with #instance_variable_get' do
+        expect(role.instance_variable_get('@object_instance_var')).to eq('test')
+      end
+
+      it 'can change with #instance_variable_set' do
+        role.instance_variable_set('@object_instance_var', 'changed')
+        expect(object.get_object_instance_variable).to eq('changed')
+      end
+    end
+
+    context 'belonging to role' do
+      before { role.set_role_instance_variable('test') }
+
+      it 'has #instance_variable_defined?' do
+        expect(role).to be_instance_variable_defined('@role_instance_var')
+      end
+
+      it 'object has not #instance_variable_defined?' do
+        expect(object).to_not be_instance_variable_defined('@role_instance_var')
+      end
+
+      it 'can access with #instance_variable_get' do
+        expect(role.instance_variable_get('@role_instance_var')).to eq('test')
+      end
+
+      it 'can change with #instance_variable_set' do
+        role.instance_variable_set('@role_instance_var', 'changed')
+        expect(role.get_role_instance_variable).to eq('changed')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rietveld'
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: rietveld
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Marten Schilstra
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0beta
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0beta
+description: ''
+email:
+- mail@martenschilstra.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rietveld.rb
+- lib/rietveld/context.rb
+- lib/rietveld/role.rb
+- lib/rietveld/version.rb
+- rietveld.gemspec
+- spec/example_context_specs/money_transfer_spec.rb
+- spec/role_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: A practical implementation of DCI for Ruby
+test_files:
+- spec/example_context_specs/money_transfer_spec.rb
+- spec/role_spec.rb
+- spec/spec_helper.rb