fabrique 0.0.0 → 0.0.1

data/lib/fabrique/argument_adaptor/positional.rb

@@ -0,0 +1,76 @@
+module Fabrique
+
+  module ArgumentAdaptor
+
+    # TODO Initialize with the name of the class we're adapting arguments for, for use in error messages
+    class Positional
+
+      def initialize(*argument_specifiers)
+        @positional_arguments = argument_specifiers.map { |spec| PositionalArgument.create(spec) }
+      end
+
+      def adapt(properties = {})
+        @positional_arguments.map { |argument| argument.pick(properties) }
+      end
+
+      class PositionalArgument
+
+        class Required
+          def initialize(arg)
+            @arg = arg
+          end
+
+          def pick(properties)
+            pick_or_do(properties) do
+              raise ArgumentError, "required argument #{@arg} missing from properties"
+            end
+          end
+
+          private
+
+          def pick_or_do(properties, &block)
+            if properties.include?(@arg)
+              properties[@arg]
+            else
+              block.call
+            end
+          end
+        end
+
+        class Optional < Required
+          def pick(properties)
+            pick_or_do(properties) do
+              raise ArgumentError, "optional argument #{@arg} (with no default) missing from properties"
+            end
+          end
+        end
+
+        class Default < Required
+          def initialize(arg, default)
+            @arg, @default = arg, default
+          end
+
+          def pick(properties)
+            pick_or_do(properties) { @default }
+          end
+        end
+
+        def self.create(specifier)
+          if specifier.is_a?(Symbol)
+            Required.new(specifier)
+          elsif specifier.is_a?(Array) and specifier.size == 1 and specifier[0].is_a?(Symbol)
+            Optional.new(*specifier)
+          elsif specifier.is_a?(Array) and specifier.size == 2 and specifier[0].is_a?(Symbol)
+            Default.new(*specifier)
+          else
+            raise ArgumentError.new("invalid argument specifier #{specifier}")
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/fabrique/bean_definition.rb

@@ -0,0 +1,46 @@
+module Fabrique
+
+  class BeanDefinition
+    attr_reader :constructor_args, :factory_method, :id, :properties, :type
+
+    def initialize(attrs = {})
+      @id = attrs["id"]
+      type_name = attrs["class"]
+      @type = type_name.is_a?(Module) ? @type_name : Module.const_get(type_name)
+      @constructor_args = attrs["constructor_args"] || []
+      @constructor_args = keywordify(@constructor_args) if @constructor_args.is_a?(Hash)
+      @properties = attrs["properties"] || {}
+      @scope = attrs["scope"] || "singleton"
+      @factory_method = attrs["factory_method"] || "new"
+    end
+
+    def dependencies
+      (dependencies_of(@constructor_args) + dependencies_of(@properties)).uniq
+    end
+
+    def singleton?
+      @scope == "singleton"
+    end
+
+    private
+
+      def keywordify(args)
+        args.inject({}) { |m, (k, v)| k = k.intern rescue k; m[k.intern] = v; m }
+      end
+
+      def dependencies_of(data, acc = [])
+        if data.is_a?(Hash)
+          dependencies_of(data.values, acc)
+        elsif data.is_a?(Array)
+          data.each do |o|
+            dependencies_of(o, acc)
+          end
+        elsif data.is_a?(BeanReference)
+          acc << data
+        end
+        acc
+      end
+
+  end
+
+end

data/lib/fabrique/bean_definition_registry.rb

@@ -0,0 +1,43 @@
+require "tsort"
+require_relative "bean_definition"
+require_relative "cyclic_bean_dependency_error"
+
+module Fabrique
+
+  class BeanDefinitionRegistry
+    include TSort
+
+    def initialize(definitions)
+      @defs = definitions.map { |d| d.is_a?(BeanDefinition) ? d : BeanDefinition.new(d) }
+    end
+
+    def get_definition(bean_name)
+      @defs.detect { |d| d.id == bean_name }
+    end
+
+    def validate!
+      begin
+        tsort
+      rescue TSort::Cyclic => e
+        raise CyclicBeanDependencyError.new(e.message.gsub(/topological sort failed/, "cyclic bean dependency error"))
+      end
+    end
+
+    private
+
+      def tsort_each_child(node, &block)
+        defn = get_definition(node)
+        deps = defn.dependencies
+        deps.map { |dep| dep.bean }.each(&block)
+      end
+
+      def tsort_each_node
+        @defs.each do |dep|
+          yield dep.id
+        end
+      end
+
+  end
+
+end
+

data/lib/fabrique/bean_factory.rb

