fabrique 0.3.1 → 1.0.0

data/fixtures/sample/README.md

@@ -0,0 +1,36 @@
+# Sample
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/sample`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sample'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sample
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/sample.
+

data/fixtures/sample/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/fixtures/sample/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sample"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/fixtures/sample/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/fixtures/sample/lib/sample/version.rb

@@ -0,0 +1,3 @@
+module Sample
+  VERSION = "0.1.1"
+end

data/fixtures/sample/lib/sample.rb

@@ -0,0 +1,9 @@
+require "sample/version"
+
+module Sample
+  # Your code goes here...
+
+  def self.version
+    Sample::VERSION
+  end
+end

data/fixtures/sample/sample.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sample/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sample"
+  spec.version       = Sample::VERSION
+  spec.authors       = ["Sheldon Hearn"]
+  spec.email         = ["sheldonh@starjuice.net"]
+
+  spec.summary       = %q{Sample gem}
+  spec.description   = %q{Sample gem for testing software that uses gems}
+  spec.homepage      = "https://github.com/starjuice/fabrique"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/fabrique/bean_definition.rb

@@ -1,12 +1,12 @@
 module Fabrique
 
   class BeanDefinition
-    attr_reader :constructor_args, :factory_method, :id, :properties, :type
+    attr_reader :constructor_args, :factory_method, :gem, :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)
+      @type = attrs["class"]
+      @gem = GemDefinition.new(attrs["gem"]) if attrs["gem"]
       @constructor_args = attrs["constructor_args"] || []
       @constructor_args = keywordify(@constructor_args) if @constructor_args.is_a?(Hash)
       @properties = attrs["properties"] || {}
@@ -15,7 +15,7 @@ module Fabrique
     end
 
     def dependencies
-      (accumulate_dependencies(@constructor_args) + accumulate_dependencies(@properties)).uniq
+      (accumulate_dependencies(@type) + accumulate_dependencies(@constructor_args) + accumulate_dependencies(@properties)).uniq
     end
 
     def singleton?

data/lib/fabrique/bean_definition_registry.rb

@@ -15,12 +15,18 @@ module Fabrique
       @defs.detect { |d| d.id == bean_name }
     end
 
+    def get_definitions
+      @defs
+    end
+
+    def get_gem_definitions
+      @defs.collect(&:gem).compact
+    end
+
     def validate!
-      begin
-        tsort
-      rescue TSort::Cyclic => e
-        raise CyclicBeanDependencyError.new(e.message.gsub(/topological sort failed/, "cyclic bean dependency error"))
-      end
+      tsort
+    rescue TSort::Cyclic => e
+      raise CyclicBeanDependencyError.new(e.message.gsub(/topological sort failed/, "cyclic bean dependency error"))
     end
 
     private

data/lib/fabrique/bean_factory.rb

@@ -8,6 +8,7 @@ module Fabrique
     def initialize(registry)
       @registry = registry
       @registry.validate!
+      @gem_loader = GemLoader.new(@registry.get_gem_definitions)
       @singletons = {}
       @semaphore = Mutex.new
     end
@@ -18,6 +19,16 @@ module Fabrique
       end
     end
 
+    def load_gem_dependencies
+      @gem_loader.load_gems
+    end
+
+    def to_h
+      @semaphore.synchronize do
+        @registry.get_definitions.map { |defn| [defn.id, get_bean_unsynchronized(defn.id)] }.to_h
+      end
+    end
+
     private
 
       def get_bean_unsynchronized(bean_name)
@@ -27,38 +38,47 @@ module Fabrique
           return singleton
         end
 
-        get_bean_by_definition(defn).tap do |bean|
-          if defn.singleton?
-            @singletons[bean_name] = bean
-          end
+        bean = get_bean_by_definition(defn)
+        if defn.singleton?
+          @singletons[bean_name] = bean
         end
+        bean
       end
 
       def get_bean_by_definition(defn)
         if defn.factory_method == "itself"
-          # Support RUBY_VERSION < 2.2.0 (missing Kernel#itself)
-          return defn.type
+          return get_factory(defn)
         end
 
         bean = constructor_injection(defn)
         property_injection(bean, defn)
       end
 
+      def get_factory(defn)
+        if defn.type.is_a?(BeanReference)
+          get_bean_unsynchronized(defn.type.bean)
+        elsif defn.type.is_a?(Module)
+          defn.type
+        else
+          Module.const_get(defn.type)
+        end
+      end
+
       def constructor_injection(defn)
         args = resolve_bean_references(defn.constructor_args)
+        factory = get_factory(defn)
         if args.respond_to?(:keys)
-          bean = defn.type.send(defn.factory_method, args)
+          bean = factory.send(defn.factory_method, args)
         else
-          bean = defn.type.send(defn.factory_method, *args)
+          bean = factory.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
+        defn.properties.each do |k, v|
+          bean.send("#{k}=", resolve_bean_references(v))
         end
+        bean
       end
 
       def resolve_bean_references(data)
@@ -76,11 +96,12 @@ module Fabrique
         elsif data.is_a?(BeanReference)
           get_bean_unsynchronized(data.bean)
         elsif data.is_a?(BeanPropertyReference)
-          get_bean_unsynchronized(data.bean).send(data.property)
+          data.resolve(get_bean_unsynchronized(data.bean))
         else
           data
         end
       end
+
   end
 
 end

data/lib/fabrique/bean_property_reference.rb

@@ -4,8 +4,16 @@ module Fabrique
     attr :bean, :property
 
     def initialize(bean_property)
-      @bean, @property = bean_property.split('.')
+      chain = bean_property.split('.')
+      @bean = chain.first
+      @property_chain = chain.drop(1)
+      @property = @property_chain.join('.')
     end
+
+    def resolve(bean)
+      @property_chain.inject(bean) { |acc, property| acc.send(property) }
+    end
+
   end
 
 end

data/lib/fabrique/data_bean.rb

@@ -0,0 +1,62 @@
+# TODO underscore method names to reduce collision
+
+module Fabrique
+
+  class DataBean < BasicObject
+
+    def initialize(hash, name = nil)
+      @hash = hash
+      @name = name
+    end
+
+    def method_missing(sym, *args)
+      key = include?(sym)
+
+      raise_no_method_error(sym) if key.nil?
+      raise_argument_error(args) unless args.empty?
+
+      glide(sym, fetch(sym))
+    end
+
+    alias_method :send, :method_missing
+
+    def to_s
+      @name or ::Kernel.sprintf("0x%014x", __id__)
+    end
+
+    private
+
+    def glide(sym, v)
+      v.is_a?(::Hash) ? ::Fabrique::DataBean.new(v, "#{to_s}.#{sym}") : v
+    end
+
+    # TODO investigate possible optimization with Ruby 2.3 frozen strings
+    def fetch(sym)
+      if @hash.include?(sym)
+        @hash[sym]
+      elsif @hash.include?(sym.to_s)
+        @hash[sym.to_s]
+      else
+        raise_no_method_error(sym)
+      end
+    end
+
+    def include?(sym)
+      if @hash.include?(sym)
+        sym
+      elsif @hash.include?(sym.to_s)
+        sym.to_s
+      end
+    end
+
+    def raise_no_method_error(sym)
+      ::Kernel.raise ::NoMethodError.new("undefined method `#{sym}' for #<Fabrique::DataBean:#{to_s}>")
+    end
+
+    def raise_argument_error(args)
+      ::Kernel.raise ::ArgumentError.new("wrong number of arguments (given #{args.size}, expected 0)")
+    end
+
+  end
+
+end

