dependency_manager 0.0.1

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dependency_manager"
+
+# 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/dependency_manager.gemspec

@@ -0,0 +1,44 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "dependency_manager/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "dependency_manager"
+  spec.version       = DependencyManager::VERSION
+  spec.authors       = ["Brandon Weaver"]
+  spec.email         = ["keystonelemur@gmail.com"]
+
+  spec.summary       = %q{Dependency Management for applications with several dependencies}
+  spec.description   =
+    %q{Manages and loads large collections of dependencies and wraps them into a service container for later consumption}
+  spec.homepage      = "https://www.github/com/baweaver/dependency_manager"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://www.github/com/baweaver/dependency_manager"
+    spec.metadata["changelog_uri"] = "https://www.github/com/baweaver/dependency_manager/CHANGELOG.md"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # 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", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "guard-rspec", "~> 4.7"
+
+  spec.add_runtime_dependency "dry-schema", "~> 1.5"
+end

data/lib/dependency_manager.rb

@@ -0,0 +1,9 @@
+require "dependency_manager/version"
+
+require "dependency_manager/container"
+require "dependency_manager/dependency_tree"
+require "dependency_manager/factory"
+require "dependency_manager/resolver"
+
+module DependencyManager
+end

data/lib/dependency_manager/config_schema_macros.rb

@@ -0,0 +1,74 @@
+require 'dry/schema'
+
+module DependencyManager
+  # Class-level methods for validation of configurations
+  module ConfigSchemaMacros
+    # Hook for binding class-level methods to the child class
+    #
+    # @param klass [Class]
+    #   Factory to bind to
+    #
+    # @return [void]
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    # Runs validation against configuration without throwing errors
+    #
+    # @param target: configuration [Hash[Symbol, Any]]
+    #   Configuration to validate, defaulting to `configuration`
+    #
+    # @return [Dry::Validation::Result]
+    def validate(target: configuration)
+      self.class.validate(**target)
+    end
+
+    # Immediate return validation that will raise an exception if the contract
+    # is not fulfilled
+    #
+    # @param target: configuration [Hash[Symbol, Any]]
+    #   Configuration to validate, defaulting to `configuration`
+    #
+    # @raises [ArgumentError]
+    #   Failure
+    #
+    # @return [TrueClass]
+    #   Success
+    def validate!(target: configuration)
+      validation_result = validate(target: target)
+
+      return true if validation_result.success?
+
+      errors = validation_result
+        .errors
+        .map { |e| "#{e.path} #{e.text}" }
+        .join(', ')
+
+      raise ArgumentError, "Configuration is invalid: #{errors}"
+    end
+
+    module ClassMethods
+      # Class-level macro for validations
+      #
+      # @see https://dry-rb.org/gems/dry-validation
+      #
+      # @param &dry_schema [Proc]
+      #   Dry Schema to validate with
+      #
+      # @return [Dry::Schema]
+      def validate_with(&dry_schema)
+        @dry_schema = Dry::Schema.Params(&dry_schema)
+      end
+
+      # Runs validator
+      #
+      # @param **configuration [Hash[Symbol, Any]]
+      #   Hash to validate with schema
+      #
+      # @return [Dry::Validation::Result]
+      def validate(**configuration)
+        @dry_schema.call(configuration)
+      end
+    end
+  end
+end

data/lib/dependency_manager/container.rb

