playhouse 0.1.1

data/lib/playhouse/validation/validation_errors.rb

@@ -0,0 +1,76 @@
+module Playhouse
+  class ContextUsageError < ArgumentError
+  end
+
+  class ActorKeyError < ContextUsageError
+    def initialize(context_name, actor_name)
+      @context_name = context_name
+      @actor_name = actor_name
+    end
+
+    def description
+      message
+    end
+  end
+
+  class InvalidActorKeyError < ActorKeyError
+    def message
+      "Actor key #{@actor_name.inspect} is not a symbol, for #{@context_name}"
+    end
+  end
+
+  class UnknownActorKeyError < ActorKeyError
+    def message
+      "Unknown actor #{@actor_name.inspect} for #{@context_name}"
+    end
+  end
+
+  class ContextValidationError < Exception
+    def initialize(*params)
+      @part_errors = {}
+    end
+
+    def for_part(part_name)
+      @part_errors[part_name] || []
+    end
+
+    def add_to_part(part_name, error)
+      @part_errors[part_name] ||= []
+      @part_errors[part_name] << error
+    end
+
+    def part_errors
+      @part_errors
+    end
+
+    def message
+      part_messages.join("\n")
+    end
+
+    private
+
+      def part_messages
+        @part_errors.map do |part_name, errors|
+          [part_name, errors.map(&:message).join(', ')].join(': ')
+        end
+      end
+  end
+
+  class ActorValidationError < Exception
+    def initialize(options)
+      @part_name = options[:part_name]
+    end
+
+    attr_reader :part_name
+  end
+
+  class RequiredActorMissing < ActorValidationError
+    def message
+      "Missing actor #{@part_name}"
+    end
+
+    def description
+      "You must specify one of these"
+    end
+  end
+end

data/playhouse.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name = "playhouse"
+  s.version = '0.1.1'
+  s.authors = ["Craig Ambrose", "Joshua Vial"]
+  s.email = ["craig@enspiral.com", "joshua@enspiral.com"]
+  s.homepage = "https://github.com/enspiral/economatic"
+  s.summary = "A DCI framework"
+  s.description = "Provides one possible way of implementing a DCI architecture in a ruby app"
+
+  s.require_paths = %w(lib)
+
+  s.files = `git ls-files`.split($/)
+  s.test_files = s.files.grep(%r{^(spec)/})
+
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.add_dependency 'rake'
+  s.add_dependency 'activesupport'
+  s.add_dependency 'activerecord'
+end

