injectable 0.0.5 → 1.0.0

data/Rakefile

@@ -1,30 +1,6 @@
-require "bundler"
-Bundler.setup
-
-require "rake"
+require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-require "injectable/version"
-
-task :gem => :build
-task :build do
-  system "gem build injectable.gemspec"
-end
-
-task :install => :build do
-  system "sudo gem install injectable-#{Injectable::VERSION}.gem"
-end
-
-task :release => :build do
-  system "git tag -a v#{Injectable::VERSION} -m 'Tagging #{Injectable::VERSION}'"
-  system "git push --tags"
-  system "gem push injectable-#{Injectable::VERSION}.gem"
-  system "rm injectable-#{Injectable::VERSION}.gem"
-end
-
-RSpec::Core::RakeTask.new("spec") do |spec|
-  spec.pattern = "spec/**/*_spec.rb"
-end
+RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "injectable"
+
+# 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(__FILE__)

data/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/injectable.gemspec

@@ -0,0 +1,28 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "injectable/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = 'injectable'
+  spec.version       = Injectable::VERSION
+  spec.authors       = %w(Papipo iovis9 jantequera amrocco)
+  spec.email         = %w(rodrigo@rubiconmd.com david.marchante@rubiconmd.com julio@rubiconmd.com anthony@rubiconmd.com)
+
+  spec.summary       = %q{A library to help you build nice service objects with dependency injection.}
+  spec.homepage      = 'https://github.com/rubiconmd/injectable'
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/injectable.rb

@@ -1,51 +1,62 @@
-# encoding: utf-8
-require "injectable/container"
-require "injectable/inflector"
-require "injectable/macros"
-require "injectable/registry"
+require 'injectable/version'
+require 'injectable/class_methods'
+require 'injectable/dependencies_graph'
+require 'injectable/dependencies_proxy'
+require 'injectable/dependency'
+require 'injectable/instance_methods'
+require 'injectable/missing_dependencies_exception'
 
-# Objects that include Injectable can have their dependencies satisfied by the
-# container, and removes some basic boilerplate code of creating basic
-# constructors that set instance variables on the class. Constructor injection
-# is the only available option here.
+# Convert your class into an injectable service
 #
-# @since 0.0.0
+# @example
+#   You would create a service like this:
+#
+#   class AddPlayerToTeamRoster
+#     include Injectable
+#
+#     dependency :team_query
+#     dependency :player_query, class: UserQuery
+#
+#     argument :team_id
+#     argument :player_id
+#
+#     def call
+#       player_must_exist!
+#       team_must_exist!
+#       team_must_accept_players!
+#
+#       team.add_to_roster(player)
+#     end
+#
+#     private
+#
+#     def player
+#       @player ||= player_query.call(player_id)
+#     end
+#
+#     def team
+#       @team ||= team_query.call(team_id)
+#     end
+#
+#     def player_must_exist!
+#       player.present? || raise UserNotFoundException
+#     end
+#
+#     def team_must_exist!
+#       team.present? || raise TeamNotFoundException
+#     end
+#
+#     def team_must_accept_players!
+#       team.accepts_players? || raise TeamFullException
+#     end
+#   end
+#
+#   And use it like this:
+#
+#   AddPlayerToTeamRoster.call(player_id: player.id, team_id: team.id)
 module Injectable
-
-  class << self
-
-    # Configure the global injectable registry. Simply just yields to the
-    # registry itself. If no block is provided returns the registry.
-    #
-    # @example Configure the registry.
-    #   Injectable.configure do |registry|
-    #     registry.register_implementation(:user, User)
-    #   end
-    #
-    # @return [ Injectable::Registry ] The registry.
-    #
-    # @since 0.0.3
-    def configure
-      block_given? ? yield(Registry) : Registry
-    end
-
-    # Including the Injectable module will extend the class with the necessary
-    # macros.
-    #
-    # @example Include the module.
-    #   class UserService
-    #     include Injectable
-    #   end
-    #
-    # @param [ Class ] klass The including class.
-    #
-    # @since 0.0.0
-    def included(klass)
-      Registry.register_implementation(
-        Inflector.underscore(klass.name).to_sym,
-        klass
-      )
-      klass.extend(Macros)
-    end
+  def self.included(base)
+    base.extend(Injectable::ClassMethods)
+    base.prepend(Injectable::InstanceMethods)
   end
 end

