ntl-orchestra 0.9.0

data/lib/orchestra/conductor.rb

@@ -0,0 +1,119 @@
+module Orchestra
+  class Conductor
+    attr :observers, :services, :thread_pool
+
+    def initialize services = {}
+      @services = services
+      @thread_pool = ThreadPool.new
+      @observers = Set.new
+      self.thread_count = Configuration.thread_count
+    end
+
+    def perform operation, input = {}
+      operation.perform self, input do |performance|
+        copy_observers performance
+        yield performance if block_given?
+      end
+    end
+
+    def record *args
+      recording = Recording.new
+      add_observer recording
+      perform *args do |performance|
+        performance.add_observer recording
+      end
+      recording
+    ensure
+      delete_observer recording
+    end
+
+    def add_observer observer
+      observers << observer
+    end
+
+    def delete_observer observer
+      observers.delete observer
+    end
+
+    def copy_observers observable
+      add_observer = observable.method :add_observer
+      observers.each &add_observer
+    end
+
+    def build_registry observable
+      hsh = { :conductor => self }
+      services.each_with_object hsh do |(service_name, _), hsh|
+        service = resolve_service observable, service_name
+        hsh[service_name] = service if service
+      end
+    end
+
+    def resolve_service observable, service_name
+      return nil unless services.has_key? service_name
+      service = Util.to_lazy_thunk services[service_name]
+      recording = ServiceRecorder.new observable, service_name
+      recording.wrap service.call self
+    end
+
+    def thread_count
+      @thread_pool.count
+    end
+
+    def thread_count= new_count
+      @thread_pool.count = new_count
+    end
+
+    class ServiceRecorder
+      attr :observable, :service_name
+
+      def initialize observable, service_name
+        @observable = observable
+        @service_name = service_name
+        @record = []
+      end
+
+      def << record
+        observable.changed
+        observable.notify_observers :service_accessed, service_name, record
+        @record << record
+      end
+
+      def each &block
+        @record.each &block
+      end
+
+      def wrap raw_service
+        Wrapper.new raw_service, self
+      end
+
+      class Wrapper < Delegator
+        attr_accessor :service
+        alias_method :__getobj__, :service
+        alias_method :__setobj__, :service=
+
+          def initialize service, recording
+            super service
+            @recording = recording
+          end
+
+        def kind_of? klass
+          super or service.kind_of? klass
+        end
+
+        def method_missing meth, *args
+          super.tap do |result|
+            @recording << {
+              :method => meth.to_s,
+              :input  => args,
+              :output => result,
+            }
+          end
+        end
+
+        def inspect
+          "#<#{self.class.name} service=#{service.inspect}>"
+        end
+      end
+    end
+  end
+end

data/lib/orchestra/configuration.rb

@@ -0,0 +1,12 @@
+module Orchestra
+  module Configuration
+    extend self
+
+    attr_accessor :thread_count
+
+    def reset
+      self.thread_count = 1
+    end
+    reset
+  end
+end

data/lib/orchestra/dsl/nodes.rb

@@ -0,0 +1,72 @@
+module Orchestra
+  module DSL
+    module Nodes
+      class Builder
+        attr_accessor :collection, :perform_block
+
+        attr :defaults, :dependencies, :provisions
+
+        def initialize
+          @defaults = {}
+          @dependencies = []
+          @provisions = []
+        end
+
+        def build_node
+          Node::InlineNode.new(
+            :collection    => collection,
+            :defaults      => defaults,
+            :dependencies  => dependencies,
+            :perform_block => perform_block,
+            :provides      => provisions,
+          )
+        end
+      end
+
+      class Context < BasicObject
+        def self.evaluate builder, &block
+          context = new builder
+          context.instance_eval &block
+        end
+
+        attr :collection, :perform
+
+        def initialize builder
+          @builder = builder
+        end
+
+        def depends_on *dependencies
+          defaults, dependencies = Util.extract_hash dependencies
+          @builder.dependencies.concat dependencies
+          defaults.each do |key, default|
+            @builder.dependencies << key
+            @builder.defaults[key] = Util.to_lazy_thunk default
+          end
+        end
+
+        def modifies provision, args = {}
+          collection, _ = Util.extract_key_args args, :collection => false
+          if collection
+            iterates_over provision
+          else
+            depends_on provision
+          end
+          provides provision
+        end
+
+        def provides *provisions
+          @builder.provisions.concat provisions
+        end
+
+        def perform &block
+          @builder.perform_block = block
+        end
+
+        def iterates_over dependency
+          @builder.dependencies << dependency
+          @builder.collection = dependency
+        end
+      end
+    end
+  end
+end