data/lib/fabrique/gem_definition.rb

@@ -0,0 +1,15 @@
+module Fabrique
+
+  class GemDefinition
+
+    attr_reader :dependency, :required_as
+
+    def initialize(defn)
+      @dependency = Gem::Dependency.new(defn["name"], defn["version"] || Gem::Requirement.default)
+      @required_as = defn["require"] || defn["name"]
+    end
+
+  end
+
+end
+

data/lib/fabrique/gem_dependency_error.rb

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

data/lib/fabrique/gem_loader.rb

@@ -0,0 +1,25 @@
+module Fabrique
+
+  class GemLoader
+
+    def initialize(gem_definitions)
+      @gem_defs = gem_definitions
+      deps = @gem_defs.collect(&:dependency).reject { |x| not x.matching_specs.empty? }
+      @gem_set = Gem::RequestSet.new(*deps)
+    end
+
+    def load_gems
+      require "rubygems/dependency_installer"
+      @gem_set.resolve
+      specs = @gem_set.install(Gem::DependencyInstaller::DEFAULT_OPTIONS.merge(document: []))
+      specs.each do |spec|
+        spec.activate
+      end
+      @gem_defs.collect(&:required_as).each { |x| require x }
+    rescue Gem::DependencyError => e
+      raise GemDependencyError.new(e.message)
+    end
+
+  end
+
+end

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

@@ -6,13 +6,24 @@ module Fabrique
 
       module Constructors
 
+        class FactoryWithCreateMethod
+
+          def initialize(*args)
+          end
+
+          def create
+            ClassWithPositionalArgumentConstructor.new("factory size", "factory color", "factory shape")
+          end
+
+        end
+
         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
+          attr_accessor :size, :color, :shape, :object
 
         end
 

data/lib/fabrique/version.rb

@@ -1,3 +1,3 @@
 module Fabrique
-  VERSION = "0.3.1"
+  VERSION = "1.0.0"
 end

data/lib/fabrique.rb

@@ -1,7 +1,4 @@
 Dir[File.join(File.dirname(__FILE__), "fabrique", "*.rb")].each { |f| require_relative f }
