codependent 0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9346a0d2621442d6fba3e69e244895fb5a4c22dc
+  data.tar.gz: ff00bf9084921b52e50dbeba357ff06a8eadcaa7
+SHA512:
+  metadata.gz: 4d9d0327496277dad897ce11b73abd6548ed3f97d107d17e1bc844958e35bb42191ecd5321c17a6c3c9ecd2ab04f5d4888de3224bcdb3026910f0f283fa33765
+  data.tar.gz: 3a8a641f957db178008be0848fde2813c10c15430cd79d3fa970962d95b5426efeaf3dda1feca61031f5c9ebe7c1122def7d9cf4c756816ce6f0e3bdb9d3384d

data/.gitignore

@@ -0,0 +1,51 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+.DS_Store
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.rubocop.yml

@@ -0,0 +1,17 @@
+inherit_from: .rubocop_todo.yml
+
+AllCops:
+  TargetRubyVersion: 2.3
+  Exclude:
+    - '**/Rakefile'
+    - '**/**/spec_helper.rb'
+    - '**/*.gemspec'
+
+Documentation:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/LambdaCall:
+  Enabled: false

data/.rubocop_todo.yml

@@ -0,0 +1,18 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2017-02-23 08:14:38 -0800 using RuboCop version 0.40.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 10
+# Configuration parameters: AllowHeredoc, AllowURI, URISchemes.
+# URISchemes: http, https
+Metrics/LineLength:
+  Max: 120
+
+# Offense count: 1
+# Configuration parameters: CountComments.
+Metrics/MethodLength:
+  Max: 11

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/Changelog.md

@@ -0,0 +1,5 @@
+## 0.1 - Initial Release
+
+### Features
+
+* Initial Release

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+group :development do
+  gem 'rspec'
+  gem 'pry'
+  gem 'pry-byebug'
+  gem 'rubocop', '~> 0.40.0', require: false
+  gem 'rake'
+  gem 'simplecov', require: false
+end

data/Gemfile.lock