data/lib/orchestra/dsl/object_adapter.rb

@@ -0,0 +1,134 @@
+module Orchestra
+  module DSL
+    class ObjectAdapter
+      def self.build_node object, args = {}
+        method_name = args.delete :method do :perform end
+        collection = args.delete :iterates_over
+        adapter_type = determine_type object, method_name
+        adapter = adapter_type.new object, method_name, collection
+        NodeFactory.build adapter, args
+      end
+
+      def self.determine_type object, method_name
+        if object.public_methods.include? method_name
+          SingletonAdapter
+        elsif object.kind_of? Class
+          ClassAdapter
+        else
+          SingletonAdapter
+        end
+      end
+
+      attr :collection, :object, :method_name
+
+      def initialize object, method_name, collection
+        @collection = collection
+        @method_name = method_name || :perform
+        @object = object
+      end
+
+      def build_context state
+        ExecutionContext.new self, state
+      end
+
+      def collection?
+        @collection ? true : false
+      end
+
+      def context_class
+        @context_class ||= Node.build_execution_context_class dependencies
+      end
+
+      def dependencies
+        [collection, *object_method.dependencies].compact
+      end
+    end
+
+    class SingletonAdapter < ObjectAdapter
+      def validate!
+        unless object.methods.include? method_name
+          raise NotImplementedError,
+            "#{object} does not implement method `#{method_name}'"
+        end
+        if collection?
+          raise ArgumentError,
+            "#{object} is a singleton; cannot iterate over collection #{collection.inspect}"
+        end
+      end
+
+      def perform state
+        deps = object_method.dependencies
+        input = state.select do |key, _| deps.include? key end
+        Invokr.invoke :method => method_name, :on => object, :with => input
+      end
+
+      def object_method
+        Invokr.query_method object.method method_name
+      end
+    end
+
+    class ClassAdapter < ObjectAdapter
+      def validate!
+        return if object.instance_methods.include? method_name
+        raise NotImplementedError,
+          "#{object} does not implement instance method `#{method_name}'"
+      end
+
+      def perform state, maybe_item = nil
+        instance = Invokr.inject object, :using => state
+        args = [method_name]
+        args << maybe_item if collection?
+        instance.public_send *args
+      end
+
+      def object_method
+        Invokr.query_method object.instance_method :initialize
+      end
+    end
+
+    class NodeFactory
+      def self.build *args
+        instance = new *args
+        instance.build_node
+      end
+
+      attr :adapter, :compact, :provides, :thread_count
+
+      def initialize adapter, args = {}
+        @adapter = adapter
+        @provides, @compact, @thread_count = Util.extract_key_args args,
+          :provides => nil, :compact => false, :thread_count => nil
+      end
+
+      def build_node
+        adapter.validate!
+        Node::DelegateNode.new adapter, build_node_args
+      end
+
+      def build_node_args
+        hsh = {
+          :dependencies => adapter.dependencies,
+          :provides     => Array(provides),
+        }
+        hsh[:collection] = adapter.collection if adapter.collection?
+        hsh
+      end
+    end
+
+    class ExecutionContext
+      def initialize adapter, state
+        @__adapter__ = adapter
+        @__state__ = state
+        return unless adapter.collection?
+        self.singleton_class.send :define_method, :fetch_collection do
+          @__state__.fetch adapter.collection
+        end
+      end
+
+      def perform *args
+        @__adapter__.perform @__state__, *args
+      end
+    end
+
+  end
+end

data/lib/orchestra/dsl/operations.rb

