shirinji 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 41ac63bcf3f6fd45d64dbcf12eafde69547eba1d
+  data.tar.gz: c07d6da743a36f3800f8a7a29bc3c8c6216368f1
+SHA512:
+  metadata.gz: 8060030b8a19b19d5b7abdc90fe8d9c1721851a2ea7c867d42ddb509f3d0d41e86865816a8caa5e1a61c10158be4aa7128be08a9a01384b48d7923e7dbbde133
+  data.tar.gz: caf8ca03a33a67c8feb56c9dd5fd57ba20b472dadc7930f00f3b565dad71e5beba3fba97948cf109dec20321b425c2e3af4d1173e90be887ecc4810368d0b263

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+.idea

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,2 @@
+Style/Documentation:
+  Enabled: false

data/.ruby-gemset

@@ -0,0 +1 @@
+shirinji

data/.ruby-version

@@ -0,0 +1 @@
+2.3.4

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.4
+before_install: gem install bundler -v 1.16.0

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in shirinji.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    shirinji (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (10.5.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  shirinji!
+
+BUNDLED WITH
+   1.16.1

data/README.md

@@ -0,0 +1,307 @@
+# Shirinji
+
+Container manager for dependency injection in Ruby.
+
+## Principles
+
+Dependencies Injection is strongly connected with the IOC (inversion of controls) pattern. IOC is
+often seen as a "Java thing" and tend to be rejected by Ruby community.
+
+Yet, it's heavily used in javascript world and fit perfectly with prototyped language.
+
+```javascript
+function updateUI(evt) { /* ... */ }
+
+$.ajax('/action', { onSuccess: updateUI, ... })
+```
+
+A simple script like that is very common in Javascript and nobody is shocked by that. Yet, it's 
+using the IOC pattern. The `$.ajax` method is delegating the action to perform when the request 
+is successful to something else, focusing only on handling the http communication part.
+
+Dependencies injection is nothing more than the exact same principle but applied to objects instead 
+of functions.
+
+Let's follow an example step by step from "the rails way" to a proper way to understand it better.
+
+```ruby
+class User < ActiveRecord::Base
+  after_create :publish_statistics, :send_confirmation_email
+  
+  private
+  
+  def publish_statistics
+    StatisticsGateway.publish_event(:new_user, user.id)
+  end
+  
+  def send_confirmation_email
+    UserMailer.confirm_email(user).deliver
+  end
+end
+```
+
+This is called "the rails way" and everybody with a tiny bit of experience knows that this way
+is not valid. Your model is gonna send statistics and emails each time it's saved, even when it's
+not in the context of signing up a new user (confusion between sign up, a business level operation 
+and create, a persistency level operation). There are plenty of situation where you actually don't
+want those operations to be performed (db seeding, imports, fixtures in tests ...)
+
+That's where services pattern comes to the rescue. Let's do it in a very simple fashion and just 
+move everything "as it is" in a service. 
+
+```ruby
+class SignUpUserService
+  def call(user)
+    user.signed_up_at = Time.now
+    user.save!
+    StatisticsGateway.publish_event(:new_user, user.id)
+    UserMailer.confirm_email(user).deliver  
+  end
+end
+
+## test
+
+RSpec.describe SignUpUserService do
+  let(:service) { described_class.new }
+  
+  describe '.call' do
+    let(:message_instance) { double(deliver: nil) }
+    let(:user) { FactoryGirl.build_stubbed(:user, id: 1) }
+  
+    before do
+      allow(StatisticsGateway).to receive(:publish_event)
+      allow(UserMailer).to receive(:confirm_email).and_return(message_instance) 
+    end
+    
+    it 'saves user' do
+      expect(user).to receive(:save!)
+      
+      service.call(user)
+    end
+    
+    it 'sets signed up time' do
+      service.call(user)
+      expect(user.signed_up_at).to_not be_nil
+      # there are better ways to test that but we don't care here
+    end
+    
+    it 'publishes statistics' do
+      expect(StatisticsGateway).to receive(:publish_event).with(:new_user, 1)
+      
+      service.call(user)
+    end
+    
+    it 'notifies user for identity confirmation' do
+      expect(UserMailer).to receive(:confirm_email).with(user)
+      expect(message_instance).to receive(:deliver)
+      
+      service.call(user)
+    end
+  end  
+end
+```
+
+It's a bit better. Now when we want to write a user in DB, it's not acting as a signup regardless
+the context. It will act as a sign up only when we call SignUpService.
+
+Yet, if we look a the tests for this service, we have to mock `StatisticsGateway` and
+`UserMailer` in order for the test to run properly. It means that we need a very precise knowledge
+of the implementation, and we need to mock global static objects which can be a very big problem
+(for example, if the same class is called twice in very different contexts in the same method)
+
+Also, if we decide to switch our statistics solution, or if we decide to change the way we notify
+users for identity confirmation, our test for signing up a user will have to change. 
+It shouldn't. The way we sign up users should not change according to the solution we chose to 
+send emails. 
+
+This demonstrate that our object has too many responsibilities. If you want to write efficient, 
+fast, scalable, readable ... code, you should restrict your objects to one and only one responsbility.
+
+```ruby
+class SignUpUserService
+  def call(user)
+    user.signed_up_at = Time.now
+    user.save!
+    
+    PublishUserStatisticsService.new.call(user)
+    SendUserEmailConfirmationService.new.call(user)
+    # implementation omitted for those services, you can figure it out  
+  end
+end
+```
+
+Now, our service has fewer responsibilities BUT, testing will be even harder because mocking `new`
+method on both "sub services" will be even more dirty than before.
+We can solve this problem very easily
+
+```ruby
+class SignUpUserService
+  def call(user)
+    user.signed_up_at = Time.now
+    user.save!
+    
+    publish_user_statistics_service.call(user)
+    send_user_email_confirmation_service.call(user)
+  end
+    
+  private
+  
+  def publish_user_statistics_service
+    PublishUserStatisticsService.new
+  end
+  
+  def send_user_email_confirmation_service
+    SendUserEmailConfirmationService.new
+  end
+end
+
+## test
+
+RSpec.describe SignUpUserService do
+  let(:publish_statistics_service) { double(call: nil) }
+  let(:send_email_confirmation_service) { double(call: nil) }
+  
+  let(:service) { described_class.new }
+  
+  before do
+    allow(service).to receive(:publish_user_statistics_service).and_return(publish_statistics_service)
+    allow(service).to receive(:send_user_email_confirmation_service).and_return(send_email_confirmation_service)
+  end
+  
+  # ...
+end
+```
+
+Our tests are now much easier to write. They're also much faster because our test is very specialized
+and focus only on the service itself.
+But if you think about it, this service still has too many responsibilities. It still carrying the 
+responsibility of choosing which service will execute the "sub tasks" and more important, it's in
+charge of creating those services instances.
+
+Instead of having strong dependencies to other services, we can make them "weak" and increase our
+code flexibility if we want to reuse it in another project.
+
+```ruby
+class SignUpUserService
+  attr_reader :publish_user_statistics_service,
+              :send_user_email_confirmation_service
+              
+  def initialize(
+    publish_user_statistics_service:,
+    send_user_email_confirmation_service:, 
+  )
+    @publish_user_statistics_service = publish_user_statistics_service
+    @send_user_email_confirmation_service = send_user_email_confirmation_service
+  end
+
+  def call(user)
+    user.signed_up_at = Time.now
+    user.save!
+    
+    publish_user_statistics_service.call(user)
+    send_user_email_confirmation_service.call(user)
+  end
+end
+```
+
+Now our service is completely agnostic about which solution is used to perform the "sub tasks".
+It's the responsibility of it's environment to provide this information. 
+
+But in a real world example, building such a tree is a complete nightmare and impossible to
+maintain. It's where Shiringji comes to the rescue.  
+
+## Usage
+
+```ruby
+map = Shirinji::Map.new do
+  bean(:sign_up_user_service, klass: "SignUpUserService")
+  bean(:publish_user_statistics_service, klass: "PublishUserStatisticsService")
+  bean(:send_user_email_confirmation_service, klass: "SendUserEmailConfirmationService")
+end
+
+resolver = Shirinji::Resolver.new(map)
+
+resolver.resolve(:sign_up_user_service)
+#=> <#SignUpUserService @publish_user_statistics_service=<#PublishUserStatisticsService ...> ...> 
+```
+
+In this example, because `SingUpUserService` constructor parameters match beans with the same name,
+Shirinji will automatically resolve them. 
+
+In a case where a parameter name match no bean, it has to be mapped explicitly.
+
+```ruby
+map = Shirinji::Map.new do
+  bean(:sign_up_user_service, klass: "SignUpUserService") do
+    attr :publish_user_statistics_service, ref: :user_publish_statistics_service
+  end
+  
+  # note the name is different
+  bean(:user_publish_statistics_service, klass: "PublishUserStatisticsService")
+  bean(:send_user_email_confirmation_service, klass: "SendUserEmailConfirmationService")
+end
+
+resolver = Shirinji::Resolver.new(map)
+
+resolver.resolve(:sign_up_user_service)
+#=> <#SignUpUserService @publish_user_statistics_service=<#PublishUserStatisticsService ...> ...> 
+```
+
+Shirinji also provide a caching mecanism to achieve singleton pattern without having to implement
+the pattern in your classes. It means the same class can be used as a singleton AND a regular class 
+at the same time without any code change.
+
+Singleton is the default access mode for a bean.
+
+```ruby
+map = Shirinji::Map.new do
+  bean(:foo, klass: 'Foo', access: :singleton) # foo is singleton
+  bean(:bar, klass: 'Bar', access: :instance) # bar is not
+end
+
+resolver = Shirinji::Resolver.new(map)
+
+resolver.resolve(:foo).object_id #=> 1
+resolver.resolve(:foo).object_id #=> 1
+
+resolver.resolve(:bar).object_id #=> 2 
+resolver.resolve(:bar).object_id #=> 3 
+```
+
+You can also create beans that contain single values. It will help you to avoid referencing global 
+variables in your code.
+
+```ruby
+map = Shirinji::Map.new do
+  bean(:config, value: Proc.new { Application.config })
+  bean(:foo, klass: 'Foo')
+end
+
+resolver = Shirinji::Resolver.new(map)
+
+class Foo
+  attr_reader :config
+  
+  def initialize(config:)
+    @config = config
+  end
+end
+
+resolver.resolve(:foo)
+#=> <#Foo @config=<#OpenStruct ...> ...>
+```
+
+Values can be anything. A `Proc` will be lazily evaluated. They also obey the singleton / instance
+strategy.
+
+## Notes
+
+- It is absolutely mandatory for your beans to be stateless to use the singleton mode. If they're
+  not, you will probably run into trouble as your objects behavior will depend on their history, leading
+  to unpredictable effects.
+- Shirinji only works with named arguments. It will raise errors if you try to use it with "standard"
+  method arguments.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/fdutey/shirinji.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'shirinji'
+
+# 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/lib/shirinji/attribute.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Shirinji
+  class Attribute
+    attr_reader :name, :reference
+
+    def initialize(name, reference)
+      @name = name
+      @reference = reference
+    end
+  end
+end

data/lib/shirinji/bean.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Shirinji
+  class Bean
+    attr_reader :name, :class_name, :value, :access, :attributes
+
+    def initialize(name, class_name: nil, value: nil, access:, &block)
+      check_params!(class_name, value)
+
+      @name = name
+      @class_name = class_name
+      @value = value
+      @access = access
+      @attributes = {}
+
+      instance_eval(&block) if block
+    end
+
+    def attr(name, ref:)
+      attributes[name] = Attribute.new(name, ref)
+    end
+
+    private
+
+    def check_params!(class_name, value)
+      msg = if class_name && value
+              'you can use either `class_name` or `value` but not both'
+            elsif !class_name && !value
+              'you must pass either `class_name` or `value`'
+            end
+
+      raise ArgumentError, msg if msg
+    end
+  end
+end

data/lib/shirinji/map.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Shirinji
+  class Map
+    attr_reader :beans
+
+    def initialize(&block)
+      @beans = {}
+
+      instance_eval(&block)
+    end
+
+    # Returns a bean based on its name
+    #
+    # @example accessing a bean
+    #   map.get(:foo)
+    #   #=> <#Shirinji::Bean ....>
+    #
+    # @example accessing a bean that doesn't exist
+    #   map.get(:bar)
+    #   #=> raises ArgumentError (unknown bean)
+    #
+    # @param name [Symbol, String] the name of the bean you want to access to
+    # @return [Bean] A bean with the given name or raises an error
+    # @raise [ArgumentError] if trying to access a bean that doesn't exist
+    def get(name)
+      bean = beans[name.to_sym]
+      raise ArgumentError, "Unknown bean #{name}" unless bean
+      bean
+    end
+
+    # Add a bean to the map
+    #
+    # @example build a class bean
+    #   map.bean(:foo, klass: 'Foo', access: :singleton)
+    #
+    # @example build a class bean with attributes
+    #   map.bean(:foo, klass: 'Foo', access: :singleton) do
+    #     attr :bar, ref: :baz
+    #   end
+    #
+    # @example build a value bean
+    #   map.bean(:bar, value: 5)
+    #
+    # @example build a lazy evaluated value bean
+    #   map.bean(:bar, value: Proc.new { 5 })
+    #
+    # @param name [Symbol] the name you want to register your bean
+    # @option [String] :klass the classname the bean is registering
+    # @option [*] :value the object registered by the bean
+    # @option [Symbol] :access either :singleton or :instance.
+    # @yield additional method to construct our bean
+    # @raise [ArgumentError] if trying to register a bean that already exist
+    def bean(name, klass: nil, value: nil, access: :singleton, &block)
+      name = name.to_sym
+
+      raise_if_name_already_taken!(name)
+
+      options = {
+        access: access,
+        class_name: klass ? klass.freeze : nil,
+        value: value
+      }
+
+      beans[name] = Bean.new(name, **options, &block)
+    end
+
+    # Scopes a given set of bean to the default options
+    #
+    # @example module
+    #   scope(module: :Foo) do
+    #     bean(:bar, klass: 'Bar')
+    #   end
+    #
+    #   #=> bean(:bar, klass: 'Foo::Bar')
+    #
+    # @example prefix
+    #   scope(prefix: :foo) do
+    #     bean(:bar, klass: 'Bar')
+    #   end
+    #
+    #   #=> bean(:foo_bar, klass: 'Bar')
+    #
+    # @example suffix
+    #   scope(suffix: :bar) do
+    #     bean(:foo, klass: 'Foo')
+    #   end
+    #
+    #   #=> bean(:foo_bar, klass: 'Foo')
+    #
+    # @example class suffix
+    #   scope(klass_suffix: :Bar) do
+    #     bean(:foo, klass: 'Foo')
+    #   end
+    #
+    #   #=> bean(:foo, klass: 'FooBar')
+    #
+    # It comes pretty handy when used with strongly normative naming
+    #
+    # @example services
+    #   scope(module: :Services, klass_suffix: :Service, suffix: :service) do
+    #     scope(module: :User, prefix: :user) do
+    #       bean(:signup, klass: 'Signup')
+    #       bean(:ban, klass: 'Ban')
+    #     end
+    #   end
+    #
+    #   #=> bean(:user_signup_service, klass: 'Services::User::SignupService')
+    #   #=> bean(:user_ban_service, klass: 'Services::User::BanService')
+    #
+    # @param options [Hash]
+    # @option options [Symbol] :module prepend module name to class name
+    # @option options [Symbol] :prefix prepend prefix to bean name
+    # @option options [Symbol] :suffix append suffix to bean name
+    # @option options [Symbol] :klass_suffix append suffix to class name
+    # @yield a standard map
+    def scope(**options, &block)
+      Scope.new(self, **options, &block)
+    end
+
+    private
+
+    def raise_if_name_already_taken!(name)
+      return unless beans[name]
+      msg = "A bean already exists with the following name: #{name}"
+      raise ArgumentError, msg
+    end
+  end
+end

data/lib/shirinji/resolver.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Shirinji
+  class Resolver
+    ARG_TYPES = %i[key keyreq].freeze
+
+    attr_reader :map, :singletons
+
+    def initialize(map)
+      @map = map
+      @singletons = {}
+    end
+
+    def resolve(name)
+      bean = map.get(name)
+
+      if bean.access == :singleton
+        single = singletons[name]
+        return single if single
+      end
+
+      resolve_bean(bean).tap do |instance|
+        singletons[name] = instance if bean.access == :singleton
+      end
+    end
+
+    def reset_cache
+      @singletons = {}
+    end
+
+    private
+
+    def resolve_bean(bean)
+      send(:"resolve_#{bean.value ? :value : :class}_bean", bean)
+    end
+
+    def resolve_value_bean(bean)
+      bean.value.is_a?(Proc) ? bean.value.call : bean.value
+    end
+
+    def resolve_class_bean(bean)
+      klass, params = resolve_class(bean)
+      return klass.new if params.empty?
+
+      check_params!(params)
+
+      args = params.each_with_object({}) do |(_type, arg), memo|
+        memo[arg] = bean(resolve_attribute(bean, arg))
+      end
+
+      klass.new(**args)
+    end
+
+    def resolve_class(bean)
+      klass = bean.class_name.constantize
+      construct = klass.instance_method(:initialize)
+
+      [klass, construct.parameters]
+    end
+
+    def resolve_attribute(bean, arg)
+      (attr = bean.attributes[arg]) ? attr.reference : arg
+    end
+
+    def check_params!(params)
+      params.each do |pair|
+        next if ARG_TYPES.include?(pair.first)
+        raise ArgumentError, 'Only key arguments are allowed'
+      end
+    end
+  end
+end

data/lib/shirinji/scope.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Shirinji
+  class Scope
+    VALID_OPTIONS = %i[module prefix suffix klass_suffix].freeze
+
+    attr_reader :parent, :mod, :prefix, :suffix, :klass_suffix
+
+    def initialize(parent, **options, &block)
+      validate_options(options)
+
+      @parent = parent
+      @mod = options[:module]
+      @prefix = options[:prefix]
+      @suffix = options[:suffix]
+      @klass_suffix = options[:klass_suffix]
+
+      instance_eval(&block) if block
+    end
+
+    def bean(name, klass: nil, value: nil, access: :singleton, &block)
+      chunks = [mod, "#{klass}#{klass_suffix}"].compact
+      options = {
+        access: access,
+        klass: klass ? chunks.join('::') : nil,
+        value: value
+      }
+
+      parent.bean([prefix, name, suffix].compact.join('_'), **options, &block)
+    end
+
+    def scope(**options, &block)
+      Scope.new(self, **options, &block)
+    end
+
+    private
+
+    def validate_options(args)
+      args.each_key do |k|
+        next if Shirinji::Scope::VALID_OPTIONS.include?(k)
+        raise ArgumentError, "Unknown key #{k}"
+      end
+    end
+  end
+end

data/lib/shirinji/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Shirinji
+  VERSION = '0.0.1'
+end

data/lib/shirinji.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Shirinji
+  # Your code goes here...
+end
+
+require 'shirinji/version'
+require 'shirinji/attribute'
+require 'shirinji/bean'
+require 'shirinji/map'
+require 'shirinji/resolver'
+require 'shirinji/scope'

data/shirinji.gemspec

@@ -0,0 +1,28 @@
+
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shirinji/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'shirinji'
+  spec.version       = Shirinji::VERSION
+  spec.authors       = ['Florian Dutey']
+  spec.email         = ['fdutey@gmail.com']
+
+  spec.summary       = 'Dependencies injection made easy'
+  spec.description   = 'Dependencies injections made easy for Ruby'
+  spec.homepage      = 'https://github.com/fdutey/shirinji'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |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', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: shirinji
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Florian Dutey
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-02-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Dependencies injections made easy for Ruby
+email:
+- fdutey@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/shirinji.rb
+- lib/shirinji/attribute.rb
+- lib/shirinji/bean.rb
+- lib/shirinji/map.rb
+- lib/shirinji/resolver.rb
+- lib/shirinji/scope.rb
+- lib/shirinji/version.rb
+- shirinji.gemspec
+homepage: https://github.com/fdutey/shirinji
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Dependencies injection made easy
+test_files: []