dry-auto_inject 0.7.0

data/dry-auto_inject.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dry/auto_inject/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dry-auto_inject'
+  spec.version       = Dry::AutoInject::VERSION.dup
+  spec.authors       = ['Piotr Solnica']
+  spec.email         = ['piotr.solnica@gmail.com']
+  spec.license       = 'MIT'
+
+  spec.summary       = 'Container-agnostic automatic constructor injection'
+  spec.homepage      = 'https://github.com/dry-rb/dry-auto_inject'
+
+  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.required_ruby_version = '>= 2.4.0'
+
+  spec.add_runtime_dependency 'dry-container', '>= 0.3.4'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.8'
+end

data/lib/dry-auto_inject.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject'

data/lib/dry/auto_inject.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject/builder'
+
+module Dry
+  # Configure an auto-injection module
+  #
+  # @example
+  #    module MyApp
+  #      # set up your container
+  #      container = Dry::Container.new
+  #
+  #      container.register(:data_store, -> { DataStore.new })
+  #      container.register(:user_repository, -> { container[:data_store][:users] })
+  #      container.register(:persist_user, -> { PersistUser.new })
+  #
+  #      # set up your auto-injection function
+  #      AutoInject = Dry::AutoInject(container)
+  #
+  #      # define your injection function
+  #      def self.Inject(*keys)
+  #        AutoInject[*keys]
+  #      end
+  #    end
+  #
+  #    # then simply include it in your class providing which dependencies should be
+  #    # injected automatically from the configured container
+  #    class PersistUser
+  #      include MyApp::Inject(:user_repository)
+  #
+  #      def call(user)
+  #        user_repository << user
+  #      end
+  #    end
+  #
+  #    persist_user = container[:persist_user]
+  #
+  #    persist_user.call(name: 'Jane')
+  #
+  # @return [Proc] calling the returned proc builds an auto-injection module
+  #
+  # @api public
+  def self.AutoInject(container, options = {})
+    AutoInject::Builder.new(container, options)
+  end
+end

data/lib/dry/auto_inject/builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject/strategies'
+require 'dry/auto_inject/injector'
+
+module Dry
+  module AutoInject
+    class Builder < BasicObject
+      # @api private
+      attr_reader :container
+
+      # @api private
+      attr_reader :strategies
+
+      def initialize(container, options = {})
+        @container = container
+        @strategies = options.fetch(:strategies) { Strategies }
+      end
+
+      # @api public
+      def [](*dependency_names)
+        default[*dependency_names]
+      end
+
+      def respond_to?(name, include_private = false)
+        Builder.public_instance_methods.include?(name) || strategies.key?(name)
+      end
+
+      private
+
+      def method_missing(name, *args, &block)
+        if strategies.key?(name)
+          Injector.new(container, strategies[name], builder: self)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/dry/auto_inject/dependency_map.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Dry
+  module AutoInject
+    DuplicateDependencyError = Class.new(StandardError)
+    DependencyNameInvalid = Class.new(StandardError)
+
+    VALID_NAME = /([a-z_][a-zA-Z_0-9]*)$/
+
+    class DependencyMap
+      def initialize(*dependencies)
+        @map = {}
+
+        dependencies = dependencies.dup
+        aliases = dependencies.last.is_a?(Hash) ? dependencies.pop : {}
+
+        dependencies.each do |identifier|
+          name = name_for(identifier)
+          add_dependency(name, identifier)
+        end
+
+        aliases.each do |name, identifier|
+          add_dependency(name, identifier)
+        end
+      end
+
+      def inspect
+        @map.inspect
+      end
+
+      def names
+        @names ||= @map.keys
+      end
+
+      def to_h
+        @map.dup
+      end
+      alias_method :to_hash, :to_h
+
+      private
+
+      def name_for(identifier)
+        matched = VALID_NAME.match(identifier.to_s)
+        raise DependencyNameInvalid, "name +#{identifier}+ is not a valid Ruby identifier" unless matched
+        matched[0]
+      end
+
+      def add_dependency(name, identifier)
+        name = name.to_sym
+        raise DuplicateDependencyError, "name +#{name}+ is already used" if @map.key?(name)
+        @map[name] = identifier
+      end
+    end
+  end
+end

data/lib/dry/auto_inject/injector.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject/strategies'
+
+module Dry
+  module AutoInject
+    class Injector < BasicObject
+      # @api private
+      attr_reader :container
+
+      # @api private
+      attr_reader :strategy
+
+      # @api private
+      attr_reader :builder
+
+      # @api private
+      def initialize(container, strategy, builder:)
+        @container = container
+        @strategy = strategy
+        @builder = builder
+      end
+
+      def [](*dependency_names)
+        strategy.new(container, *dependency_names)
+      end
+
+      def respond_to?(name, include_private = false)
+        Injector.instance_methods.include?(name) || builder.respond_to?(name)
+      end
+
+      private
+
+      def method_missing(name, *args, &block)
+        builder.__send__(name)
+      end
+    end
+  end
+end

data/lib/dry/auto_inject/method_parameters.rb

