playhouse 0.1.1

data/lib/playhouse/part.rb

@@ -0,0 +1,29 @@
+require 'playhouse/validation/required_actor_validator'
+
+module Playhouse
+  class Part
+    attr_accessor :name, :repository, :role, :composer, :optional
+
+    def initialize(name, options = {})
+      @name = name
+
+      options.each do |key, value|
+        self.send("#{key}=", value)
+      end
+    end
+
+    def cast(actor)
+      @role ? @role.cast_actor(actor) : actor
+    end
+
+    def required
+      !optional
+    end
+
+    def validators
+      result = []
+      result << RequiredActorValidator.new(part_name: name) if required
+      result
+    end
+  end
+end

data/lib/playhouse/play.rb

@@ -0,0 +1,59 @@
+require 'active_support/core_ext/string/inflections'
+require 'playhouse/talent_scout'
+
+module Playhouse
+  # A Play is a cohesive collection of application logic (in the form of Contexts).
+  # Your production might just contain one play, or you might prefer to have several
+  # plays each with their own theme. Contexts are typically called through a play rather
+  # that directly, and the Play will use it's TalentScout to ensure that the correct
+  # Actors are found.
+  #
+  # Contexts within your play can call each other, but should not call Contexts in other
+  # Plays directly, but can do so be calling the public interface on another Play.
+  class Play
+    class << self
+      def context(context_class)
+        context_classes << context_class
+
+        define_method context_class.method_name do |params|
+          execute_context(context_class, params)
+        end
+        
+        define_method "#{context_class.method_name}_with_parent" do |parent, params|
+          execute_context_with_parent(parent, context_class, params)
+        end
+      end
+
+      def context_classes
+        @context_classes ||= []
+      end
+
+      def contexts_for(resource_module)
+        resource_module.constants.each do |constant|
+          context resource_module.const_get(constant)
+        end
+      end
+    end
+
+    def initialize(talent_scout = TalentScout.new)
+      @talent_scout = talent_scout
+    end
+
+    def commands
+      self.class.context_classes
+    end
+
+    def execute_context(context_class, params)
+      @talent_scout.build_context(context_class, params).call
+    end
+    
+    def execute_context_with_parent(parent, context_class, params)
+      @talent_scout.build_context_with_parent(parent, context_class, params)
+    end
+
+    def name
+      self.class.name.split('::').last.underscore
+    end
+  end
+
+end

data/lib/playhouse/production.rb

@@ -0,0 +1,33 @@
+require 'playhouse/support/default_hash_values'
+
+module Playhouse
+  # A production is the complete collection of your application logic,
+  # and is nearly an application ready to run. You just need to supply
+  # a theatre and an interface and you can have a running app.
+  class Production
+    def initialize
+      @plays = []
+    end
+
+    def run(options = {})
+      options.extend Support::DefaultHashValues
+      theatre = options.required_value :theatre
+      interface = options.required_value :interface
+      interface_instance = interface.build(self)
+
+      theatre.while_open do
+        interface_instance.run options[:interface_args]
+      end
+    end
+
+    # Your production should inherit from this class and call this method
+    # in it's initialize method. This method is public just in case you
+    # want to build your production from the outside, but that's not really
+    # necessary or recommended.
+    def add_play(play_class)
+      @plays << play_class.new
+    end
+
+    attr_reader :plays
+  end
+end

data/lib/playhouse/role.rb

@@ -0,0 +1,55 @@
+module Playhouse
+  module Role
+    class CastingException < Exception; end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def cast_actor(actor)
+        check_depencies(actor)
+        actor.extend(self)
+      end
+
+      def cast_all(actor_collection)
+        actor_collection.map do |actor|
+          cast_actor(actor)
+        end
+      end
+
+      private
+
+      class Dependency
+        def initialize(method_name, options)
+          @method_name = method_name
+          @default_role = options[:default_role]
+        end
+
+        def check(actor)
+          unless actor.respond_to?(@method_name)
+            if @default_role
+              @default_role.cast_actor(actor)
+            else
+              raise CastingException.new("Trying to cast #{actor.class.name} but it doesn't support method #{@method_name}")
+            end
+          end
+        end
+      end
+
+      def check_depencies(actor)
+        dependencies.each do |dependency|
+          dependency.check(actor)
+        end
+      end
+
+      def dependencies
+        @dependencies ||= []
+      end
+
+      def actor_dependency(method_name, options = {})
+        dependencies << Dependency.new(method_name, options)
+      end
+    end
+  end
+end

data/lib/playhouse/scouts/build_with_composer.rb

@@ -0,0 +1,33 @@
+require 'playhouse/scouts/can_construct_object'
+
+module Playhouse
+  module Scouts
+    class BuildWithComposer
+      def actor_for_part(part, params)
+        if part.composer
+          param_value = params[part.name]
+          if param_value
+            part.composer.compose(param_value)
+          else
+            nil
+          end
+        else
+          nil
+        end
+      end
+
+      private
+
+      def object_builder(part)
+      end
+
+      def param_suffix
+        "attributes"
+      end
+
+      def build_method
+        :compose
+      end
+    end
+  end
+end

data/lib/playhouse/scouts/can_construct_object.rb

@@ -0,0 +1,15 @@
+module Playhouse
+  module Scouts
+    module CanConstructObject
+      def actor_for_part(part, params)
+        if object_builder(part)
+          param_key = "#{part.name}_#{param_suffix}".to_sym
+          param_value = params[param_key]
+          object_builder(part).send(build_method, param_value) if param_value
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/playhouse/scouts/direct_value.rb