@@ -0,0 +1,108 @@
+module Orchestra
+  module DSL
+    module Operations
+      class Builder
+        attr_writer :command, :result
+
+        def initialize
+          @nodes = {}
+        end
+
+        def build_operation
+          raise ArgumentError, "Must supply a result" if @result.nil?
+          raise ArgumentError, "Must supply at least one node" if @nodes.empty?
+          Operation.new(
+            :command => @command,
+            :nodes   => @nodes,
+            :result  => @result,
+          )
+        end
+
+        def add_node name_or_object, args = {}, &block
+          name, node = case name_or_object
+          when nil then build_anonymous_node block
+          when Operation then build_embedded_operation_node name_or_object
+          when ::String, ::Symbol then build_inline_node name_or_object, block
+          else build_object_node name_or_object, args
+          end
+          node.provisions << name.to_sym if node.provisions.empty?
+          set_node name.to_sym, node
+        end
+
+        def set_node name, node
+          if @nodes.has_key? name
+            raise ArgumentError, "There are duplicate nodes named #{name.inspect}"
+          end
+          @nodes[name] = node
+          node.freeze
+        end
+
+        def build_anonymous_node block
+          node = Node::InlineNode.build &block
+          unless node.provisions.size == 1
+            raise ArgumentError, "Could not infer name for node from a provision"
+          end
+          name = node.provisions.fetch 0
+          [name, node]
+        end
+
+        def build_embedded_operation_node operation
+          name = object_name operation
+          [name || operation.result, operation]
+        end
+
+        def build_inline_node name, block
+          node = Node::InlineNode.build &block
+          [name, node]
+        end
+
+        def build_object_node object, args
+          name = object_name object
+          node = ObjectAdapter.build_node object, args
+          [name, node]
+        end
+
+        private
+
+        def object_name object
+          object.name and Util.to_snake_case Util.demodulize object.name
+        end
+      end
+
+      class Context < BasicObject
+        def self.evaluate builder, &block
+          context = new builder
+          context.instance_eval &block
+        end
+
+        attr :nodes
+
+        def initialize builder
+          @builder = builder
+        end
+
+        def node *args, &block
+          @builder.add_node *args, &block
+          nil
+        end
+
+        def result= result
+          @builder.result = result
+          nil
+        end
+
+        def result name = nil, &block
+          node = @builder.add_node name, &block
+          name ||= node.provisions.fetch 0
+          self.result = name
+        end
+
+        def finally name = :__finally__, &block
+          @builder.add_node name, &block
+          @builder.command = true
+          self.result = name
+        end
+      end
+    end
+  end
+end

data/lib/orchestra/errors.rb

@@ -0,0 +1,44 @@
+module Orchestra
+  class Error < StandardError
+    def list_out list
+      list = list.map &:inspect
+      return list.fetch 0 if list.size == 1
+      list.fetch 0
+      second_to_last, last = list.slice! -2..-1
+      str = list.join ', '
+      str << ', ' unless str.empty?
+      str << "#{second_to_last} and #{last}"
+      str
+    end
+  end
+
+  class MissingProvisionError < Error
+    def initialize missing_provisions
+      @missing_provisions = missing_provisions
+    end
+
+    def to_s
+      "failed to supply output: #{list_out @missing_provisions}"
+    end
+  end
+
+  class CircularDependencyError < Error
+    def to_s
+      "Circular dependency detected! Check your dependencies/provides"
+    end
+  end
+
+  class MissingInputError < Error
+    def initialize missing_input
+      @missing_input = missing_input
+    end
+
+    def count
+      @missing_input.count
+    end
+
+    def to_s
+      "Missing input#{'s' unless count == 1} #{list_out @missing_input}"
+    end
+  end
+end

data/lib/orchestra/node/output.rb

