wrapper_based 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a512a58ee3c31a5d96debe8d835854faa1b05d1d
-  data.tar.gz: 0cb617aec6443efcb7972c5d015d43d4533f2918
+  metadata.gz: c9905f3b4631008847a1ea6998fc79ce2d186727
+  data.tar.gz: bf443b8da55d7e0c32b7cdb99e09a8d47b585901
 SHA512:
-  metadata.gz: 70e62a920819ba82bd6396b3849258e83177a8b99ba3b4d74548f71af68b4714012926e2cc904d101860da8b5dc982b2c2bd7c3bf24b9e0ae4ca3d6b6da192ce
-  data.tar.gz: 318f1a9ab51099e22f5e4234161ccd24931aba3067f24eedcc1ed6b593ea6b6b4e7843fe3f270379a0191322b9d622bcb37b3b8f56aa097aae623ce10c6b75e4
+  metadata.gz: 2f5bc3f9544c492ed7a5307f3b5a57463e8ef12dcb9972998da421298ecc528e3f215097d33bf8cdc8ebb1275980ee32a77f70d908bec84ea22fbc08d6f89ec2
+  data.tar.gz: 9b42afaff1621d74441b3373ce7879bc2d167959b3fcdea5b7d46d6562a2df02395261b1591406a8f567596ef07daccfc1bc2a580ff359fd6ba072b281155be1

data/.gitignore

@@ -8,3 +8,5 @@
 /spec/reports/
 /tmp/
 *.gem
+.gitignore
+.ruby-version

data/.travis.yml

@@ -1,7 +1,7 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.1.0
+  - 2.1.2
   - 2.2.0
   - 2.3.0
   - 2.4.0

data/README.md

@@ -17,88 +17,137 @@ And then execute:
 
     $ bundle
 
-## Usage
+## DCI::Roles
 