@@ -0,0 +1,78 @@
+require "thread"
+
+module Fabrique
+
+  class BeanFactory
+    attr_reader :registry, :singletons
+
+    def initialize(registry)
+      @registry = registry
+      @registry.validate!
+      @singletons = {}
+      @semaphore = Mutex.new
+    end
+
+    def get_bean(bean_name)
+      @semaphore.synchronize do
+        get_bean_unsynchronized(bean_name)
+      end
+    end
+
+    private
+
+      def get_bean_unsynchronized(bean_name)
+        defn = @registry.get_definition(bean_name)
+
+        if defn.factory_method == "itself"
+          # Support RUBY_VERSION < 2.2.0 (missing Kernel#itself)
+          return defn.type
+        end
+
+        if defn.singleton? and singleton = @singletons[bean_name]
+          return singleton
+        end
+
+        bean = constructor_injection(defn)
+        property_injection(bean, defn)
+        if defn.singleton?
+          @singletons[bean_name] = bean
+        end
+        bean
+      end
+
+      def constructor_injection(defn)
+        args = resolve_bean_references(defn.constructor_args)
+        if args.respond_to?(:keys)
+          bean = defn.type.send(defn.factory_method, args)
+        else
+          bean = defn.type.send(defn.factory_method, *args)
+        end
+      end
+
+      def property_injection(bean, defn)
+        bean.tap do |b|
+          defn.properties.each do |k, v|
+            b.send("#{k}=", resolve_bean_references(v))
+          end
+        end
+      end
+
+      def resolve_bean_references(data)
+        if data.is_a?(Hash)
+          data.inject({}) do |memo, (k, v)|
+            memo[k] = resolve_bean_references(v)
+            memo
+          end
+        elsif data.is_a?(Array)
+          data.inject([]) do |acc, v|
+            acc << resolve_bean_references(v)
+          end
+        elsif data.is_a?(BeanReference)
+          get_bean_unsynchronized(data.bean)
+        else
+          data
+        end
+      end
+  end
+
+end

data/lib/fabrique/bean_reference.rb

@@ -0,0 +1,13 @@
+module Fabrique
+
+  class BeanReference
+
+    attr_reader :bean
+
+    def initialize(bean)
+      @bean = bean
+    end
+
+  end
+
+end

data/lib/fabrique/construction/as_is.rb

@@ -0,0 +1,16 @@
+module Fabrique
+
+  module Construction
+
+    class AsIs
+
+      def call(type, properties = nil)
+        raise ArgumentError.new("unexpected properties for as-is construction") unless (properties.nil? or properties.empty?)
+        type
+      end
+
+    end
+
+  end
+
+end

data/lib/fabrique/construction/builder_method.rb

@@ -0,0 +1,21 @@
+module Fabrique
+
+  module Construction
+
+    class BuilderMethod
+
+      def initialize(builder_method_name, &block)
+        @builder_method_name, @builder_runner = builder_method_name, block
+      end
+
+      def call(type, properties = {})
+        type.send(@builder_method_name) do |builder|
+          @builder_runner.call(builder, properties)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/fabrique/construction/default.rb

@@ -0,0 +1,17 @@
+require_relative "positional_argument"
+
+module Fabrique
+
+  module Construction
+
+    class Default < PositionalArgument
+
+      def initialize
+        super()
+      end
+
+    end
+
+  end
+
+end

data/lib/fabrique/construction/keyword_argument.rb

@@ -0,0 +1,16 @@
+module Fabrique
+
+  module Construction
+
+    # TODO Derive from PropertiesHash
+    class KeywordArgument
+
+      def call(type, properties)
+        type.new(properties)
+      end
+
+    end
+
+  end
+
+end

data/lib/fabrique/construction/positional_argument.rb

@@ -0,0 +1,40 @@
+module Fabrique
+
+  module Construction
+
+    class PositionalArgument
+
+      def initialize(*argument_names)
+        @argument_names = argument_names
+      end
+
+      def call(type, properties = nil)
+        if properties.nil?
+          type.new
+        else
+          type.new(*get_args(properties))
+        end
+      end
+
+      private
+
+        def get_args(properties)
+          @argument_names.inject([]) do |arguments, arg|
+            if arg.is_a?(Array)
+              arg.each do |optional_arg|
+                arguments << properties[optional_arg] if properties.include?(optional_arg)
+              end
+            elsif properties.include?(arg)
+              arguments << properties[arg]
+            else
+              raise ArgumentError, "required argument #{arg} missing from properties"
+            end
+            arguments
+          end
+        end
+
+    end
+
+  end
+
+end

data/lib/fabrique/construction/properties_hash.rb

@@ -0,0 +1,19 @@
+module Fabrique
+
+  module Construction
+
+    class PropertiesHash
+
+      def call(type, properties = nil)
+        if properties.nil?
+          type.new
+        else
+          type.new(properties)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/fabrique/constructor/identity.rb

@@ -0,0 +1,10 @@
+module Fabrique
+
+  module Constructor
+
+    class Identity
+    end
+
+  end
+
+end

data/lib/fabrique/cyclic_bean_dependency_error.rb

