yep 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f21f4ad7229428a808d252aa5a322ea640394d7db976c48a445ddbac5f6ebca9
+  data.tar.gz: a76b70a6723454e34bb2267e5644dec0fbb458228968a7dc85f6334b76469c4f
+SHA512:
+  metadata.gz: 3e254ea0a473f0a6dbfe5e2fe360f79224268efe5b882080cc4545c4f7bc781bab4b29744e90fce878e8d070c39f5aaea6b5deeec40c5993d21b275b3766c22d
+  data.tar.gz: 226abe945d27ca517e781b7d2c65bbc3d12b6f9b0768b83a63cb83b920bde019bd9c33a9e90b47ce362b75a5a05c9d0e56a075277028edf435dc671d5ddbecbb

data/.rubocop.yml

@@ -0,0 +1,22 @@
+AllCops:
+  TargetRubyVersion: 2.6
+Metrics/LineLength:
+  Max: 100
+Style/Documentation:
+  Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: false
+Layout/MultilineMethodCallIndentation:
+  Enabled: false
+Metrics/ModuleLength:
+  Exclude:
+    - "**/*test_*.rb"
+Metrics/BlockLength:
+  Exclude:
+    - "**/*test_*.rb"
+Lint/UselessComparison:
+  Exclude:
+    - "**/*test_*.rb"
+Layout/MultilineOperationIndentation:
+  Exclude:
+    - "**/*test_*.rb"

data/.ruby-version

@@ -0,0 +1 @@
+2.6.0

data/Gemfile