-[Dijkstra data](https://github.com/RichOrElse/wrapper-based/blob/master/examples/dijkstra/data.rb) | 
-[Dijkstra test](https://github.com/RichOrElse/wrapper-based/blob/master/test/dijkstra_test.rb) | 
-Djikstra example:
+Includes role components to classes.
+
+### Usage
 
 ```ruby
-module DestinationNode
-  def shortest_path_from(neighbor, find_shortest)
-    return [self] if equal? neighbor
-    find_shortest.path(from: neighbor)
+class ApplicationController
+  include DCI::Roles(:current_user, logged: SignsUser)
+
+  before_action -> { with! logged: session }
+  helper_method :logged, :current_user
+  
+  private
+
+  def authenticate_user!
+    if logged.out?
+      flash[:error] = "You must be logged in to access this section"
+      redirect_to login_url
+    else
+      with_current_user! logged.user
+    end
   end
 end
 
-Map = DCI::Module.new do |mod| using mod
-  def distance_between(a, b)
-    @distances[Edge.new(a, b)]
-  end
+class LoginController < ApplicationController
+  include DCI::Roles(signing: SignsUser, user_params: UserParams, login: HasEncryptedPassword)
+
+  before_action -> { with! signing: session, user_params: params.require(:user) }
+  before_action -> { with! login: signing.by(user_params.login) }
 
-  def distance_of(path)
-    path.each_cons(2).inject(0) { |total, (to, from)| total + distance_between(from, to) }
+  def new; end
+
+  def create
+    if login.authenticate(user_params.password)
+      signing.in! login
+      redirect_to login, notice: 'Welcome, you are now logged in.'
+    else
+      flash[:danger] = 'Invalid credentials.'
+      render :new, status: :unauthorized
+    end
   end
+end
+
+class LogoutController < ApplicationController
+  include DCI::Roles(signing: SignsUser)
 
-  def neighbors(near:)
-    [south_neighbor_of(near), east_neighbor_of(near)].compact # excludes nil neighbors
+  before_action -> { with! signing: session }
+
+  def destroy
+    signing.out!
+    redirect_to root_url
   end
 end
 
-class FindShortest < DCI::Context(:from, to: DestinationNode, city: Map)
-  def initialize(city:, from: city.root, to: city.destination) super end
+class SignsUser < Struct.new(:signed)
+  def in!(user)
+    signed[:user_id] = user.id
+  end
 
-  def distance
-    city.distance_of path
+  def out!
+    signed.delete(:user_id)
+    @user = nil
   end
 
-  def path(from: @from)
-    shortest_neighbor_path(from) << from
+  def out?
+    signed[:user_id].nil? || in?
   end
 
-  private
+  def in?
+    !user.nil?
+  end
 
-  def shortest_neighbor_path(current)
-    city.neighbors(near: current).
-      map { |neighbor| to.shortest_path_from(neighbor, self) }.
-      min_by { |neighbor_path| city.distance_of neighbor_path }
+  def user
+    @user ||= by(id: signed[:user_id])
   end
-end
-```
 
-[View more examples](https://github.com/RichOrElse/wrapper-based/tree/master/examples)
+  def by(**identification)
+    User.find_by identification
+  end
 
-## Context methods
+  def with(**credentials)
+    User.new credentials
+  end
 
-### context#to_proc
+  def up!(user)
+    user.save && user if User.validate_registering(user)
+  end
+end
 
-Returns call method as a Proc.
+module UserParams
+  def registration
+    permit(:username, :email)
+  end
 
-```ruby
-['Card Wars', 'Ice Ninja Manual', 'Bacon'].map &GiftToy[gifter: 'Jake', giftee: 'Finn']
+  def login
+    permit(:username, :email)
+  end
+
+  def security
+    permit(:password, :password_confirmation, :code)
+  end
+
+  def password
+    self[:password]
+  end
+end
 ```
 
-### context[params,...]
+## DCI::Context
 
-Square brackets are alias for call method.
+### Usage
 
 ```ruby
-TransferMoney[from: source_account, to: destination_account][amount: 100]
+class GiftToy < DCI::Context(:toy, gifter: Buyer, giftee: Recipient)
+  def call(toy = @toy)
+    gift = gifter.buy 
+    giftee.receive gift 
+  end
+end
 ```
 
-### context#rebind(**params)
-Assigns object to role.
+#### Context#to_proc
+
+Returns call method as a Proc.
 
 ```ruby
-add_member = Evaluate.new(to: 'Justice League')
-['Batman', Superman', 'Wonder Woman'].each do |founder|
-  add_member.rebind(member: founder).(recruit: 'Supergirl')
-end
+['Card Wars', 'Ice Ninja Manual', 'Bacon'].map &GiftToy[gifter: 'Jake', giftee: 'Finn']
 ```
 
-## Context class methods
-
-### klass#call(**params)
+#### Context::call
 
 A shortcut for instantiating the context by passing the collaborators and then executing the context call method.
 
@@ -112,21 +161,15 @@ Which is equivalent to:
 Funds::TransferMoney.new(from: @account1, to: @account2, amount: 50).call
 ```
 
-## DCI::Module
-
-Extention module for supporting procedural code. Define a block with the 'new' method and pass the 'mod' parameter to 'using' keyword.
-
-```ruby
-AwesomeSinging = TypeWrapper::Module.new do |mod| using mod
-  def sing
-    "#{name} sings #{song}"
-  end
-
-  def song
-    "Everything is AWESOME!!!"
-  end
-end
-```
+## Context Examples
+[Money Transfer](examples/money_transfer.rb) | 
+[Djikstra](examples/djikstra.rb) | 
+[Toy Shop](examples/toy_shop.rb) | 
+[Acapella](examples/acapella.rb) | 
+[Background Job](examples/background_job.rb) | 
+[Facade](examples/users_facade.rb) | 
+[HTTP API Client](examples/http_api_client.rb) | 
+[all examples](examples)
 
 ## Development
 

data/examples/acapella.rb

@@ -0,0 +1,55 @@
+require 'wrapper_based'
+
+module SoftSinging
+  def sing(lyrics)
+    puts "#{name}: #{lyrics.to_s.downcase}"
+  end
+end
+
+module LoudSinging
+  def sing(lyrics)
+    puts "#{name}: #{lyrics.to_s.upcase}!"
+  end
+end
+
+module NormalSinging
+  def sing(lyrics)
+    puts "#{name}: #{lyrics}"
+  end
+end
+
+class Trio < DCI::Context(normaly: NormalSinging, softly: SoftSinging, loudly: LoudSinging)
+  def initialize(singing = nil, normaly: singing, softly: singing, loudly: singing)
+    super(normaly: normaly, softly: softly, loudly: loudly)
+  end
+
+  def perform(song)
+    song.each_slice(3).each do |first, second, third|
+      softly.sing(first)
+      loudly.sing(second)
+      normaly.sing(third)
+    end
+  end
+end
+
+class Duet < DCI::Context(female: SoftSinging, male: LoudSinging)
+  def initialize(singing = nil, female: singing, male: singing)
+    super(female: female, male: male)
+  end
+
+  def perform(song)
+    song.each_slice(2).each do |first, last|
+      female.sing(first)
+      male.sing(last)
+    end
+  end
+end
+
+Singer = Struct.new(:name)
+singer = Singer['Justin']
+artist = Trio.new(singer)
+
+words = ["Na", "Hey", "Baby", "Oh", "Ooh", "You"]
+
+pop_song = words.permutation.flat_map(&:to_a).shuffle.first(20)
+artist.perform pop_song

data/examples/background_job.rb

@@ -0,0 +1,29 @@
+# https://gist.github.com/fj/c67a81a8ded757ccc075
+require 'yaml'
+
+module RangeQuery
+  def weekly(since, till = since + 1.week)
+    where(created_at: since...till)
+  end
+end
+
+class SendWeeklySummary < DCI::Context(:author, posts: RangeQuery)
+  def initialize(author) super(author: author, posts: author.posts) end
+
+  def perform since: Date.today.at_beginning_of_week, weekly_posts: posts.weekly(since)
+    weekly_digest = PostMailer.summary(weekly_posts, to: @author, title: "Your Posts this week")
+    weekly_digest.deliver unless weekly_posts.empty?
+  end
+
+  # load decoded job
+  def init_with(coder)
+    initialize Author.find coder['author_id']
+  end
+
+  # encode job
+  def encode_with(coder)
+    coder['author_id'] = @author.id
+  end
+
+  public :author
+end

data/examples/dijkstra.rb

@@ -2,42 +2,52 @@ require_relative 'dijkstra/data'
 # See https://github.com/RichOrElse/wrapper-based/blob/master/test/dijkstra_test.rb
 
 module DestinationNode
-  def shortest_path_from(neighbor, find_shortest)
-    return [self] if equal? neighbor
-    find_shortest.path(from: neighbor)
+  def shortest_path_from(node, finds_shortest)
+    return [self] if equal? node
+    finds_shortest.path from: node
   end
 end
 
-Map = DCI::Module.new do |mod| using mod
+module Map
   def distance_between(a, b)
     @distances[Edge.new(a, b)]
   end
 
-  def distance_of(path)
-    path.each_cons(2).inject(0) { |total, (to, from)| total + distance_between(from, to) }
+  def neighbors_of(node)
+    [south_neighbor_of(node), east_neighbor_of(node)].compact
+  end
+end
+
+class FindsDistance < DCI::Context(city: Map)
+  def initialize(city) super(city: city) end
+
+  def between(from, to)
+    city.distance_between(from, to)
   end
 
-  def neighbors(near:)
-    [south_neighbor_of(near), east_neighbor_of(near)].compact # excludes nil neighbors
+  def of(path)
+    path.each_cons(2).inject(0) { |total_distance, (to, from)| total_distance + between(from, to) }
   end
+
+  alias_method :call, :of
 end
 
-class FindShortest < DCI::Context(:from, to: DestinationNode, city: Map)
-  def initialize(city:, from: city.root, to: city.destination) super end
+class FindsShortest < DCI::Context(:from, to: DestinationNode, city: Map, road_distance: FindsDistance)
+  def initialize(city:, from: city.root, to: city.destination, road_distance: city) super end
 
   def distance
-    city.distance_of path
+    road_distance.of path
   end
 
   def path(from: @from)
-    shortest_neighbor_path(from) << from
+    city.neighbors_of(from).map(&to_shortest_path).min_by(&road_distance) << from
+  end
+
+  def call(neighbor = @from)
+    to.shortest_path_from(neighbor, self)
   end
 
   private
 
-  def shortest_neighbor_path(current)
-    city.neighbors(near: current).
-      map { |neighbor| to.shortest_path_from(neighbor, self) }.
-      min_by { |neighbor_path| city.distance_of neighbor_path }
-  end
+  alias_method :to_shortest_path, :to_proc
 end

data/examples/http_api_client.rb

@@ -0,0 +1,46 @@
+module ServiceAPI
+  InvalidToken = Class.new(StandardError)
+  UnknownContact = Class.new(StandardError)
+
+  module Client
+    REQUEST_PATH = Rails.application.secrets.service_api_url + '/api/v2'
+    MAX_PER_PAGE = 100
+
+    def contacts(page: 1, per: MAX_PER_PAGE)
+      fail InvalidToken, 'Please provide valid token.' if service_api_token.blank?
+      url = REQUEST_PATH + '/contacts?' + { token: service_api_token, page: page, per: per }.to_query
+      JSON(RestClient.get url, header: { content_type: :json })
+    rescue RestClient::Unauthorized => error
+      fail InvalidToken, 'Please provide valid token.'
+    end
+
+    def send_message(composition)
+      fail InvalidToken, 'Please provide valid token.' if service_api_token.blank?
+      url = REQUEST_PATH + '/messages?' + { token: service_api_token }.to_query
+      RestClient.post(url, composition.to_json, { content_type: :json, accept: :json }).body
+    rescue RestClient::UnprocessableEntity, RestClient::NotFound => error
+      fail UnknownContact, 'Contact not recognized.'
+    rescue RestClient::Unauthorized => error
+      fail InvalidToken, 'Please provide valid token.'
+    end
+  end
+
+  module MessageComposingRecipient
+    def compose(body)
+      fail UnknownContact, 'Contact not recognized.' if blank?
+      {
+        recipients: ["contact-#{self}"],
+        message: { body: body }
+      }
+    end
+  end
+end
+
+class SendsContactMessage < DCI::Context(:message, user: ServiceAPI::Client, to: ServiceAPI::MessageComposingRecipient)
+  def call(message = @message)
+    results = user.send_message to.compose(message)
+    return :success, results
+  rescue ServiceAPI::UnknownContact => error
+    return :failure, message: error.message
+  end
+end

data/examples/money_transfer.rb

@@ -21,18 +21,16 @@ module Funds
   end
 
   class TransferMoney < DCI::Context(:amount, from: SourceAccount, to: DestinationAccount, events: Logging)
-    def initialize(amount: 0, events: [], **accounts)
-      super
-    end
+    def initialize(amount: 0, events: [], **accounts) super end
 
     def withdraw(amount)
       from.decrease_balance_by(amount)
-      events.log "Withdrew", amount, from
+      events.log "Withdrew", amount, @from
     end
 
     def deposit(amount)
       to.increase_balance_by(amount)
-      events.log "Deposited", amount, to
+      events.log "Deposited", amount, @to
     end
 
     def transfer(amount)
@@ -42,13 +40,9 @@ module Funds
 
     def call(amount: @amount)
       transfer(amount)
-      return :success, { log: @events }, accounts
+      return :success, logging: @events, accounts: [@from, @to]
     rescue Funds::Insufficient => error
-      return :failure, { message: error.message }, accounts
-    end
-
-    def accounts
-      [@from, @to]
+      return :failure, message: error.message
     end
   end
 end

data/examples/toy_shop.rb

@@ -1,11 +1,13 @@
+require 'wrapper_based'
+
 # Data
 
 Purchase = Struct.new(:toy, :buyer)
 Deliver = Struct.new(:toy, :recipient, :purchase, :status)
 
-# Behaviors
+# Interactions
 
-module Buyer
+module Shopper
   def buy(toy)
     Purchase.new toy, self
   end
@@ -19,32 +21,25 @@ end
 
 # Contexts
 
-class PurchaseToy < DCI::Context(:purchaser)
-  purchaser.as Buyer
-  purchaser.as Recipient
+class BuyToy < DCI::Context(shopper: Shopper, recipient: Recipient)
+  def initialize(shopper:, recipient: shopper) super end
 
-  def call(toy)
-    purchased = purchaser.buy toy
-    purchaser.receive purchased
+  def call(item)
+    bought = shopper.buy item
+    recipient.receive bought
   end
 end
 
-
-class GiftToy < DCI::Context(:gifter, :giftee)
-  gifter.as Buyer
-  giftee.as Recipient
-
+class GiftToy < DCI::Context(gifter: Shopper, giftee: Recipient)
   def call(toy)
     gift = gifter.buy toy
     giftee.receive gift
   end
 end
 
-# Interactions
-
-finn_purchase_toy = PurchaseToy[purchaser: 'Finn']
+finn_purchase_toy = BuyToy[shopper: 'Finn']
 finn_purchase_toy.call 'Rusty sword'
 finn_purchase_toy.('Armor of Zeldron')
 finn_purchase_toy['The Enchiridion']
 
-['Card Wars', 'Ice Ninja Manual', 'Bacon'].each &GiftToy[gifter: 'Jake', giftee: 'Finn']
+puts ['Card Wars', 'Ice Ninja Manual', 'Bacon'].map &GiftToy[gifter: 'Jake', giftee: 'Finn']

data/examples/users_facade.rb

@@ -0,0 +1,23 @@
+# See: https://medium.com/kkempin/facade-design-pattern-in-ruby-on-rails-710aa88326f
+
+class UsersFacade < DCI::Context(:user, :users, :active_users, vip: VipUsersPresenter)
+  def initialize(user:, users: user.class, active_users: users.active, vip: active_users.vip) super end
+
+  def new_user
+    users.new
+  end
+
+  def last_active_users
+    @last_active_users ||= active_users.order(:created_at).limit(10)
+  end
+
+  def vip_users
+    @vip_users ||= vip.users
+  end
+
+  def messages
+    @messages ||= user.messages
+  end
+
+  private :users, :active_users, :vip
+end

data/lib/wrapper_based.rb

@@ -1,10 +1,30 @@
 require "wrapper_based/version"
 require "wrapper_based/context"
-require "wrapper_based/context/producer"
-require "wrapper_based/context/casting"
-require "wrapper_based/context/type_casting"
-require "wrapper_based/context/casting_director"
+require "wrapper_based/casting"
+require "wrapper_based/casting/type"
+require "wrapper_based/casting/director"
+require "wrapper_based/casting/pool"
 require "wrapper_based/dci"
+require "wrapper_based/type_casting"
+require "wrapper_based/role_unknown"
 
 module WrapperBased
+  def with!(**role_players)
+    role_players.each { |role, player| send :"with_#{role}!", player }
+    self
+  rescue NoMethodError => error
+    raise RoleUnknown.or(error)
+  end
+
+  private
+
+  using TypeCasting
+
+  def cast_as(role, actor, &recast)
+    _components[role].as_role_played_by(actor, &recast)
+  end
+
+  def _components
+    @_components ||= {}
+  end
 end

data/lib/wrapper_based/casting.rb

@@ -0,0 +1,56 @@
+module WrapperBased
+  RoleValueMissing = Class.new(StandardError)
+
+  class Casting < Module
+    def initialize
+      include WrapperBased
+    end
+
+    def casts(role)
+      role_writer = :"#{role}="
+
+      define_method(:"with_#{role}!") do |value|
+        send role_writer, yield(value)
+        self
+      end
+
+      private_reader role
+      private_writer role
+    end
+
+    def casts_as(role, &recast)
+      role_player = :"@#{role}"
+
+      define_method(:"with_#{role}!") do |actor|
+        _components[role] = cast_as(role, actor, &recast)
+        instance_variable_set(role_player, actor)
+        self
+      end
+
+      private_reader role
+      private_writer role
+    end
+
+    private
+
+    def private_reader(role)
+      define_method(role) do
+        _components.fetch(role) { raise RoleValueMissing, "Role `#{role}' is missing.", caller }
+      end
+
+      private role
+    end
+
+    def private_writer(role)
+      writer = :"#{role}="
+      role_player = :"@#{role}"
+
+      define_method(writer) do |value|
+        _components[role] = value
+        instance_variable_set(role_player, value)
+      end
+
+      private writer
+    end
+  end
+end

data/lib/wrapper_based/casting/director.rb

@@ -0,0 +1,28 @@
+module WrapperBased
+  TALENTLESS = -> actor { actor }
+
+  class Casting::Director < Struct.new(:casting, :talent_pool)
+    def initialize(talent_pool) super(Casting.new, talent_pool) end
+
+    def adds(role, talent = TALENTLESS)
+      case talent
+      when ::Proc, ::Method, ::Symbol
+        casting.casts role, &talent
+      when ::Class
+        casting.casts role, &talent.method(:new)
+      when ::Module
+        casting.casts_as role, &type_for(role).has(talent).method(:typecast)
+      else
+        throw :wrong_talent_type, [role, talent, "expected Module, Class, Proc, Method or Symbol"]
+      end
+    end
+
+    def to_proc
+      method(:adds).to_proc
+    end
+
+    def type_for(role)
+      Casting::Type.new(role, talent_pool)
+    end
+  end
+end

data/lib/wrapper_based/casting/pool.rb

@@ -0,0 +1,22 @@
+module WrapperBased
+  class Casting::Pool
+    def initialize(wrapper_for)
+      @talent_pool = Hash.new do |cache, type_casting|
+        cache[type_casting] = wrapper_for[*type_casting]
+      end
+    end
+
+    def casting_for(*supporting_roles, **leading_roles)
+      WrapperBased::Casting::Director.new(@talent_pool).tap do |director|
+        supporting_roles.each(&director)
+        leading_roles.each { |role, talent| director.adds role, talent }
+      end.casting
+    end
+
+    def context_for(*roles, &script)
+      klass = Class.new(Context).include casting_for(*roles)
+      klass.class_exec(&script) if block_given?
+      klass
+    end
+  end # Context class
+end # WrapperBased module

data/lib/wrapper_based/casting/type.rb

@@ -0,0 +1,31 @@
+require 'set'
+
+module WrapperBased
+  class Casting::Type
+    attr_reader :name
+
+    def initialize(name, talent_pool)
+      @name = name.to_sym
+      @talents = Set.new
+      @lookup = talent_pool
+    end
+
+    def has(talent)
+      @talents << talent
+      self
+    end
+
+    def [](*where)
+      @lookup[where]
+    end
+
+    def cast_type(type)
+      self[type, *@talents]
+    end
+
+    def typecast(actor)
+      return actor if @talents.empty?
+      cast_type(actor.class).new actor
+    end
+  end
+end

data/lib/wrapper_based/context.rb

@@ -1,60 +1,22 @@
 module WrapperBased
   class Context
-    def initialize(**where)
-      @_casting_director_ = CastingDirector.new(self.class)
-      rebind where
-    end
-
-    def rebind(**where)
-      where.each { |role, player| public_send :"#{role}=", player }
-      self
+    def initialize(*role_players)
+      with!(*role_players)
     end
 
     def to_proc
       method(:call).to_proc
     end
 
-    def [](*args, &block)
-      call(*args, &block)
+    def call(*)
+      raise NotImplementedError, "Context must implement a call method."
     end
 
-    UnassignedRole = Class.new(StandardError)
-
     class << self
       alias_method :[], :new
 
-      def call(**where)
-        new(where).call
-      end
-
-      def cast_as(role, actor)
-        send(role).typecast(actor)
-      end
-
-      protected
-
-      def add_role(role, casting)
-        add_reader_for(role)
-        add_writer_for(role)
-        add_role_to_class role, casting
-      end
-
-      def add_reader_for(role)
-        define_method(role) do
-          @_casting_director_.fetch(role) { raise UnassignedRole, "Role '#{role}' is missing.", caller }
-        end
-      end
-
-      def add_writer_for(role)
-        role_player = :"@#{role}"
-        define_method(:"#{role}=") do |actor|
-          instance_variable_set(role_player, actor)
-          @_casting_director_.cast_as role, actor
-        end
-      end
-
-      def add_role_to_class(role, casting)
-        define_singleton_method(role) { casting }
+      def call(*role_players, &blk)
+        new(*role_players).call(&blk)
       end
     end # class methods
   end # Context class

data/lib/wrapper_based/dci.rb

@@ -3,9 +3,23 @@ require "type_wrapper"
 module DCI
   Module = Class.new(TypeWrapper::Module)
 
-  @@context_producer = WrapperBased::Context::Producer.new(TypeWrapper)
+  @@casting_pool = WrapperBased::Casting::Pool.new(TypeWrapper)
 
-  def self.Context(*args, &block)
-    @@context_producer.produce(*args, &block)
+  class << self
+    def Context(*roles, &block)
+      fail_on_wrong_talent_type { return @@casting_pool.context_for(*roles, &block) }
+    end
+
+    def Roles(*roles)
+      fail_on_wrong_talent_type { return @@casting_pool.casting_for(*roles) }
+    end
+
+    private
+
+    def fail_on_wrong_talent_type(&blk)
+      key, wrong, expected = catch(:wrong_talent_type, &blk)
+      message = "'#{key}: #{wrong}' has wrong key value type #{wrong.class} (#{expected})"
+      raise TypeError, message, caller
+    end
   end
 end

data/lib/wrapper_based/role_unknown.rb

@@ -0,0 +1,8 @@
+module WrapperBased
+  class RoleUnknown < NoMethodError
+    def self.or(error)
+      return error unless error.message =~ /^undefined method `with_(\w..)/
+      new error.message.sub('undefined method', 'unknown role').sub('with_','').sub('!','')
+    end
+  end
+end

data/lib/wrapper_based/{context/type_casting.rb → type_casting.rb}

@@ -1,23 +1,17 @@
 require 'delegate'
 
 module WrapperBased
-  module Context::TypeCasting
+  module TypeCasting
     refine Object do
       def as_role_played_by(actor)
-        actor
-      end
-    end
-
-    refine NilClass do
-      def as_role_played_by(actor)
-        yield
+        yield actor
       end
     end
 
     refine Delegator do
       def as_role_played_by(actor)
         return replace_role_player_with(actor) if actor.instance_of?(role_type)
-        yield
+        yield actor
       end
 
       def replace_role_player_with(actor)

data/lib/wrapper_based/version.rb

@@ -1,3 +1,3 @@
 module WrapperBased
-  VERSION = "1.1.0"
+  VERSION = "2.0.0"
 end

data/wrapper_based.gemspec

@@ -21,9 +21,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.required_ruby_version = ">= 2.1.0"
 
-  spec.add_runtime_dependency "type_wrapper", "~> 1.2"
+  spec.add_runtime_dependency "type_wrapper", "~> 1.3"
 
   spec.add_development_dependency "bundler", "~> 1.15"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "mocha", "~> 1.2.1"
+  spec.add_development_dependency "activesupport", "4.2.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wrapper_based
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Ritchie Paul Buitre
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-20 00:00:00.000000000 Z
+date: 2017-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: type_wrapper
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +66,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.2.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.2.9
 description: 
 email:
 - ritchie@richorelse.com
@@ -81,18 +109,23 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/acapella.rb
+- examples/background_job.rb
 - examples/dijkstra.rb
 - examples/dijkstra/data.rb
+- examples/http_api_client.rb
 - examples/money_transfer.rb
 - examples/toy_shop.rb
+- examples/users_facade.rb
 - lib/wrapper_based.rb
+- lib/wrapper_based/casting.rb
+- lib/wrapper_based/casting/director.rb
+- lib/wrapper_based/casting/pool.rb
+- lib/wrapper_based/casting/type.rb
 - lib/wrapper_based/context.rb
-- lib/wrapper_based/context/casting.rb
-- lib/wrapper_based/context/casting_director.rb
-- lib/wrapper_based/context/producer.rb
-- lib/wrapper_based/context/type_casting.rb
 - lib/wrapper_based/dci.rb
-- lib/wrapper_based/roles.rb
+- lib/wrapper_based/role_unknown.rb
+- lib/wrapper_based/type_casting.rb
 - lib/wrapper_based/version.rb
 - wrapper_based.gemspec
 homepage: https://github.com/RichOrElse/wrapper-based/
@@ -115,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Wrapper Based DCI framework for OOP done right.

data/lib/wrapper_based/context/casting.rb

@@ -1,31 +0,0 @@
-require 'set'
-
-module WrapperBased
-  class Context::Casting
-    attr_reader :name
-
-    def initialize(name, wrappers)
-      @name = name.to_sym
-      @casting = Set.new
-      @wrappers = wrappers
-    end
-
-    def as(extention)
-      @casting << extention
-      self
-    end
-
-    def wrapper_for(*args)
-      @wrappers[args]
-    end
-
-    def cast_type(type)
-      wrapper_for type, *@casting
-    end
-
-    def typecast(actor)
-      return actor if @casting.empty?
-      cast_type(actor.class).new actor
-    end
-  end
-end

data/lib/wrapper_based/context/casting_director.rb

@@ -1,20 +0,0 @@
-require 'forwardable'
-
-module WrapperBased
-  class Context::CastingDirector
-    extend Forwardable
-    using Context::TypeCasting
-
-    def initialize(context_class)
-      @casts = {}
-      @re = context_class
-    end
-
-    def cast_as(role, actor)
-      @casts[role] = @casts[role].as_role_played_by(actor) { recast_as(role, actor) }
-    end
-
-    def_delegator :@re, :cast_as, :recast_as
-    def_delegators :@casts, :fetch, :[]
-  end
-end

data/lib/wrapper_based/context/producer.rb

@@ -1,21 +0,0 @@
-module WrapperBased
-  class Context
-    class Producer
-      def initialize(wrapper_for)
-        @wrapper_cache = Hash.new do |cache, type_casting|
-          cache[type_casting] = wrapper_for[*type_casting]
-        end
-      end
-
-      def produce(*supporting, **leading, &script)
-        wrappers = @wrapper_cache
-        roles = supporting.map(&:to_sym) | leading.keys
-        Class.new(Context) do
-          roles.each { |role| add_role role, Casting.new(role, wrappers) }
-          leading.each_pair { |role, trait| send(role).as trait }
-          class_eval(&script) unless script.nil?
-        end
-      end # produce method
-    end # Producer class
-  end # Context class
-end # WrapperBased module

data/lib/wrapper_based/roles.rb

@@ -1,64 +0,0 @@
-module WrapperBased
-  class Roles < Module
-    Unassigned = Class.new(StandardError)
-
-    def initialize(wrappers, *roles, **where, &block)
-      @casting_agent = (where.keys | roles.map(&:to_sym)).inject {|cast, role| cast[role] = Casting.new(role, wrappers) }
-      @casting_agent.keys.each { |role| add_role role }
-      where.each_pair {|role, trait| @casting[role].as trait }
-      define_casting_director(@casting_agent)
-      include InstanceMethods
-    end
-
-    def cast_as role, actor
-
-    end
-
-    def defing_casting_director(casting_agent)
-      define_method(:_casting_director_) { @_casting_director ||= CastingDirector.new(casting_agent) }
-    end
-
-    def cast_as(role, actor)
-      @casting[role].typecast actor
-    end
-
-    def add_role(role)
-      add_reader_for(role)
-      add_writer_for(role)
-    end
-
-    def add_reader_for(role)
-      define_method(role) do
-        _casting_director_.fetch(role) { raise Roles::Unassigned, "Role '#{role}' is missing.", caller }
-      end
-    end
-
-    def add_writer_for(role)
-      role_player = :"@#{role}"
-      define_method(:"#{role}=") do |actor|
-        instance_variable_set(role_player, actor)
-        _casting_director_.cast_as role, actor
-      end
-    end
-
-    def add_role_to_class(role, casting)
-      define_singleton_method(role) { casting }
-    end
-
-    def define_casting_director
-      roles = self
-    end
-
-    def included(base)
-      base.extend ClassMethods
-    end
-
-    module InstanceMethods
-      def rebind(**where, &block)
-        where.each { |role, player| public_send :"#{role}=", player }
-        instance_eval &block if block_given?
-        self
-      end
-    end
-  end
-end