@@ -0,0 +1,92 @@
+require 'set'
+
+module Dry
+  module AutoInject
+    # @api private
+    class MethodParameters
+      PASS_THROUGH = [[:rest]]
+
+      if RUBY_VERSION >= '2.4.4.' && !defined? JRUBY_VERSION
+        def self.of(obj, name)
+          Enumerator.new do |y|
+            begin
+              method = obj.instance_method(name)
+            rescue NameError
+            end
+
+            loop do
+              break if method.nil?
+
+              y << MethodParameters.new(method.parameters)
+              method = method.super_method
+            end
+          end
+        end
+      else
+        # see https://bugs.ruby-lang.org/issues/13973
+        def self.of(obj, name)
+          Enumerator.new do |y|
+            ancestors = obj.ancestors
+
+            loop do
+              klass = ancestors.shift
+              break if klass.nil?
+
+              begin
+                method = klass.instance_method(name)
+
+                next unless method.owner.equal?(klass)
+              rescue NameError
+                next
+              end
+
+              y << MethodParameters.new(method.parameters)
+            end
+          end
+        end
+      end
+
+      attr_reader :parameters
+
+      def initialize(parameters)
+        @parameters = parameters
+      end
+
+      def splat?
+        return @splat if defined? @splat
+        @splat = parameters.any? { |type, _| type == :rest }
+      end
+
+      def sequential_arguments?
+        return @sequential_arguments if defined? @sequential_arguments
+        @sequential_arguments = parameters.any? { |type, _|
+          type == :req || type == :opt
+        }
+      end
+
+      def keyword_names
+        @keyword_names ||= parameters.each_with_object(Set.new) { |(type, name), names|
+          names << name if type == :key || type == :keyreq
+        }
+      end
+
+      def keyword?(name)
+        keyword_names.include?(name)
+      end
+
+      def empty?
+        parameters.empty?
+      end
+
+      def length
+        parameters.length
+      end
+
+      def pass_through?
+        parameters.eql?(PASS_THROUGH)
+      end
+
+      EMPTY = new([])
+    end
+  end
+end

data/lib/dry/auto_inject/strategies.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'dry-container'
+
+module Dry
+  module AutoInject
+    class Strategies
+      extend Dry::Container::Mixin
+
+      # @api public
+      def self.register_default(name, strategy)
+        register name, strategy
+        register :default, strategy
+      end
+    end
+  end
+end
+
+require 'dry/auto_inject/strategies/args'
+require 'dry/auto_inject/strategies/hash'
+require 'dry/auto_inject/strategies/kwargs'

data/lib/dry/auto_inject/strategies/args.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject/strategies/constructor'
+require 'dry/auto_inject/method_parameters'
+
+module Dry
+  module AutoInject
+    class Strategies
+      # @api private
+      class Args < Constructor
+        private
+
+        def define_new
+          class_mod.class_exec(container, dependency_map) do |container, dependency_map|
+            define_method :new do |*args|
+              deps = dependency_map.to_h.values.map.with_index { |identifier, i|
+                args[i] || container[identifier]
+              }
+
+              super(*deps, *args[deps.size..-1])
+            end
+          end
+        end
+
+        def define_initialize(klass)
+          super_parameters = MethodParameters.of(klass, :initialize).each do |ps|
+            # Look upwards past `def foo(*)` methods until we get an explicit list of parameters
+            break ps unless ps.pass_through?
+          end
+
+          if super_parameters.empty?
+            define_initialize_with_params
+          else
+            define_initialize_with_splat(super_parameters)
+          end
+        end
+
+        def define_initialize_with_params
+          initialize_args = dependency_map.names.join(', ')
+
+          instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def initialize(#{initialize_args})
+              #{dependency_map.names.map { |name| "@#{name} = #{name}" }.join("\n")}
+              super()
+            end
+          RUBY
+        end
+
+        def define_initialize_with_splat(super_parameters)
+          super_pass = if super_parameters.splat?
+            '*args'
+          else
+            "*args.take(#{super_parameters.length})"
+          end
+
+          instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def initialize(*args)
+              #{dependency_map.names.map.with_index { |name, i| "@#{name} = args[#{i}]" }.join("\n")}
+              super(#{super_pass})
+            end
+          RUBY
+        end
+      end
+
+      register :args, Args
+    end
+  end
+end

data/lib/dry/auto_inject/strategies/constructor.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'dry/auto_inject/dependency_map'
+
+module Dry
+  module AutoInject
+    class Strategies
+      class Constructor < Module
+        ClassMethods = Class.new(Module)
+        InstanceMethods = Class.new(Module)
+
+        attr_reader :container
+        attr_reader :dependency_map
+        attr_reader :instance_mod
+        attr_reader :class_mod
+
+        def initialize(container, *dependency_names)
+          @container = container
+          @dependency_map = DependencyMap.new(*dependency_names)
+          @instance_mod = InstanceMethods.new
+          @class_mod = ClassMethods.new
+        end
+
+        # @api private
+        def included(klass)
+          define_readers
+
+          define_new
+          define_initialize(klass)
+
+          klass.send(:include, instance_mod)
+          klass.extend(class_mod)
+
+          super
+        end
+
+        private
+
+        def define_readers
+          instance_mod.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            attr_reader #{dependency_map.names.map { |name| ":#{name}" }.join(', ')}
+          RUBY
+          self
+        end
+
+        def define_new
+          raise NotImplementedError, "must be implemented by a subclass"
+        end
+
+        def define_initialize(klass)
+          raise NotImplementedError, "must be implemented by a subclass"
+        end
+      end
+    end
+  end
+end