data/lib/injectable/class_methods.rb

@@ -0,0 +1,157 @@
+module Injectable
+  module ClassMethods
+    def self.extended(base)
+      base.class_eval do
+        simple_class_attribute :dependencies,
+                               :call_arguments,
+                               :initialize_arguments
+
+        self.dependencies = DependenciesGraph.new(namespace: base)
+        self.initialize_arguments = {}
+        self.call_arguments = {}
+      end
+    end
+
+    def inherited(base)
+      base.class_eval do
+        self.dependencies = dependencies.with_namespace(base)
+        self.initialize_arguments = initialize_arguments.dup
+        self.call_arguments = call_arguments.dup
+      end
+    end
+
+    # Blatantly stolen from rails' ActiveSupport.
+    # This is a simplified version of class_attribute
+    def simple_class_attribute(*attrs)
+      attrs.each do |name|
+        define_singleton_method(name) { nil }
+
+        ivar = "@#{name}"
+
+        define_singleton_method("#{name}=") do |val|
+          singleton_class.class_eval do
+            define_method(name) { val }
+          end
+
+          if singleton_class?
+            class_eval do
+              define_method(name) do
+                if instance_variable_defined? ivar
+                  instance_variable_get ivar
+                else
+                  singleton_class.send name
+                end
+              end
+            end
+          end
+          val
+        end
+      end
+    end
+
+    # Use the service with the params declared with '.argument'
+    # @param args [Hash] parameters needed for the Service
+    # @example MyService.call(foo: 'first_argument', bar: 'second_argument')
+    def call(args = {})
+      new.call(args)
+    end
+
+    # Declare dependencies for the service
+    # @param name [Symbol] the name of the service
+    # @option options [Class] :class The class to use if it's different from +name+
+    # @option options [Symbol, Array<Symbol>] :depends_on if the dependency has more dependencies
+    # @yield explicitly declare the dependency
+    #
+    # @return [Object] the injected dependency
+    #
+    # @example Using the same name as the service object
+    #   dependency :team_query
+    #     # => @team_query = TeamQuery.new
+    #
+    # @example Specifying a different class
+    #   dependency :player_query, class: UserQuery
+    #     # => @player_query = UserQuery.new
+    #
+    # @example With a block
+    #   dependency :active_players do
+    #     ->(players) { players.select(&:active?) }
+    #   end
+    #     # => @active_players = [lambda]
+    #
+    # @example With more dependencies
+    #   dependency :counter
+    #   dependency :team_service
+    #   dependency :player_counter, depends_on: [:counter, :team_service]
+    #     # => @counter = Counter.new
+    #     # => @team_service = TeamService.new
+    #     # => @player_counter = PlayerCounter.new(counter: @counter, team_service: @team_service)
+    #
+    # @example Dependencies that don't accept keyword arguments
+    #   dependency :counter
+    #   dependency :player_counter, depends_on: :counter do |counter:|
+    #     PlayerCounter.new(counter)
+    #   end
+    #     # => @counter = Counter.new
+    #     # => @player_counter = PlayerCounter.new(@counter)
+    def dependency(name, options = {}, &block)
+      options[:block] = block if block_given?
+      options[:depends_on] = Array(options.fetch(:depends_on, []))
+      options[:name] = name
+      dependencies.add(options)
+      define_method name do
+        instance_variable_get("@#{name}") || dependencies_proxy.get(name)
+      end
+    end
+
+    # Declare the arguments for `#call` and initialize the accessors
+    # This helps us clean up the code for memoization:
+    #
+    # ```
+    # private
+    #
+    # def player
+    #   # player_id exists in the context because we added it as an argument
+    #   @player ||= player_query.call(player_id)
+    # end
+    # ```
+    #
+    # Every argument is required unless given an optional default value
+    # @param name Name of the argument
+    # @option options :default The default value of the argument
+    # @example
+    #   argument :player_id
+    #     # => def call(player_id:)
+    #     # =>   @player_id = player_id
+    #     # => end
+    # @example with default arguments
+    #   argument :team_id, default: 1
+    #     # => def call(team_id: 1)
+    #     # =>   @team_id = team_id
+    #     # => end
+    def argument(name, options = {})
+      call_arguments[name] = options
+      attr_accessor name
+    end
+
+    def initialize_with(name, options = {})
+      initialize_arguments[name] = options
+      attr_accessor name
+    end
+
+    # Get the #initialize arguments declared with '.initialize_with' with no default
+    # @private
+    def required_initialize_arguments
+      find_required_arguments initialize_arguments
+    end
+
+    # Get the #call arguments declared with '.argument' with no default
+    # @private
+    def required_call_arguments
+      find_required_arguments call_arguments
+    end
+
+    def find_required_arguments(hash)
+      hash.reject { |_arg, options| options.key?(:default) }.keys
+    end
+  end
+end