@@ -0,0 +1,119 @@
+require 'set'
+
+module DependencyManager
+  class Container
+    # A container should only be built once
+    class BuildOnceError < ArgumentError; end
+
+    # You can't add new dependencies after a build
+    class AddedFactoryAfterBuildError < ArgumentError; end
+
+    attr_reader :dependencies
+
+    # Creates a new Dependency Container
+    #
+    # @param app_context: [Any]
+    #   Contextual information for the currently running application
+    #
+    # @param configuration: [Hash[Symbol, Any]]
+    #   Hash of configuration values, typically loaded from a YAML or JSON file
+    #
+    # @param factories: Factory.factories [Array[Factory]]
+    #   All factories to build dependency chain from. This will default to the
+    #   `Factory.factories` method, which will grab all children of the base
+    #   `Factory` class.
+    #
+    # @return [Container]
+    def initialize(app_context:, configuration:, factories: Factory.factories)
+      @app_context = app_context
+      @configuration = configuration
+      @factories = factories.is_a?(Set) ? factories : Set[*factories]
+      @built = false
+    end
+
+    # Register a factory explicitly
+    #
+    # @param factory [type] [description]
+    #
+    # @return [type] [description]
+    def register(factory)
+      raise AddedFactoryAfterBuildError, "Cannot add Factories after Container has been built" if @built
+
+      @factories.add factory
+    end
+
+    # Builds all the dependencies from factories
+    #
+    # @return [Hash[Symbol, Any]]
+    #   Built resources
+    def build
+      raise BuildOnceError, "Cannot build more than once" if @built
+
+      @dependency_tree = dependency_tree
+      @ordered_factory_dependencies = dependency_tree.tsort
+
+      @dependencies = {}
+
+      # Take the ordered factories
+      @ordered_factory_dependencies.each do |factory_name|
+        # Get their associated class
+        factory = DependencyManager::Factory.get(factory_name)
+
+        # Figure out which dependencies we need, which are optional, and which
+        # will break the factory build coming up
+        resolved_dependencies = Resolver.new(
+          factory: factory,
+          loaded_dependencies: dependencies
+        ).resolve
+
+        # Create an instance of the factory including its resolved dependencies.
+        factory_instance = factory.new(
+          app_context:    @app_context,
+          factory_config: get_config(factory),
+          **resolved_dependencies
+        )
+
+        # ...and build the dependency based on the provided configuration options.
+        @dependencies[factory.dependency_name] = factory_instance.build
+      end
+
+      @built = true
+
+      @dependencies
+    end
+
+    # Fetch a dependency by name
+    #
+    # @param dependency [Symbol]
+    #
+    # @return [Any]
+    def fetch(dependency)
+      @dependencies.fetch(dependency)
+    end
+
+    # Listing of all dependencies
+    #
+    # @return [Hash[Symbol, Any]]
+    def to_h
+      @dependencies
+    end
+
+    def dependency_tree
+      DependencyTree.new(dependency_hash)
+    end
+
+    private def dependency_hash
+      @factories.map { |k| [k.name, k.factory_dependencies] }.to_h
+    end
+
+    # Gets the dependencies configuration from the master configuration.
+    #
+    # @param klass [Class]
+    #   Class to get configuration for
+    #
+    # @return [Hash[Symbol, Any]]
+    private def get_config(klass)
+      @configuration.fetch(klass.dependency_name, {})
+    end
+  end
+end

data/lib/dependency_manager/dependency_tree.rb

@@ -0,0 +1,29 @@
+require 'tsort'
+require 'delegate'
+
+module DependencyManager
+  # Dependency tree implementation using TSort to resolve the order in which
+  # factories should be run.
+  class DependencyTree < Delegator
+    include TSort
+
+    attr_reader :resources
+
+    # Allow access to the underlying hash
+    alias_method :__getobj__, :resources
+
+    def initialize(resources)
+      @resources = resources
+    end
+
+    # TSort interface method
+    def tsort_each_node(&block)
+      @resources.each_key(&block)
+    end
+
+    # TSort interface method
+    def tsort_each_child(node, &block)
+      @resources.fetch(node).each(&block)
+    end
+  end
+end

data/lib/dependency_manager/factory.rb