@@ -0,0 +1,6 @@
+module Fabrique
+
+  class CyclicBeanDependencyError < RuntimeError
+  end
+
+end

data/lib/fabrique/plugin_registry.rb

@@ -0,0 +1,56 @@
+module Fabrique
+
+  class PluginRegistry
+
+    def initialize(name)
+      @name = name
+      @registrations = []
+    end
+
+    def register(id, type, constructor)
+      if existing = find_registration(id)
+        raise ArgumentError, "could not register #{type} as #{id} in #{@name}: #{existing.type} already registered as #{id}"
+      end
+      @registrations << Registration.new(id, type, constructor)
+      true
+    end
+
+    def acquire(id, properties = nil)
+      if registration = find_registration(id)
+        registration.call_constructor(properties)
+      else
+        raise ArgumentError, "#{id} not registered in #{@name}"
+      end
+    end
+
+    private
+
+      def find_registration(id)
+        @registrations.detect { |r| r.id == id }
+      end
+
+      def unregister(id)
+        @registrations.delete(find_registration(id))
+      end
+
+      class Registration
+
+        attr_reader :id, :type, :constructor
+
+        def initialize(id, type, constructor)
+          @id, @type, @constructor = id, type, constructor
+        end
+
+        def call_constructor(properties = nil)
+          # TODO Push conditional into construction helpers
+          if properties.nil?
+            @constructor.call(@type)
+          else
+            @constructor.call(@type, properties)
+          end
+        end
+
+      end
+  end
+
+end

data/lib/fabrique/test/fixtures/constructors.rb

@@ -0,0 +1,81 @@
+module Fabrique
+
+  module Test
+
+    module Fixtures
+
+      module Constructors
+
+        class ClassWithProperties
+
+          DEFAULT_SIZE = "default size" unless defined?(DEFAULT_SIZE)
+          DEFAULT_COLOR = "default color" unless defined?(DEFAULT_COLOR)
+          DEFAULT_SHAPE = "default shape" unless defined?(DEFAULT_SHAPE)
+
+          attr_accessor :size, :color, :shape
+
+        end
+
+        class ClassWithDefaultConstructor < ClassWithProperties
+
+          def initialize
+            @size, @color, @shape = DEFAULT_SIZE, DEFAULT_COLOR, DEFAULT_SHAPE
+          end
+
+        end
+
+        OtherClassWithDefaultConstructor = Class.new(ClassWithDefaultConstructor)
+
+        class ClassWithPropertiesHashConstructor < ClassWithProperties
+
+          def initialize(properties)
+            @size, @color, @shape = properties[:size], properties[:color], properties[:shape]
+          end
+
+        end
+
+        class ClassWithPositionalArgumentConstructor < ClassWithProperties
+
+          def initialize(size, color, shape)
+            @size, @color, @shape = size, color, shape
+          end
+
+        end
+
+        class ClassWithKeywordArgumentConstructor < ClassWithProperties
+
+          def initialize(size: DEFAULT_SIZE, color: DEFAULT_COLOR, shape: DEFAULT_SHAPE)
+            @size, @color, @shape = size, color, shape
+          end
+
+        end
+
+        class ClassWithBuilderMethod < ClassWithProperties
+
+          private_class_method :new
+
+          def initialize(builder)
+            @size, @color, @shape = builder.size, builder.color, builder.shape
+          end
+
+          def self.build
+            builder = Builder.new
+            if block_given?
+              yield builder
+            end
+            new(builder)
+          end
+
+          class Builder
+            attr_accessor :size, :color, :shape
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/fabrique/test/fixtures/modules.rb

@@ -0,0 +1,35 @@
+module Fabrique
+
+  module Test
+
+    module Fixtures
+
+      module Modules
+
+        module ModuleWithStaticMethods
+
+          DEFAULT_SIZE = "module size" unless defined?(DEFAULT_SIZE)
+          DEFAULT_COLOR = "module color" unless defined?(DEFAULT_COLOR)
+          DEFAULT_SHAPE = "module shape" unless defined?(DEFAULT_SHAPE)
+
+          def self.size
+            DEFAULT_SIZE
+          end
+
+          def self.color
+            DEFAULT_COLOR
+          end
+
+          def self.shape
+            DEFAULT_SHAPE
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/fabrique/test/fixtures/opengl.rb

@@ -0,0 +1,37 @@
+module Fabrique
+
+  module Test
+
+    module Fixtures
+
+      module OpenGL
+
+        class Object
+
+          attr_reader :shader, :mesh, :scale
+
+          def initialize(shader, physical = {})
+            @shader = shader
+            @mesh = physical[:mesh]
+            @scale = physical[:scale]
+          end
+
+        end
+
+        class Mesh
+
+          attr_reader :vectors
+
+          def initialize(vectors = [])
+            @vectors = vectors
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end