data/lib/injectable/dependencies_graph.rb

@@ -0,0 +1,43 @@
+module Injectable
+  # Holds the dependency signatures of the service object
+  class DependenciesGraph
+    attr_reader :graph, :dependency_class, :proxy_class
+    attr_accessor :namespace
+
+    def initialize(namespace:,
+                   proxy_class: ::Injectable::DependenciesProxy,
+                   dependency_class: ::Injectable::Dependency)
+      @namespace = namespace
+      @graph = {}
+      @proxy_class = proxy_class
+      @dependency_class = dependency_class
+    end
+
+    def names
+      graph.keys
+    end
+
+    def with_namespace(namespace)
+      dup.tap { |dupe| dupe.namespace = namespace }
+    end
+
+    # Adds the signature of a dependency to the graph
+    def add(name:, depends_on:, **kwargs)
+      check_for_missing_dependencies!(depends_on)
+      graph[name] = dependency_class.new(kwargs.merge(name: name, depends_on: depends_on))
+    end
+
+    def proxy
+      proxy_class.new(graph: graph, namespace: namespace)
+    end
+
+    private
+
+    def check_for_missing_dependencies!(deps)
+      missing = deps.reject { |dep| graph.key?(dep) }
+      return if missing.empty?
+
+      raise Injectable::MissingDependenciesException, "missing dependencies: #{missing.join(', ')}"
+    end
+  end
+end

data/lib/injectable/dependencies_proxy.rb

@@ -0,0 +1,29 @@
+module Injectable
+  # Memoizes the Dependencies generated by Dependency based on DependencyGraph
+  class DependenciesProxy
+    attr_reader :graph, :namespace
+
+    def initialize(graph:, namespace: nil)
+      @graph = graph
+      @namespace = namespace
+      @instances = {}
+    end
+
+    # Get the instance of the dependency +name+
+    def get(name)
+      @instances[name] ||= graph[name].instance(args: memoized_dependencies_of(name), namespace: namespace)
+    end
+
+    private
+
+    def memoized_dependencies_of(name)
+      return [] if dependencies_of(name).empty?
+
+      dependencies_of(name).each_with_object({}) { |dep, hash| hash[dep] = get(dep) }
+    end
+
+    def dependencies_of(name)
+      graph[name].depends_on
+    end
+  end
+end

data/lib/injectable/dependency.rb

@@ -0,0 +1,40 @@
+module Injectable
+  # Initialize a dependency based on the options or the block passed
+  Dependency = Struct.new(:name, :block, :class, :call, :with, :depends_on, keyword_init: true) do
+    def instance(args: [], namespace: nil)
+      args = wrap_args(args)
+      wrap_call build_instance(args, namespace: namespace)
+    end
+
+    private
+
+    def wrap_args(args)
+      args = with unless with.nil?
+      args.is_a?(Array) ? args : [args]
+    end
+
+    def wrap_call(the_instance)
+      return the_instance unless call
+
+      lambda do |*args|
+        the_instance.public_send(call, *args)
+      end
+    end
+
+    def build_instance(args, namespace:)
+      block.nil? ? klass(namespace: namespace).new(*args) : block.call(*args)
+    end
+
+    def klass(namespace:)
+      self.class || resolve(namespace: namespace)
+    end
+
+    def resolve(namespace:)
+      (namespace || Object).const_get(camelcased)
+    end
+
+    def camelcased
+      @camelcased ||= name.to_s.split('_').map(&:capitalize).join
+    end
+  end
+end