data/spec/playhouse/context_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'playhouse/context'
+
+module Playhouse
+  describe Context do
+    before do
+      class ExampleContext < Context
+        attr_accessor :performed
+
+        def perform
+          self.performed = true
+        end
+      end
+    end
+
+    after do
+      Playhouse.class_eval{remove_const :ExampleContext}
+    end
+
+    describe 'constructing' do
+      it 'does not allow an unspecified actor to be stored' do
+        expect { ExampleContext.new(foobar: 'value') }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe '.actor' do
+      let(:role) { double(:role) }
+
+      it 'allows the actor to be passed into the constructor and stored' do
+        ExampleContext.actor :foobar
+        subject = ExampleContext.new(foobar: 'value')
+        subject.foobar.should == 'value'
+      end
+
+      it 'extends the actor by the specified role' do
+        ExampleContext.actor :foobar, role: role
+        role.should_receive(:cast_actor).with('value').and_return('cast value')
+        subject = ExampleContext.new(foobar: 'value')
+        subject.call
+        subject.foobar.should == 'cast value'
+      end
+    end
+    
+    describe '#inherit_actors_from' do
+      before do
+        class ParentContext < Context
+          actor :current_user
+          actor :other_actor
+        end
+        @parent = ParentContext.new current_user: 'user', other_actor: 'other'
+        ExampleContext.actor :current_user
+      end
+
+      it 'loads actors that are unset' do
+        subject = ExampleContext.new
+        subject.inherit_actors_from @parent
+        expect(subject.current_user).to eq 'user'
+      end
+
+      it 'does not load actors that are already set' do
+        subject = ExampleContext.new current_user: 'user override'
+        subject.inherit_actors_from @parent
+        expect(subject.current_user).to eq 'user override'
+      end
+
+      it 'does not load actors for which it has no part' do
+        subject = ExampleContext.new
+        subject.inherit_actors_from @parent
+        expect{subject.other_actor}.to raise_error
+      end
+    end
+
+    describe '#call' do
+      it 'calls perform' do
+        subject = ExampleContext.new
+        subject.call
+
+        subject.performed.should be_true
+      end
+
+      it 'does not raise an error if an optional actor is not supplied' do
+        ExampleContext.actor :foobar, optional: true
+        subject = ExampleContext.new
+        subject.call
+      end
+
+      it 'raises an error if a required actor is not supplied' do
+        ExampleContext.actor :foobar
+        subject = ExampleContext.new
+        expect {
+          subject.call
+        }.to raise_error
+      end
+    end
+
+    describe 'http_method' do
+      it 'defaults to :get' do
+        expect(ExampleContext.http_methods).to include(:get)
+      end
+      it 'can be set one at a time' do
+        ExampleContext.http_method :post
+        expect(ExampleContext.http_methods).to include(:post)
+      end
+      it 'can be set with an array' do
+        ExampleContext.http_method [:get, :post]
+        expect(ExampleContext.http_methods).to include(:get)
+        expect(ExampleContext.http_methods).to include(:post)
+      end
+    end
+  end
+end

data/spec/playhouse/part_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'playhouse/part'
+
+module Playhouse
+  describe Part do
+    subject { Part.new(:amount) }
+
+    describe "#validators" do
+      it "is empty for an optional part" do
+        subject.optional = true
+        subject.validators.should == []
+      end
+
+      it "includes a required actor validator if not optional" do
+        subject.validators.first.should be_a(RequiredActorValidator)
+      end
+    end
+  end
+end

data/spec/playhouse/play_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'playhouse/context'
+require 'playhouse/play'
+
+module Playhouse
+  describe Play do
+    before do
+      class CalculateTax < Context
+      end
+
+      class ExampleAPI < Play
+        context CalculateTax
+      end
+    end
+
+    after do
+      Playhouse.class_eval{remove_const :ExampleAPI}
+      Playhouse.class_eval{remove_const :CalculateTax}
+    end
+
+    context 'when instantiated' do
+      subject { ExampleAPI.new }
+      let(:context) { double(:context) }
+
+      it 'presents contexts as callable methods' do
+        CalculateTax.actor :taxable_income
+        CalculateTax.should_receive(:new).with(taxable_income: 123).and_return(context)
+        context.should_receive(:call)
+
+        #subject.respond_to?(:calculate_tax).should be_true
+        subject.calculate_tax taxable_income: 123
+      end
+      
+      it 'presents callable methods with parent' do
+        parent = double(:context)
+        expect(subject).to receive(:execute_context_with_parent)
+        
+        subject.calculate_tax_with_parent parent, {}
+      end
+
+      it 'has a name' do
+        expect(subject.name).to eq('example_api')
+      end
+    end
+
+    describe 'resource' do
+      before do
+        module ExampleResource
+          class Context1 < Context
+          end
+          class Context2 < Context
+          end
+        end
+      end
+      it 'loads all contexts inside a module' do
+        ExampleAPI.stub(:context)
+        expect(ExampleAPI).to receive(:context).with(ExampleResource::Context1)
+        expect(ExampleAPI).to receive(:context).with(ExampleResource::Context2)
+        ExampleAPI.contexts_for ExampleResource
+      end
+
+    end
+  end
+end