@@ -0,0 +1,61 @@
+module Orchestra
+  class Node
+    class Output
+      attr :hsh, :node, :raw
+
+      def self.process node, raw
+        instance = new node, raw
+        instance.massage
+        instance.hsh
+      end
+
+      def initialize node, raw
+        @node = node
+        @raw = raw
+      end
+
+      def provisions
+        node.provisions
+      end
+
+      def collection?
+        node.collection?
+      end
+
+      def massage
+        @raw.compact! if collection?
+        @hsh = coerce_to_hash
+        prune
+        ensure_all_provisions_supplied!
+      end
+
+      def coerce_to_hash
+        return Hash(raw) unless provisions.size == 1
+        return raw if all_provisions_supplied? raw if raw.kind_of? Hash
+        raise MissingProvisionError.new provisions if raw.nil?
+        { provisions.first => raw }
+      end
+
+      def all_provisions_supplied? hsh = @hsh
+        provisions.all? &included_in_output(hsh)
+      end
+
+      def missing_provisions
+        provisions.reject &included_in_output
+      end
+
+      def included_in_output hsh = @hsh
+        hsh.keys.method :include?
+      end
+
+      def prune
+        hsh.select! do |key, _| provisions.include? key end
+      end
+
+      def ensure_all_provisions_supplied!
+        return if all_provisions_supplied?
+        raise MissingProvisionError.new missing_provisions
+      end
+    end
+  end
+end

data/lib/orchestra/node.rb

@@ -0,0 +1,130 @@
+module Orchestra
+  class Node
+    autoload :Output, "orchestra/node/output"
+
+    attr :collection, :dependencies, :provisions
+
+    def initialize args = {}
+      @provisions,
+      @collection,
+      @dependencies = Util.extract_key_args(
+        args,
+        :provides      => [],
+        :collection    => nil,
+        :dependencies  => [],
+      )
+    end
+
+    def required_dependencies
+      dependencies - optional_dependencies
+    end
+
+    def optional_dependencies
+      defaults.keys
+    end
+
+    def collection?
+      collection ? true : false
+    end
+
+    def perform input = {}
+      performance = Performance.new Conductor.new, {}, input
+      Performance::Movement.perform self, performance
+    end
+
+    def process raw_output
+      Output.process self, raw_output
+    end
+
+    class DelegateNode < Node
+      attr :adapter
+
+      def initialize adapter, args = {}
+        @adapter = adapter
+        super args
+      end
+
+      def build_context input
+        adapter.build_context input
+      end
+
+      def optional_dependencies
+        adapter.object_method.optional_dependencies
+      end
+    end
+
+    class InlineNode < Node
+      def self.build &block
+        builder = DSL::Nodes::Builder.new
+        DSL::Nodes::Context.evaluate builder, &block
+        builder.build_node
+      end
+
+      attr :context_class, :defaults, :perform_block
+
+      def initialize args = {}
+        @defaults = args.delete :defaults do {} end
+        @perform_block = args.fetch :perform_block
+        args.delete :perform_block
+        super args
+        @context_class = build_execution_context_class
+        validate!
+      end
+
+      def validate!
+        unless perform_block
+          raise ArgumentError, "expected inline node to define a perform block"
+        end
+      end
+
+      def build_execution_context_class
+        context = Class.new ExecutionContext
+        context.class_exec dependencies, collection do |deps, collection|
+          deps.each do |dep| define_dependency dep end
+          alias_method :fetch_collection, collection if collection
+        end
+        context
+      end
+
+      def build_context input
+        state = apply_defaults input
+        execution_context = context_class.new state, perform_block
+      end
+
+      def apply_defaults input
+        defaults.each do |key, thunk|
+          next if input.has_key? key
+          input[key] = thunk.call
+        end
+        input
+      end
+
+      def optional_dependencies
+        defaults.keys
+      end
+
+      class ExecutionContext
+        def self.define_dependency dep
+          define_method dep do
+            ivar = "@#{dep}"
+            return instance_variable_get ivar if instance_variable_defined? ivar
+            instance_variable_set ivar, @__state__[dep]
+          end
+        end
+
+        def initialize state, perform_block
+          @__perform_block__ = perform_block
+          @__state__ = state
+        end
+
+        def perform item = nil
+          if @__perform_block__.arity == 0
+            instance_exec &@__perform_block__
+          else
+            instance_exec item, &@__perform_block__
+          end
+        end
+      end
+    end
+  end
+end