@@ -0,0 +1,9 @@
+module Playhouse
+  module Scouts
+    class DirectValue
+      def actor_for_part(part, params)
+        params[part.name]
+      end
+    end
+  end
+end

data/lib/playhouse/scouts/entity_from_repository.rb

@@ -0,0 +1,23 @@
+require 'playhouse/scouts/can_construct_object'
+
+module Playhouse
+  module Scouts
+    class EntityFromRepository
+      include CanConstructObject
+
+      private
+
+      def object_builder(part)
+        part.repository
+      end
+
+      def param_suffix
+        "id"
+      end
+
+      def build_method
+        :find
+      end
+    end
+  end
+end

data/lib/playhouse/support/default_hash_values.rb

@@ -0,0 +1,23 @@
+module Playhouse
+  module Support
+    module DefaultHashValues
+      def value_or_default(key, default)
+        value_or_do(key) { default }
+      end
+
+      def value_or_error(key, error)
+        value_or_do(key) { raise(error) }
+      end
+
+      def required_value(key)
+        value_or_error(key, ArgumentError.new("Missing required argument #{key}"))
+      end
+
+      private
+
+        def value_or_do(key)
+          self[key].nil? ? yield : self[key]
+        end
+    end
+  end
+end

data/lib/playhouse/support/files.rb

@@ -0,0 +1,7 @@
+def require_all(*path_parts)
+  path = File.join(path_parts)
+  files = Dir.glob(path)
+  files.each do |file|
+    require file
+  end
+end

data/lib/playhouse/talent_scout.rb

@@ -0,0 +1,42 @@
+require 'playhouse/scouts/build_with_composer'
+require 'playhouse/scouts/direct_value'
+require 'playhouse/scouts/entity_from_repository'
+
+# Finds the actors for a context. The name of this class
+# might be a bit creative since I felt the need to explain it.
+module Playhouse
+  class TalentScout
+    def build_context(context_class, params)
+      context_class.new(actors_for_params(context_class, params))
+    end
+
+    def build_context_with_parent(parent, context_class, params)
+      context = build_context context_class, params
+      context.inherit_actors_from parent
+      context
+    end
+
+    private
+
+    def actors_for_params(context_class, params)
+      actors = {}
+      context_class.parts.each do |part|
+        actor = actor_for_part(part, params)
+        actors[part.name] = actor if actor
+      end
+      actors
+    end
+
+    def scouts
+      [Scouts::BuildWithComposer, Scouts::DirectValue, Scouts::EntityFromRepository].map(&:new)
+    end
+
+    def actor_for_part(part, params)
+      scouts.each do |scout|
+        actor = scout.actor_for_part(part, params)
+        return actor if actor
+      end
+      nil
+    end
+  end
+end

data/lib/playhouse/theatre.rb

@@ -0,0 +1,62 @@
+require 'yaml'
+require 'active_record'
+require 'playhouse/support/default_hash_values'
+
+module Playhouse
+  class Theatre
+    class DoubleBookedError < Exception; end
+
+    attr_reader :root_path
+
+    class << self
+      attr_reader :current
+
+      def current=(value)
+        if @current
+          raise DoubleBookedError.new("You already have #{@current.inspect} staged")
+        end
+        @current = value
+      end
+
+      def clear_current
+        @current = nil
+      end
+    end
+
+    def initialize(options = {})
+      options.extend Support::DefaultHashValues
+
+      @environment = options.value_or_error :environment, ArgumentError.new("environment option is required")
+      @root_path =   options.value_or_default :root, Dir.pwd
+      @load_db =     options.value_or_default :load_db, true
+    end
+
+    def while_open
+      open
+      begin
+        yield
+      ensure
+        close
+      end
+    end
+
+    def open
+      Dir.chdir @root_path
+      connect_to_database
+      self.class.current = self
+    end
+
+    def close
+      self.class.clear_current
+    end
+
+    private
+
+    def connect_to_database
+      if @load_db
+        db_params = YAML.load(File.read(root_path + "/config/database.yml"))[@environment.to_s]
+        ActiveRecord::Base.establish_connection db_params
+      end
+    end
+  end
+end

data/lib/playhouse/validation/actors_validator.rb

@@ -0,0 +1,23 @@
+require 'playhouse/validation/validation_errors'
+
+module Playhouse
+  class ActorsValidator
+    def validate_actors(parts, actors)
+      error = ContextValidationError.new
+      raise_error = false
+
+      parts.each do |part|
+        part.validators.each do |validator|
+          begin
+            validator.validate_actor(actors[part.name])
+          rescue ActorValidationError => actor_error
+            raise_error = true
+            error.add_to_part(part.name, actor_error)
+          end
+        end
+      end
+
+      raise error if raise_error
+    end
+  end
+end

data/lib/playhouse/validation/required_actor_validator.rb

@@ -0,0 +1,17 @@
+module Playhouse
+  class ActorValidator
+    def initialize(options)
+      @part_name = options[:part_name]
+    end
+
+    private
+
+      attr_accessor :part_name
+  end
+
+  class RequiredActorValidator < ActorValidator
+    def validate_actor(actor)
+      raise RequiredActorMissing.new(part_name: part_name) if actor.nil?
+    end
+  end
+end