@@ -0,0 +1,7 @@
+source 'http://rubygems.org'
+
+group :development do
+  gem 'rubocop'
+end
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    yep (0.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ast (2.4.0)
+    jaro_winkler (1.5.2)
+    parallel (1.14.0)
+    parser (2.6.0.0)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
+    psych (3.1.0)
+    rainbow (3.0.0)
+    rubocop (0.65.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.5, != 2.5.1.1)
+      powerpack (~> 0.1)
+      psych (>= 3.1.0)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.4.0)
+    ruby-progressbar (1.10.0)
+    unicode-display_width (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rubocop
+  yep!
+
+BUNDLED WITH
+   2.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2017 yep
+
+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,202 @@
+# yep
+
+A simple, thread-safe dependency injection framework written in ruby.
+
+## Install
+
+From the command line
+```
+gem install yep
+```
+
+From a Gemfile
+```
+source 'http://rubygems.org'
+
+gem 'yep'
+```
+
+## Usage
+
+In the following example we will use a simple convoluted application that
+queries an external API for some data.
+
+```ruby
+require 'net/http'
+require 'json'
+
+class RandomUserRepository
+  class << self
+    def random
+      response = Net::HTTP.get(URI('https://randomuser.me/api'))    
+      JSON.parse(response)
+    end
+  end
+end
+```
+
+```ruby
+class User
+  attr_accessor :name
+
+  def random
+    users = RandomUserRepository.random
+    self.name = users['results'][0]['name']['first']
+    self
+  end 
+end
+```
+
+The problem with the code above is that the `User` class has a hard dependency
+on `RandomUserRepository`. This has two negative side effects. It would not be
+simple in a larger application to swap out the `RandomUserRepository` for
+another underlying repository such as `SqlUserRepository`. It's not simple
+to swap out the `RandomUserRepository` for testing purposes, maybe for
+something like `TestUserRepository`.
+
+So lets have a look at dependency injection with yep to see how this can be
+solved.
+
+### Container
+
+The container will hold dependencies registered under keys which can then later
+be resolved. Registration of dependencies should happen once for an application.
+
+```ruby
+require 'yep'
+
+class App
+
+  def self.boot
+    Yep::Container.add(:repository, RandomUserRepository,
+        Yep::Container::SINGLETON)
+    Yep::Container.add(:user, User, Yep::Container::INSTANCE)
+  end
+end
+
+App.boot
+```
+
+During registration we register a class under a key then assign a lifetime to
+the registered class. 
+
+If `Yep::Container::SINGLETON` is used as a lifetime, every time the dependency
+is resolved the container will return the same instance of a class.
+
+If `Yep::Container::INSTANCE` is used as a lifetime, every time the dependency
+is resolve the container will return a new instance of a class.
+
+### Injector
+
+Now the dependencies are registered to the container lets change the `User`
+class have the repository injected into the user class.
+
+```ruby
+class User
+  extend Yep::Inject
+
+  attr_accessor :name
+
+  inject(:repository)
+
+  def random
+    users = repository.random
+    self.name = users['results'][0]['name']['first']
+    self
+  end
+end
+```
+
+By extending `Yep::Inject` you then have access to call the `inject` method.
+By calling this method it will set an instance variable with the same key as the
+registered dependency, in this case `repository`. Now by calling
+`User.new.repository` the `RandomUserRepository` will be returned from the 
+container.
+
+If at anytime you wanted to swap out and use a different repository, as long
+as it has the same method signatures and return the same data structures, you
+can just change the dependency on the container.
+
+Example:
+
+A new repository that reads from a SQL database.
+
+```ruby
+class SqlUserRepository
+  include SomeSqlModule
+
+  class << self
+    def random
+      response = db.read('SELECT * FROM users LIMIT 1 ORDER BY RAND()')
+      JSON.parse(response)
+    end
+  end
+end
+```
+
+Change the dependency of repository during boot.
+
+```ruby
+require 'yep'
+
+class App
+
+  def self.boot
+    Yep::Container.add(:repository, SqlUserRepository,
+        Yep::Container::SINGLETON)
+    Yep::Container.add(:user, User, Yep::Container::INSTANCE)
+  end
+end
+
+App.boot
+```
+
+Now by calling `User.new.repository` the `SqlUerRepository` will be returned 
+from the container.
+
+*Note:* By calling `Yep::Container.resolve(:repository)` you can
+programmatically resolve a dependency from the container.
+
+### Testing
+
+During testing you may want to mock how the dependences are resolved.
+
+In this example we mock the Users repository call to return a reliable set of
+data for testing.
+
+```ruby
+class FakeUserRepository
+  class << self
+    def random
+      JSON.parse('{ "results": [ { "name": { "first": "FakeName" }}] }')
+    end
+  end
+end
+```
+
+```ruby
+require 'minitest/autorun'
+
+require 'yep'
+
+class TestUser < Minitest::Test
+  User.enable_dependency_mocks!
+
+  def test_name_is_set_after_random_is_called
+    user = User.new
+    user.mock(:repository, FakeUserRepository)
+    user.random
+
+    assert user.name == 'FakeName'
+    
+    user.unmock(:repository)
+  end
+```
+
+In this example the underlying repository is swapped out to make sure the call
+to `random` will return reliable data. After the test finished the repository
+is then unmocked (returned back to it's original state)
+
+## Licence
+
+See `LICENCE` file.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/testtask'
+require 'rubocop/rake_task'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+RuboCop::RakeTask.new
+
+desc 'Run tests'
+task default: :test

data/lib/yep.rb

@@ -0,0 +1,4 @@
+require 'rubygems' unless defined?(Gem)
+
+require 'yep/container'
+require 'yep/inject'

data/lib/yep/container.rb

@@ -0,0 +1,61 @@
+require 'monitor'
+
+module Yep
+  class Container
+    module ClassMethods
+      def add(name, clazz, lifetime = Container::INSTANCE)
+        instance.add(name: name, clazz: clazz, lifetime: lifetime)
+      end
+
+      def resolve(name)
+        instance.resolve(name: name)
+      end
+
+      private
+
+      def instance
+        @instance ||= new
+      end
+    end
+
+    extend ClassMethods
+    include MonitorMixin
+
+    INSTANCE = :instance
+    SINGLETON = :singleton
+
+    CannotResolveError = Class.new(StandardError)
+    AlreadyAddedError = Class.new(StandardError)
+
+    def initialize
+      super
+      @store ||= {}
+    end
+
+    def add(name:, clazz:, lifetime:)
+      synchronize do
+        raise(AlreadyAddedError, "Depenency with key #{name} already exists") \
+          if store.key?(name)
+
+        store[name] = {
+          class: clazz,
+          lifetime: lifetime
+        }
+      end
+    end
+
+    def resolve(name:)
+      synchronize do
+        object = store[name]
+        raise(CannotResolveError, "No dependency is mapped to key #{name}") \
+          if object.nil?
+
+        object[:lifetime] == INSTANCE ? object[:class].new : object[:class]
+      end
+    end
+
+    private
+
+    attr_reader :store
+  end
+end

data/lib/yep/inject.rb

@@ -0,0 +1,26 @@
+module Yep
+  module Inject
+    def inject(name)
+      variable = "@#{name}"
+      define_method(name) do
+        unless instance_variable_defined?(variable)
+          instance_variable_set(variable, Container.resolve(name))
+        end
+
+        instance_variable_get(variable)
+      end
+    end
+
+    def enable_dependency_mocks!
+      define_method(:mock) do |name, clazz|
+        variable = "@#{name}"
+        instance_variable_set(variable, clazz)
+      end
+
+      define_method(:unmock) do |name|
+        variable = "@#{name}"
+        instance_variable_set(variable, Container.resolve(name))
+      end
+    end
+  end
+end

data/lib/yep/version.rb

@@ -0,0 +1,3 @@
+module Yep
+  VERSION = '0.0.0'.freeze
+end

data/test/test_yep.rb

@@ -0,0 +1,73 @@
+require 'minitest/autorun'
+
+require 'yep'
+
+class TestYep < Minitest::Test
+  Yep::Container.add(:hash, Hash)
+  Yep::Container.add(:string, String)
+  Yep::Container.add(:math, Math, Yep::Container::SINGLETON)
+
+  def test_resolve_instance_always_returns_a_new_object
+    assert Yep::Container.resolve(:hash).object_id !=
+      Yep::Container.resolve(:hash).object_id
+  end
+
+  def test_resolve_singleton_always_returns_the_same_object
+    assert Yep::Container.resolve(:math).object_id ==
+      Yep::Container.resolve(:math).object_id
+  end
+
+  def test_resolve_should_raise_error_when_a_dependency_is_not_found
+    assert_raises Yep::Container::CannotResolveError do
+      Yep::Container.resolve(:foo)
+    end
+  end
+
+  def test_add_cannot_add_the_same_key_more_than_once
+    assert_raises Yep::Container::AlreadyAddedError do
+      Yep::Container.add(:hash, Hash)
+    end
+  end
+
+  class Injected
+    extend Yep::Inject
+
+    inject(:math)
+    inject(:string)
+
+    module ClassMethods
+      def instance
+        @instance ||= new
+      end
+    end
+
+    extend ClassMethods
+  end
+
+  Injected.enable_dependency_mocks!
+
+  def test_injector_injects_dependency
+    assert Injected.instance.math == Math
+  end
+
+  def test_injector_caches_the_injected_dependency
+    assert Injected.instance.string.object_id ==
+      Injected.instance.string.object_id
+  end
+
+  def test_injector_can_be_mocked
+    Injected.instance.mock(:math, Hash)
+
+    assert Injected.instance.math == Hash
+  end
+
+  def test_injector_can_be_unmocked
+    Injected.instance.mock(:math, Hash)
+
+    assert Injected.instance.math == Hash
+
+    Injected.instance.unmock(:math)
+
+    assert Injected.instance.math == Math
+  end
+end

data/yep.gemspec

@@ -0,0 +1,19 @@
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+require 'yep/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'yep'
+  s.version  = Yep::VERSION
+  s.authors  = ['Dan Watson']
+  s.email    = ['dan@paz.am']
+  s.homepage = 'https://github.com/dan-watson/yep'
+  s.summary  = 'Yep is a dependency injection framework written in ruby'
+
+  s.rubyforge_project = 'yep'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`
+    .split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: yep
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Dan Watson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-05 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- dan@paz.am
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/yep.rb
+- lib/yep/container.rb
+- lib/yep/inject.rb
+- lib/yep/version.rb
+- test/test_yep.rb
+- yep.gemspec
+homepage: https://github.com/dan-watson/yep
+licenses: []
+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: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Yep is a dependency injection framework written in ruby
+test_files: []