@@ -0,0 +1,257 @@
+require 'dependency_manager/config_schema_macros'
+require 'set'
+
+module DependencyManager
+  # Base for all other factories, providing interface hints and generic
+  # functionality
+  #
+  # ### Initialize for Dependency Specifications
+  #
+  # Every keyword argument used in the `initialize` function for a Factory
+  # is used to resolve the dependencies of the class with the exception of
+  # `CONTEXT_DEPENDENCIES`.
+  #
+  # `:keyreq` represents a required argument, while `:key` represents an
+  # optional one:
+  #
+  # ```ruby
+  # def initialize(logger:, optional_dependency: nil, **dependencies)
+  #   super(**dependencies)
+  #
+  #   @logger = logger
+  #   @optional_dependency = optional_dependency
+  # end
+  # ```
+  #
+  # This value could be `nil` or any other sane default value for the
+  # dependency specified.
+  #
+  # The `Factory` implements several helper methods on its singleton class
+  # like `dependencies`, `optional_dependencies`, and `factory_dependencies` to
+  # help with constructing dependency chains.
+  class Factory
+    # Methods for validating configurations
+    include ConfigSchemaMacros
+
+    # Dependencies that are always present and injected at a top level
+    # rather than by other factories
+    CONTEXT_DEPENDENCIES = %i(app_context factory_config)
+
+    # Keyword param types
+    KEYWORD_ARGS = %i(keyreq key)
+    OPTIONAL_ARG = :key
+
+    class << self
+      # Captures classes inheriting from Factory for later use
+      #
+      # @param subclass [Class]
+      #   The subclass
+      #
+      # @return [void]
+      def inherited(subclass)
+        @factories ||= Set.new
+        @factories.add subclass
+      end
+
+      # Get all available factory names except the Base factory
+      #
+      # @return [Array[Symbol]]
+      def factories
+        @factories || Set.new
+      end
+
+      # Get a factory by its underscored name
+      #
+      # @param factory_name [Symbol]
+      #
+      # @return [Symbol] Constant name
+      def get(factory_name)
+        const_name = constantize(factory_name)
+
+        unless const_defined?(const_name)
+          raise ArgumentError, "Tried to get non-existant Factory. Did you remember to define it?: #{const_name}"
+        end
+
+        const_get const_name
+      end
+
+      # Utility to constantize an underscored string or symbol
+      #
+      # @param s [String, Symbol]
+      #
+      # @return [Symbol]
+      def constantize(s)
+        s.to_s.split('_').map(&:capitalize).join.to_sym
+      end
+
+      def const_name
+        to_s.split('::').last
+      end
+
+      # Name of the factory
+      #
+      # @return [String]
+      def name
+        underscore const_name
+      end
+
+      # Name of the expected dependency to be generated
+      #
+      # @return [Symbol]
+      def dependency_name
+        name.to_s.sub(/_factory$/, '').to_sym
+      end
+
+      def parameters
+        instance_method(:initialize).parameters
+      end
+
+      # Dependencies of the class under the factory that it needs to initialize.
+      #
+      # @return [Array[Symbol]]
+      def dependencies
+        dependencies = parameters
+          .select { |type, _name| KEYWORD_ARGS.include?(type) }
+          .map(&:last)
+
+        dependencies - CONTEXT_DEPENDENCIES
+      end
+
+      # Dependencies of the factory itself to make sure factories load in the
+      # correct order.
+      #
+      # @return [Array[Symbol]]
+      def factory_dependencies
+        dependencies.map { |d| "#{d}_factory".to_sym }
+      end
+
+      # Dependencies required to build the factory
+      #
+      # @return [Array[Symbol]]
+      def required_dependencies
+        dependencies - optional_dependencies
+      end
+
+      # Optional arguments that are not strictly required, but used
+      # for additional functionality.
+      #
+      # @return [Array[Symbol]]
+      def optional_dependencies
+        optionals = parameters
+          .select { |type, _name| type == OPTIONAL_ARG }
+          .map(&:last)
+
+        optionals - CONTEXT_DEPENDENCIES
+      end
+
+      # Underscores a constant name
+      #
+      # @param const_name [Symbol]
+      #
+      # @return [Symbol]
+      def underscore(const_name)
+        const_name.gsub(/([^\^])([A-Z])/,'\1_\2').downcase.to_sym
+      end
+    end
+
+    # Creates a new Factory.
+    #
+    # @param app_context: nil [AppContext]
+    #   Application context information. Defaulted to `nil` in case users
+    #   do not need this information.
+    #
+    # @param factory_config: [Hash[Symbol, Any]]
+    #   Configuration specific to the factory
+    #
+    # @return [Factory]
+    def initialize(app_context: nil, factory_config:)
+      @app_context = app_context
+      @factory_config = factory_config
+    end
+
+    # Used to build the dependency
+    #
+    # @raise [NotImplementedError]
+    def build
+      raise NotImplementedError
+    end
+
+    # Used to generate configuration for the dependency,
+    # not always necessary for shorter builds.
+    #
+    # As a default will be an alias for `@factory_config`,
+    # and is used as a hook point for any validation.
+    #
+    # @raise [Hash[Symbol, Any]]
+    def configuration
+      @configuration ||= deep_merge(default_configuration, @factory_config)
+    end
+
+    # Default configuration of the Factory
+    #
+    # @return [Hash[Symbol, Any]]
+    def default_configuration
+      {}
+    end
+
+    # Used to load and require any associated external dependencies.
+    #
+    # @raise [NotImplementedError]
+    def load_requirements
+      raise NotImplementedError
+    end
+
+    # Whether or not the dependency should be enabled. It is suggested to
+    # use this as a guard when building dependencies:
+    #
+    # ```ruby
+    # def build
+    #   return unless enabled?
+    #
+    #   # ...
+    # end
+    # ```
+    #
+    # @return [FalseClass] Disabled by default
+    def enabled?
+      false
+    end
+
+    # Deeply merges two Hashes
+    #
+    # @param a [Hash]
+    #   Original Hash
+    #
+    # @param b [Hash]
+    #   Hash to merge
+    #
+    # @param &fn [Proc[Any, Any, Any]]
+    #   Merging function
+    #
+    # @return [Hash]
+    protected def deep_merge(a, b, &fn)
+      deep_merge!(a.dup, b.dup, &fn)
+    end
+
+    # Destructive merge of two hashes
+    #
+     # @param a [Hash]
+    #   Original Hash
+    #
+    # @param b [Hash]
+    #   Hash to merge
+    #
+    # @param &fn [Proc[Any, Any, Any]]
+    #   Merging function
+    #
+    # @return [Hash]
+    protected def deep_merge!(a, b, &fn)
+      a.merge!(b) do |key, left, right|
+        next deep_merge(left, right, &fn) if left.is_a?(Hash) && right.is_a?(Hash)
+        next fn.call(left, right, &fn) if block_given?
+
+        right
+      end
+    end
+  end
+end