@@ -0,0 +1,63 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.3.0)
+    byebug (9.0.5)
+    coderay (1.1.1)
+    diff-lcs (1.3)
+    docile (1.1.5)
+    json (2.0.2)
+    method_source (0.8.2)
+    parser (2.3.1.2)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-byebug (3.4.0)
+      byebug (~> 9.0)
+      pry (~> 0.10)
+    rainbow (2.1.0)
+    rake (11.2.2)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    rubocop (0.40.0)
+      parser (>= 2.3.1.0, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.1)
+    simplecov (0.12.0)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    slop (3.6.0)
+    unicode-display_width (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pry
+  pry-byebug
+  rake
+  rspec
+  rubocop (~> 0.40.0)
+  simplecov
+
+BUNDLED WITH
+   1.14.3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,170 @@
+# Codependent
+
+Codependent is a simple, lightweight dependency injection library for Ruby.
+
+[![Gem Version](https://badge.fury.io/rb/Codependent.png)](https://badge.fury.io/rb/Codependent)
+
+## Codependent by Example
+
+### Installation
+
+```
+gem install codependent
+```
+
+...or add Codependent to your Gemfile:
+
+```
+source 'https://rubygems.org'
+
+gem 'codependent'
+```
+
+### Basic Usage
+
+```ruby
+# Let's define some injectable types.
+Logger = Struct.new(:writer)
+
+class UserRepository
+  def initialize(logger:)
+    @logger = logger
+  end
+
+  attr_reader :logger
+end
+
+class AccountRepository
+  attr_accessor :logger, :user_repository
+end
+
+# Create & configure a container by passing a block to the constructor:
+container = Codependent::Container.new do
+  # Transient or "instance" dependencies are configured with a simple
+  # DSL.
+  instance :logger do
+    # You can inject simple values:
+    from_value Logger.new
+  end
+
+  # You can inject via the constructor:
+  singleton :user_repository do
+    from_type UserRepository
+    depends_on :logger
+  end
+
+  # Codependent will pass the dependencies to the type's constructor.
+  # The constructor needs to have keyword arguments that match the
+  # type's dependencies. Codependent will raise an error if the keyword
+  # arguments don't match the dependencies.
+
+  # You can also inject via setters, useful to handle circular dependencies:
+  singleton :account_repository do
+    from_type AccountRepository
+    inject_setters
+
+    # Multiple dependencies are supported:
+    depends_on :logger, :user_repository
+  end
+
+  # Codependent will call the setters to fill in the dependencies, and will
+  # raise an error if there aren't setters for each dependency.
+
+  # If you have an object with complex constructor requirements, you can
+  # use a provider function:
+  instance :db_connection do
+    # Codependent will pass the dependencies to the provider block in a Hash.
+    from_provider do |deps|
+      DB.open(deps[:connection_string])
+    end
+  end
+
+  # You can disable Codependent's type checking:
+  instance :unchecked_dependency
+    from_type MetaprogammingIsCool
+    skip_checks
+end
+
+# Now that we've got our IoC container all wired up, we can ask it to give
+# us instances of our types:
+a_logger = container.resolve :logger # => a new instance of Logger
+a_user_repo = container.resolve :user_repository # => An instance of UserRepository.
+an_account_repo = container.resolve :account_repository # => An instance of Account Repository
+
+# The user repository is defined as a singleton, so the references should be
+# pointing at the same object.
+expect(an_account_repo.user_repository).to eq(a_user_repo)
+
+# The logger is a new instance each time it's resolved, so these won't be the
+# same reference.
+expect(a_user_repo.logger).not_to eq(a_logger)
+```
+
+## Advanced Usage
+
+### Managing Containers
+
+```ruby
+# If you don't want to deal with managing the container yourself, Codependent
+# can do it for you.
+
+# You can create globally-accessible containers by giving the manager a name
+# and configuring the container:
+Codependent::Manager.container :my_container do
+  # This block is passed to a new container instance and uses the same syntax
+  # we've already seen.
+  instance :logger do
+    with_constructor { Logger.new }
+  end
+end
+
+# Access the container through the manager:
+a_logger = Codependent::Manager[:my_container].resolve(:logger)
+
+# Test to see if a container is defined:
+Codependent::Manager.container?(:my_container) # => True
+
+# You can reset a container you've defined back to it's original configuration:
+Codependent::Manager.reset_container!(:my_container)
+
+# ...or just remove all of them:
+Codependent::Manager.reset!
+```
+
+### Class Definition Syntax
+
+```ruby
+# Not everyone wants to configure the container up front. You can define your
+# dependencies in your class definitions with the Codependent Helper.
+class UserRepository
+  extend Codependent::Helper
+
+  # Tell Codependent what to call this injectable and how it should be resolved:
+  singleton :user_repository do
+    # The syntax here is the same as before.
+    with_constructor { self.new }
+    depends_on :logger
+  end
+end
+
+class Logger
+  extend Codependent::Helper
+
+  # You can also specify the managed container into which this type should be
+  # defined:
+  instance :logger, in_container: :my_container do
+    with_constructor { self.new }
+  end
+end
+```
+
+## Developing Codependent
+
+### Building from source
+
+1. Clone the repo.
+2. Install dependencies: `bundle install`
+3. Run the tests: `bundle exec rake ci`
+4. Build a local copy of the gem: `gem build codependent.gemspec`
+5. Install the gem locally: `gem install ./Codependent-0.1.gem`
+6. Don't forget to version-bump the gemspec before publishing!

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+end
+
+task ci: [:spec, :rubocop]

data/codependent.gemspec

@@ -0,0 +1,11 @@
+Gem::Specification.new do |s|
+  s.name        = 'codependent'
+  s.version     = '0.2'
+  s.date        = '2017-02-23'
+  s.summary     = "A simple dependency injection library for Ruby."
+  s.authors     = ["Joshua Tompkins"]
+  s.email       = 'josh@joshtompkins.com'
+  s.files       = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.homepage    = 'https://github.com/jtompkins/codependent'
+  s.license     = 'MIT'
+end

data/lib/codependent/container.rb

@@ -0,0 +1,60 @@
+require 'codependent/injectable'
+require 'codependent/resolvers/root_resolver'
+
+module Codependent
+  class Container
+    CONFIG_BLOCK_MISSING_ERROR = 'You must provide a config block.'.freeze
+
+    def initialize(&block)
+      @injectables = {}
+
+      instance_eval(&block) if block
+    end
+
+    def instance(id, &config_block)
+      validate_config_arguments(config_block)
+
+      add_injectable!(id, :instance, config_block)
+    end
+
+    def singleton(id, &config_block)
+      validate_config_arguments(config_block)
+
+      add_injectable!(id, :singleton, config_block)
+    end
+
+    def injectable(id)
+      injectables[id]
+    end
+
+    def injectable?(id)
+      injectables.key?(id)
+    end
+
+    def resolve(id)
+      return unless injectable?(id)
+
+      resolver.resolve(id)
+    end
+
+    private
+
+    attr_reader :injectables, :singleton_values
+
+    def resolver
+      Resolvers::RootResolver.new(injectables)
+    end
+
+    def validate_config_arguments(config_block)
+      raise ArgumentError, CONFIG_BLOCK_MISSING_ERROR unless config_block
+    end
+
+    def add_injectable!(id, type, config_block)
+      builder = Codependent::InjectableBuilder.new(type)
+
+      builder.instance_eval(&config_block)
+
+      injectables[id] = builder.build
+    end
+  end
+end

data/lib/codependent/injectable.rb

@@ -0,0 +1,39 @@
+module Codependent
+  class Injectable
+    def initialize(type, dependencies, state, resolver)
+      @type = type
+      @dependencies = dependencies
+      @state = state
+      @resolver = resolver
+      @singleton_value = nil
+    end
+
+    attr_reader :dependencies, :state, :resolver
+
+    def depends_on?(dependency_id)
+      @dependencies.include?(dependency_id)
+    end
+
+    def singleton?
+      @type == :singleton
+    end
+
+    def instance?
+      @type == :instance
+    end
+
+    def value(dependencies)
+      singleton? ? singleton_value(dependencies) : instance_value(dependencies)
+    end
+
+    private
+
+    def singleton_value(dependencies)
+      @singleton_value ||= instance_value(dependencies)
+    end
+
+    def instance_value(dependencies)
+      resolver.new.(state, dependencies)
+    end
+  end
+end

data/lib/codependent/injectable_builder.rb

@@ -0,0 +1,67 @@
+require 'codependent/injectable'
+
+require 'codependent/validators/value_validator'
+require 'codependent/validators/provider_validator'
+require 'codependent/validators/constructor_injection_validator'
+require 'codependent/validators/setter_injection_validator'
+
+require 'codependent/resolvers/eager_type_resolver'
+require 'codependent/resolvers/deferred_type_resolver'
+require 'codependent/resolvers/provider_resolver'
+require 'codependent/resolvers/value_resolver'
+
+module Codependent
+  class InjectableBuilder
+    def initialize(type)
+      @type = type
+      @dependencies = []
+      @state = {}
+      @skip_checks = false
+    end
+
+    attr_reader :type, :dependencies, :state, :validator, :resolver
+
+    def from_value(value)
+      @state = { value: value }
+      @validator = Validators::ValueValidator
+      @resolver = Resolvers::ValueResolver
+    end
+
+    def from_provider(&block)
+      @state = { provider: block }
+      @validator = Validators::ProviderValidator
+      @resolver = Resolvers::ProviderResolver
+    end
+
+    def from_type(klass, additional_args = nil)
+      @state = {
+        type: klass,
+        additional_args: additional_args
+      }
+
+      @validator = Validators::ConstructorInjectionValidator
+      @resolver = Resolvers::EagerTypeResolver
+    end
+
+    def inject_setters
+      @validator = Validators::SetterInjectionValidator
+      @resolver = Resolvers::DeferredTypeResolver
+    end
+
+    def skip_checks
+      @skip_checks = true
+    end
+
+    def depends_on(*dependencies)
+      @dependencies.concat(dependencies)
+    end
+
+    def build
+      return unless @validator
+
+      @validator.new.(@type, @state, @dependencies) unless @skip_checks
+
+      Injectable.new(@type, @dependencies, @state, @resolver)
+    end
+  end
+end

data/lib/codependent/manager.rb

@@ -0,0 +1,69 @@
+require 'codependent/container'
+
+module Codependent
+  class Manager
+    class << self
+      @instance = nil
+
+      def instance
+        @instance ||= Manager.new
+      end
+
+      def reset!
+        @instance = nil
+      end
+
+      def method_missing(method, *args, &block)
+        super unless instance.respond_to?(method)
+
+        @instance.send(method, *args, &block)
+      end
+    end
+
+    def container?(container_id)
+      containers.key?(container_id)
+    end
+
+    def reset_container!(container_id)
+      return unless container?(container_id)
+
+      config_block = containers[container_id][:config]
+      containers[container_id] = build_container(config_block)
+
+      get_container(container_id)
+    end
+
+    def container(container_id, &config_block)
+      unless container?(container_id)
+        containers[container_id] = build_container(config_block)
+      end
+
+      get_container(container_id)
+    end
+
+    def [](container_id)
+      get_container(container_id)
+    end
+
+    def global
+      get_container(:global)
+    end
+
+    private
+
+    def build_container(config_block = nil)
+      {
+        container: Codependent::Container.new(&config_block),
+        config: config_block
+      }
+    end
+
+    def get_container(container_id)
+      containers[container_id][:container]
+    end
+
+    def containers
+      @containers ||= { global: build_container }
+    end
+  end
+end

data/lib/codependent/resolvers/deferred_type_resolver.rb

@@ -0,0 +1,21 @@
+module Codependent
+  module Resolvers
+    class DeferredTypeResolver
+      def call(state, _)
+        state[:type].new
+      end
+
+      def apply(value, dependencies)
+        dependencies.each do |dep_id, dep|
+          value.send(to_setter(dep_id), dep)
+        end
+      end
+
+      private
+
+      def to_setter(id)
+        "#{id}=".to_sym
+      end
+    end
+  end
+end

data/lib/codependent/resolvers/eager_type_resolver.rb

@@ -0,0 +1,17 @@
+module Codependent
+  module Resolvers
+    class EagerTypeResolver
+      def call(state, dependency_hash)
+        constructor_args = dependency_hash.merge(state[:additional_args] || {})
+
+        type = state[:type]
+
+        if !constructor_args.empty?
+          type.new(**constructor_args)
+        else
+          type.new
+        end
+      end
+    end
+  end
+end

data/lib/codependent/resolvers/provider_resolver.rb

@@ -0,0 +1,9 @@
+module Codependent
+  module Resolvers
+    class ProviderResolver
+      def call(state, dependency_hash)
+        state[:provider].call(dependency_hash)
+      end
+    end
+  end
+end

data/lib/codependent/resolvers/root_resolver.rb

@@ -0,0 +1,84 @@
+require 'codependent/resolvers/deferred_type_resolver'
+
+module Codependent
+  module Resolvers
+    class RootResolver
+      def initialize(injectables)
+        @injectables = injectables
+      end
+
+      attr_reader :injectables
+
+      def resolve(id)
+        dependencies = build_dependency_graph(id)
+
+        resolved = resolve_eager_dependencies(dependencies)
+        resolve_deferred_dependencies!(resolved)
+
+        resolved[id]
+      end
+
+      private
+
+      def deferred?(injectable)
+        injectable.resolver == DeferredTypeResolver
+      end
+
+      def resolve_eager_dependencies(injectable_ids)
+        injectable_ids.reduce({}) do |acc, id|
+          acc.merge(id => resolve_value(id, acc))
+        end
+      end
+
+      def resolve_deferred_dependencies!(available_dependencies)
+        available_dependencies.keys.each do |id|
+          injectable = injectables[id]
+
+          next unless deferred?(injectable)
+
+          resolver = injectable.resolver.new
+
+          resolver.apply(
+            available_dependencies[id],
+            required_dependencies(available_dependencies, injectable)
+          )
+        end
+      end
+
+      def resolve_value(id, available_dependencies)
+        injectable = injectables[id]
+        dependencies = {}
+
+        unless deferred?(injectable)
+          dependencies = required_dependencies(
+            available_dependencies,
+            injectable
+          )
+        end
+
+        injectable.value(dependencies)
+      end
+
+      def required_dependencies(all_dependencies, injectable)
+        all_dependencies.select { |k, _| injectable.dependencies.include?(k) }
+      end
+
+      def build_dependency_graph(id)
+        stack = [id]
+        dependencies = [id]
+
+        until stack.empty?
+          current = injectables[stack.pop]
+
+          current.dependencies.each do |dep_id|
+            next if dependencies.include?(dep_id)
+            dependencies.unshift(dep_id)
+            stack.push(dep_id)
+          end
+        end
+
+        dependencies
+      end
+    end
+  end
+end

data/lib/codependent/resolvers/value_resolver.rb

@@ -0,0 +1,9 @@
+module Codependent
+  module Resolvers
+    class ValueResolver
+      def call(state, _)
+        state[:value]
+      end
+    end
+  end
+end

data/lib/codependent/validators/constructor_injection_validator.rb

@@ -0,0 +1,45 @@
+module Codependent
+  module Validators
+    class ConstructorInjectionValidator
+      MISSING_TYPE_ERROR = 'Constructor injection requires a type to be specified.'.freeze
+      MISSING_DEPENDENCY_KEYWORDS_ERROR = 'All dependencies must appear as keyword arguments to the constructor.'.freeze
+      NO_ARGS_WITH_DEPENDENCIES_ERROR = 'Constructor injection requires the constructor to receive arguments.'.freeze
+
+      def call(_, state, dependencies)
+        raise MISSING_TYPE_ERROR unless state[:type]
+
+        return unless dependencies.count > 0
+
+        validate_constructor_params(state[:type], dependencies)
+      end
+
+      private
+
+      def all_keywords?(params)
+        params.all? { |p| p[0] == :key || p[0] == :keyreq }
+      end
+
+      def extract_param_names(params)
+        params.map { |p| p[1] }
+      end
+
+      def params_for_all_dependencies?(dependencies, parameter_names)
+        (dependencies - parameter_names).empty?
+      end
+
+      def validate_constructor_params(klass, dependencies)
+        params = klass.instance_method(:initialize).parameters
+
+        raise NO_ARGS_WITH_DEPENDENCIES_ERROR if params.count == 0
+
+        return unless all_keywords?(params)
+
+        parameter_names = extract_param_names(params)
+
+        return if params_for_all_dependencies?(dependencies, parameter_names)
+
+        raise MISSING_DEPENDENCY_KEYWORDS_ERROR
+      end
+    end
+  end
+end

data/lib/codependent/validators/provider_validator.rb

@@ -0,0 +1,11 @@
+module Codependent
+  module Validators
+    class ProviderValidator
+      NO_BLOCK_ERROR = 'Provider injectables must have a block.'.freeze
+
+      def call(_, state, _)
+        raise NO_BLOCK_ERROR unless state[:provider]
+      end
+    end
+  end
+end

data/lib/codependent/validators/setter_injection_validator.rb

@@ -0,0 +1,26 @@
+module Codependent
+  module Validators
+    class SetterInjectionValidator
+      MISSING_TYPE_ERROR = 'Setter injection requires a type to be specified.'.freeze
+      MISSING_ACCESSOR_KEYWORDS_ERROR = 'All dependencies must appear as accessors on the class.'.freeze
+
+      def call(_, state, dependencies)
+        raise MISSING_TYPE_ERROR unless state[:type]
+
+        return unless dependencies.count > 0
+
+        validate_setters(state[:type], dependencies)
+      end
+
+      private
+
+      def validate_setters(klass, dependencies)
+        dependencies.each do |dep_id|
+          unless klass.method_defined? "#{dep_id}=".to_sym
+            raise MISSING_ACCESSOR_KEYWORDS_ERROR
+          end
+        end
+      end
+    end
+  end
+end

data/lib/codependent/validators/value_validator.rb

@@ -0,0 +1,18 @@
+module Codependent
+  module Validators
+    class ValueValidator
+      SINGLETON_ERROR = 'Value injectables are only allowed on singletons.'.freeze
+      NIL_VALUE_ERROR = 'Value injectables must not be nil.'.freeze
+      NO_DEPENDENCIES_ERROR = 'Value injectables may not have dependencies'.freeze
+
+      def call(type, state, dependencies)
+        raise SINGLETON_ERROR unless type == :singleton
+        raise NIL_VALUE_ERROR unless state[:value]
+
+        no_dependencies = !dependencies || dependencies.count != 0
+
+        raise NO_DEPENDENCIES_ERROR if no_dependencies
+      end
+    end
+  end
+end

data/lib/codependent.rb

@@ -0,0 +1,15 @@
+require 'codependent/manager'
+require 'codependent/container'
+require 'codependent/injectable'
+require 'codependent/injectable_builder'
+
+require 'codependent/resolvers/root_resolver'
+require 'codependent/resolvers/eager_type_resolver'
+require 'codependent/resolvers/deferred_type_resolver'
+require 'codependent/resolvers/provider_resolver'
+require 'codependent/resolvers/value_resolver'
+
+require 'codependent/validators/constructor_injection_validator'
+require 'codependent/validators/setter_injection_validator'
+require 'codependent/validators/provider_validator'
+require 'codependent/validators/value_validator'

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: codependent
+version: !ruby/object:Gem::Version
+  version: '0.2'
+platform: ruby
+authors:
+- Joshua Tompkins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-23 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: josh@joshtompkins.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".ruby-version"
+- Changelog.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- codependent.gemspec
+- lib/codependent.rb
+- lib/codependent/container.rb
+- lib/codependent/injectable.rb
+- lib/codependent/injectable_builder.rb
+- lib/codependent/manager.rb
+- lib/codependent/resolvers/deferred_type_resolver.rb
+- lib/codependent/resolvers/eager_type_resolver.rb
+- lib/codependent/resolvers/provider_resolver.rb
+- lib/codependent/resolvers/root_resolver.rb
+- lib/codependent/resolvers/value_resolver.rb
+- lib/codependent/validators/constructor_injection_validator.rb
+- lib/codependent/validators/provider_validator.rb
+- lib/codependent/validators/setter_injection_validator.rb
+- lib/codependent/validators/value_validator.rb
+homepage: https://github.com/jtompkins/codependent
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A simple dependency injection library for Ruby.
+test_files: []