-Dir[File.join(File.dirname(__FILE__), "fabrique", "construction", "*.rb")].each { |f| require_relative f }
-Dir[File.join(File.dirname(__FILE__), "fabrique", "constructor", "*.rb")].each { |f| require_relative f }
-Dir[File.join(File.dirname(__FILE__), "fabrique", "argument_adaptor", "*.rb")].each { |f| require_relative f }
 
 module Fabrique
 end

data/spec/fabrique/data_bean_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Fabrique::DataBean do
+
+  context "over a string-keyed hash" do
+
+    let(:wrapped) do
+      {
+        "string" => "string value",
+        "number" => 42,
+        "array" => %w[element1 element2 element3].freeze,
+        "hash" => {"key" => "value"}.freeze
+      }.freeze
+    end
+
+    subject { described_class.new(wrapped) }
+
+    it "provides direct method access to the values of top-level scalar keys" do
+      expect(subject.string).to eql wrapped["string"]
+      expect(subject.number).to eql wrapped["number"]
+      expect(subject.array).to eql wrapped["array"]
+    end
+
+    it "provides daisy-chained method access to the values of nested hash keys" do
+      expect(subject.hash.key).to eql wrapped["hash"]["key"]
+    end
+
+    it "raises NoMethodError for access to non-existent top-level keys" do
+      expect { subject.nosuchmethod }.to raise_error(NoMethodError, /undefined method `nosuchmethod' for /)
+    end
+
+    it "raises NoMethodError for access to non-existent nested keys" do
+      expect { subject.hash.nosuchnestedmethod }.to raise_error(NoMethodError, /undefined method `nosuchnestedmethod' for/)
+    end
+
+  end
+
+  context "over a symbol-keyed hash" do
+
+    let(:wrapped) do
+      {
+        string: "string value",
+        number: 42,
+        array: %w[element1 element2 element3].freeze,
+        hash: {key: "value"}.freeze
+      }.freeze
+    end
+
+    subject { described_class.new(wrapped) }
+
+    it "provides direct method access to the values of top-level scalar keys" do
+      expect(subject.string).to eql wrapped[:string]
+      expect(subject.number).to eql wrapped[:number]
+      expect(subject.array).to eql wrapped[:array]
+    end
+
+    it "provides daisy-chained method access to the values of nested hash keys" do
+      expect(subject.hash.key).to eql wrapped[:hash][:key]
+    end
+
+    it "raises NoMethodError for access to non-existent top-level keys" do
+      expect { subject.nosuchmethod }.to raise_error(NoMethodError, /undefined method `nosuchmethod' for /)
+    end
+
+    it "raises NoMethodError for access to non-existent nested keys" do
+      expect { subject.hash.nosuchnestedmethod }.to raise_error(NoMethodError, /undefined method `nosuchnestedmethod' for/)
+    end
+
+  end
+
+  context "regardless of wrapped hash" do
+
+    let(:wrapped) do
+      {
+        "meaning_of_life" => 42,
+        "object_id" => "The best object ever!",
+        "hash" => "A breakfast food type",
+        "top" => {middle: {"bottom" => {key: "value"}}}
+      }
+    end
+
+    subject { described_class.new(wrapped) }
+
+    it "goes out of its way to avoid method name collision" do
+      expect(subject.object_id).to eql wrapped["object_id"]
+      expect(subject.hash).to eql wrapped["hash"]
+    end
+
+    it "raises ArgumentError on known method access with arguments" do
+      expect { subject.meaning_of_life(42) }.to raise_error(ArgumentError, /wrong number of arguments \(given 1, expected 0\)/)
+    end
+
+    it "raises NoMethodError on unknown method access with arguments" do
+      expect { subject.nosuchmethod(42) }.to raise_error(NoMethodError, /undefined method `nosuchmethod' for /)
+    end
+
+    context "without a name" do
+
+      subject { described_class.new(wrapped) }
+
+      it "includes its string representation in NoMethodError messages" do
+        expect { subject.nosuchmethod }.to raise_error(/ for #<#{described_class}:#{subject.to_s}>/)
+      end
+
+      it "includes its string representation and nested keys daisy-chained in NoMethodError messages" do
+        expect { subject.top.middle.bottom.nosuchnestedmethod }.to raise_error(/ for #<#{described_class}:#{subject.to_s}.top.middle.bottom>/)
+      end
+
+    end
+
+    context "with a name" do
+
+      subject { described_class.new(wrapped, "config") }
+
+      it "includes its name in NoMethodError messages" do
+        expect { subject.nosuchmethod }.to raise_error(NoMethodError, / for #<#{described_class}:config>/)
+      end
+
+      it "includes its name and nested keys daisy-chained in NoMethodError messages" do
+        expect { subject.top.middle.bottom.nosuchnestedmethod }.to raise_error(/ for #<#{described_class}:config.top.middle.bottom>/)
+      end
+
+    end
+
+  end
+
+end