data/spec/playhouse/production_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'playhouse/production'
+
+module Playhouse
+  describe Production do
+    let(:theatre)   { double(:theatre) }
+    let(:interface) { double(:interface, build: instance) }
+    let(:instance)  { double(:interface_instance) }
+
+    describe "#run" do
+      it "requires a theatre and an interface" do
+        expect { subject.run(theatre: theatre) }.to raise_error(ArgumentError)
+        expect { subject.run(interface: interface) }.to raise_error(ArgumentError)
+      end
+
+      it "opens the theatre" do
+        theatre.should_receive :while_open
+        subject.run(theatre: theatre, interface: interface)
+      end
+
+      it "runs the interface" do
+        theatre.stub(:while_open).and_yield
+        interface.should_receive(:build).with(subject).and_return(instance)
+        instance.should_receive(:run)
+
+        subject.run(theatre: theatre, interface: interface)
+      end
+
+      it "passes optional interface_args parameter through to interface" do
+        theatre.stub(:while_open).and_yield
+        instance.should_receive(:run).with("args")
+
+        subject.run(theatre: theatre, interface: interface, interface_args: "args")
+      end
+    end
+
+    describe "#plays" do
+      let(:play_class) { double(:play_class, new: play) }
+      let(:play)       { double(:play) }
+
+      it "has a collection of plays which can be added" do
+        subject.add_play play_class
+        subject.plays.should == [play]
+      end
+    end
+  end
+end

data/spec/playhouse/role_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'playhouse/role'
+
+module Playhouse
+  describe Role do
+    module ExampleRole
+      include Role
+
+      actor_dependency :dingbat
+
+      def foobar
+        'awesome!'
+      end
+    end
+
+    class DingbatActor
+      def dingbat
+      end
+    end
+
+    subject { ExampleRole }
+    let(:valid_actor) { DingbatActor.new }
+    let(:invalid_actor) { Object.new }
+
+    context "when casting as" do
+      it "adds foobar method to actor" do
+        player = subject.cast_actor(valid_actor)
+        player.foobar.should == 'awesome!'
+      end
+
+      context "without a default role" do
+        it "raises exception if an actor dependency is not met" do
+          expect {
+            subject.cast_actor(invalid_actor)
+          }.to raise_error
+        end
+      end
+
+      context "with a default role" do
+        subject { ExampleRoleWithDefault }
+
+        module DingbatProviderRole
+          include Role
+          def dingbat
+          end
+        end
+        module ExampleRoleWithDefault
+          include Role
+
+          actor_dependency :dingbat, default_role: DingbatProviderRole
+
+          def foobar
+            'awesome!'
+          end
+        end
+
+        it "auto casts actor with default role" do
+          player = subject.cast_actor(invalid_actor)
+          player.foobar
+          player.dingbat
+        end
+      end
+    end
+
+    context "when casting an enumerable as" do
+      it "extends each member of the enumerable" do
+        players = subject.cast_all([valid_actor])
+        players.first.foobar.should == 'awesome!'
+      end
+    end
+  end
+end

data/spec/playhouse/support/default_hash_values_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'playhouse/support/default_hash_values'
+
+module Playhouse
+  module Support
+    describe DefaultHashValues do
+      def subject_with(data)
+        data.extend(DefaultHashValues)
+      end
+
+      describe "#value_or_default" do
+        it "returns the value if it is not nil" do
+          subject_with(key: 1).value_or_default(:key, 'fish').should == 1
+          subject_with(key: false).value_or_default(:key, 'fish').should == false
+        end
+
+        it "returns the default if the value is nil" do
+          subject_with(key: nil).value_or_default(:key, 'fish').should == 'fish'
+        end
+      end
+
+      describe "#value_or_error" do
+        it "returns the value if it is not nil" do
+          subject_with(key: 1).value_or_error(:key, 'fish').should == 1
+          subject_with(key: false).value_or_error(:key, 'fish').should == false
+        end
+
+        it "raises the error if the value is nil" do
+          expect { subject_with(key: nil).value_or_error(:key, 'fish') }.to raise_error('fish')
+        end
+      end
+    end
+  end
+end