shirinji 0.0.2 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9e72d17d6ce2db50ed67b5ae251a372ad202620a
-  data.tar.gz: c78b751572c478329040fb289fb405253e921f46
+SHA256:
+  metadata.gz: 6dc426a5294d566ede0acdf7b46568d09736ef05d044afbed686bb604cd48830
+  data.tar.gz: 2fc85bcb5c7a1c5050cc6a29397e3b2380b89482442f64e119676c463670ffeb
 SHA512:
-  metadata.gz: f7efa6c82ec9558e7d89ca90bc26e5639d2fecc9d31dc1ef4d1bd3c0ff3e12b5f59f744a172633f5c02ed29e2812dbe8861e9cf78461d190795b74bc066bef07
-  data.tar.gz: 9a445d8d26e846184318eb37a4fd824a628f5343f854f4cd7bace5b5aa01a3e1529379f6ff2f1293c556e92db513e5136e95b134a28a99e5500175d9547783f7
+  metadata.gz: 7f8cb9af67898e849acd3bc6c1885094dea834db218f5ab6a39b167ebb54d8ea3d6371c62692a83a27c62124714c2762087a7c79e55821717852f22835e0bad9
+  data.tar.gz: 07e1eac7f60615db3ecd869d59d3a648c269d56926f09a8ca5897f618d3a69b2849508c9887623ac12e2f04957fed777b01ec77dd1cd666c674ad1bfd003f856

data/.codeclimate.yml

@@ -0,0 +1,3 @@
+plugins:
+  rubocop:
+    enabled: true

data/.gitignore

@@ -9,4 +9,7 @@
 
 # rspec failure tracking
 .rspec_status
-.idea
+.idea
+
+docker-compose.yml
+Dockerfile

data/.travis.yml

@@ -1,5 +1,38 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.3.4
-before_install: gem install bundler -v 1.16.0
+  - 2.4.0
+  - 2.4.1
+  - 2.4.2
+  - 2.4.3
+  - 2.4.4
+  - 2.4.5
+  - 2.4.6
+  - 2.4.7
+  - 2.4.8
+  - 2.4.9
+  - 2.5.0
+  - 2.5.1
+  - 2.5.2
+  - 2.5.3
+  - 2.5.4
+  - 2.5.5
+  - 2.5.6
+  - 2.5.7
+  - 2.5.8
+  - 2.5.9
+  - 2.6.0
+  - 2.6.1
+  - 2.6.2
+  - 2.6.3
+  - 2.6.4
+  - 2.6.5
+  - 2.6.6
+  - 2.6.7
+  - 2.7.0
+  - 2.7.1
+  - 2.7.2
+  - 2.7.3
+  - 3.0.0
+  - 3.0.1
+before_install: gem install bundler

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+Speech is free, you can tell anything you want.
+
+## Our Standards
+
+Sue me.
+

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    shirinji (0.0.1)
+    shirinji (0.0.7)
 
 GEM
   remote: https://rubygems.org/
   specs:
     diff-lcs (1.3)
-    rake (10.5.0)
+    rake (13.0.3)
     rspec (3.7.0)
       rspec-core (~> 3.7.0)
       rspec-expectations (~> 3.7.0)
@@ -26,10 +26,9 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.16)
-  rake (~> 10.0)
+  rake (>= 12.3.3)
   rspec (~> 3.0)
   shirinji!
 
 BUNDLED WITH
-   1.16.1
+   2.2.16

data/README.md

@@ -1,307 +1,337 @@
 # Shirinji
 
-Container manager for dependency injection in Ruby.
+[![Gem Version](https://badge.fury.io/rb/shirinji.svg)](
+https://badge.fury.io/rb/shirinji
+)
+[![Build Status](https://travis-ci.org/fdutey/shirinji.svg?branch=master)](
+https://travis-ci.org/fdutey/shirinji
+)
+[![Maintainability](
+https://api.codeclimate.com/v1/badges/4b1c0010788d70581680/maintainability)
+](https://codeclimate.com/github/fdutey/shirinji/maintainability)
+
+Dependencies Injection made clean and easy for Ruby.
+
+## Supported ruby versions
+
+- 2.4.x
+- 2.5.x
+- 2.6.x
+- 2.7.x
+- 3.0.x
 
 ## 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.
+Remove hard dependencies between your objects and delegate object tree building
+to an unobtrusive framework with cool convention over configuration. 
 
-Yet, it's heavily used in javascript world and fit perfectly with prototyped language.
+Shirinji relies on a mapping of beans and a resolver. When you resolve a bean,
+it will return (by default) an instance of the class associated to the bean,
+with all the bean dependencies resolved.
 
-```javascript
-function updateUI(evt) { /* ... */ }
+```ruby
+class FooService
+  attr_reader :bar_service
+  
+  def initialize(bar_service:)
+    @bar_service = bar_service
+  end
+  
+  def call(obj)
+    obj.foo = 123
+    
+    bar_service.call(obj)
+  end
+end
 
-$.ajax('/action', { onSuccess: updateUI, ... })
-```
+map = Shirinji::Map.new do
+  bean(:foo_service, klass: 'FooService')
+  bean(:bar_service, klass: 'BarService')
+end
 
-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.
+resolver = Shirinji::Resolver.new(map)
 
-Dependencies injection is nothing more than the exact same principle but applied to objects instead 
-of functions.
+resolver.resolve(:foo_service)
+# => <#FooService @bar_service=<#BarService>> 
+```
 
-Let's follow an example step by step from "the rails way" to a proper way to understand it better.
+Shirinji is unobtrusive. Basically, any of your objects can be used 
+outside of its context.
 
 ```ruby
-class User < ActiveRecord::Base
-  after_create :publish_statistics, :send_confirmation_email
-  
-  private
-  
-  def publish_statistics
-    StatisticsGateway.publish_event(:new_user, user.id)
-  end
+bar_service = BarService.new
+foo_service = FooService.new(bar_service: bar_service)
+# => <#FooService @bar_service=<#BarService>>
+
+# tests
+
+RSpec.describe FooService do
+  let(:bar_service) { double(call: nil) }
+  let(:service) { described_class.new(bar_service: bar_service) }
   
-  def send_confirmation_email
-    UserMailer.confirm_email(user).deliver
+  describe '.call' do
+    # ...
   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 ...)
+## Constructor arguments
+
+Shirinji relies on constructor to inject dependencies. It's considering that
+objects that receive dependencies should be immutables and those dependencies
+should not change during your program lifecycle.
+
+Shirinji doesn't accept anything else than named parameters. This way,
+arguments order doesn't matter and it makes everybody's life easier. 
+
+## Name resolution
 
-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. 
+By default, when you try to resolve a bean, Shirinji will look for a bean named 
+accordingly for each constructor parameter. 
+
+It's possible to locally override this behaviour though by using `attr` macro.
 
 ```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  
+class FooService
+  attr_reader :bar_service
+  
+  def initialize(my_service:)
+    @bar_service = my_service
   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) }
+map = Shirinji::Map.new do
+  bean(:foo_service, klass: 'FooService') do
+    attr :my_service, ref: :bar_service
+  end
   
-    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  
+  bean(:bar_service, klass: 'BarService')
 end
+
+resolver = Shirinji::Resolver.new(map)
+
+resolver.resolve(:foo_service)
+# => <#FooService @bar_service=<#BarService>>
 ```
 
-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.
+## Caching and singletons
 
-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)
+Shirinji provides a caching mecanism to help you improve memory consumption.
+This cache is safe as long as your beans remains immutable (they should always
+be). 
 
-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. 
+The consequence is that any cached instance is actually a singleton. Singleton
+is no more a property of your class but of it's environment, improving the
+reusability of your code. 
 
-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.
+Singleton is the default access mode for a bean.
 
 ```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
+map = Shirinji::Map.new do
+  bean(:bar_service, klass: 'BarService', access: :instance)
+  bean(:foo_service, klass: 'FooService', access: :singleton)
+  # same as bean(:foo_service, klass: 'FooService')
 end
+
+resolver = Shirinji::Resolver.new(map)
+
+resolver.resolve(:foo_service).object_id #=> 1
+resolver.resolve(:foo_service).object_id #=> 1
+
+resolver.resolve(:bar_service).object_id #=> 2 
+resolver.resolve(:bar_service).object_id #=> 3 
 ```
 
-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
+Cache can be reset with the simple command `resolver.reset_cache`, which can be
+useful when using a development console like rails console ([shirinji-rails](
+https://github.com/fdutey/shirinji-rails) is attaching cache reset to `reload!` 
+command).
+
+## Other type of beans
+
+Dependencies injection doesn't apply only to classes. You can actually inject
+anything and therefore, Shirinji allows you to declare anything as a dependency.
+To achieve that, use the key `value` instead of `class`.
 
 ```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)
+module MyApp
+  def self.config
+    @config
   end
-    
-  private
   
-  def publish_user_statistics_service
-    PublishUserStatisticsService.new
-  end
-  
-  def send_user_email_confirmation_service
-    SendUserEmailConfirmationService.new
+  def self.load!
+    @config = OpenStruct.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 }
+class FooService
+  attr_reader :config
   
-  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)
+  def initialize(config:)
+    @config = config
   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.
+MyApp.load!
 
-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.
+map = Shirinji::Map.new do
+  bean(:config, value: Proc.new { MyApp.config })
+  
+  bean(:foo_service, klass: 'FooService')
+end
 
-```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
+resolver = Shirinji::Resolver.new(map)
 
-  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
+resolver.resolve(:foo_service)
+#=> <#FooService @config=<#OpenStruct ...> ...>
 ```
 
-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. 
+A value can be anything. `Proc` will be lazily evaluated. It also obeys the 
+cache mechanism described before.
 
-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.  
+## Skip construction mechanism
 
-## Usage
+In some cases, you need a dependency to be injected as a class and not an 
+instance. In such case, you could use value beans, returning the class itself, 
+but you would lose the benefit of scopes (see below). 
+Instead, Shirinji provides a parameter to skip the object construction.
+
+A real life example is a Job where `deliver_now` and `deliver_later` are 
+class methods.
 
 ```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")
+  bean(:foo_job, klass: 'FooJob', construct: false)
 end
 
 resolver = Shirinji::Resolver.new(map)
 
-resolver.resolve(:sign_up_user_service)
-#=> <#SignUpUserService @publish_user_statistics_service=<#PublishUserStatisticsService ...> ...> 
+resolver.resolve(:foo_job) #=> FooJob
 ```
 
-In this example, because `SingUpUserService` constructor parameters match beans with the same name,
-Shirinji will automatically resolve them. 
+## Scopes
 
-In a case where a parameter name match no bean, it has to be mapped explicitly.
+Building complex objects mapping leads to lot of repetition. That's why Shirinji 
+also provides a scope mechanism to help you dry your code.
 
 ```ruby
 map = Shirinji::Map.new do
-  bean(:sign_up_user_service, klass: "SignUpUserService") do
-    attr :publish_user_statistics_service, ref: :user_publish_statistics_service
+  scope module: :Services, suffix: :service, klass_suffix: :Service do
+    bean(:foo, klass: 'Foo')
+    # same as bean(:foo_service, klass: 'Services::FooService')
+    
+    scope module: :User, prefix: :user do
+      bean(:bar, klass: 'Bar')
+      # same as bean(:user_bar_service, klass: 'Services::User::BarService')
+    end 
   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)
+Scopes also come with an `auto_klass` attribute to save even more time for 
+common cases
 
-resolver.resolve(:sign_up_user_service)
-#=> <#SignUpUserService @publish_user_statistics_service=<#PublishUserStatisticsService ...> ...> 
+```ruby
+map = Shirinji::Map.new do
+  scope module: :Services, 
+        suffix: :service, 
+        klass_suffix: :Service, 
+        auto_klass: true do
+    bean(:foo)
+    # same as bean(:foo_service, klass: 'Services::FooService')
+  end
+end
 ```
 
-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.
+Scopes also provides an `auto_prefix` option
 
-Singleton is the default access mode for a bean.
+```ruby
+map = Shirinji::Map.new do
+  scope module: :Services, 
+        suffix: :service, 
+        klass_suffix: :Service, 
+        auto_klass: true do
+        
+    # Do not use auto prefix on root scope or every bean will be prefixed
+    # with `services_`
+    scope auto_prefix: true do
+      bean(:foo)
+      # same as bean(:foo_service, klass: 'Services::FooService')
+      
+      scope module: :User do
+        # same as scope module: :User, prefix: :user
+  
+        bean(:bar)
+        # same as bean(:user_bar_service, klass: 'Services::User::BarService')
+      end
+    end
+  end
+end
+```
+
+Finally, for mailers / jobs ..., Scopes allow you to specify a global value
+for `construct`
 
 ```ruby
 map = Shirinji::Map.new do
-  bean(:foo, klass: 'Foo', access: :singleton) # foo is singleton
-  bean(:bar, klass: 'Bar', access: :instance) # bar is not
+  scope module: :Jobs, 
+        suffix: :job, 
+        klass_suffix: :Job, 
+        auto_klass: true, 
+        construct: false do
+    bean(:foo)
+    # bean(:foo_job, klass: 'Jobs::FooJob', construct: false)
+  end
 end
+```
 
-resolver = Shirinji::Resolver.new(map)
+Scopes do not carry property `access`
 
-resolver.resolve(:foo).object_id #=> 1
-resolver.resolve(:foo).object_id #=> 1
+## Code splitting
 
-resolver.resolve(:bar).object_id #=> 2 
-resolver.resolve(:bar).object_id #=> 3 
-```
+When a project grows, dependencies grows too. Keeping them into one single file
+leads to headaches. One possible solution to keep everything under control is
+to split your dependencies into many files.
 
-You can also create beans that contain single values. It will help you to avoid referencing global 
-variables in your code.
+To include a "sub-map" into another one, you can use `include_map` method.
 
 ```ruby
-map = Shirinji::Map.new do
-  bean(:config, value: Proc.new { Application.config })
-  bean(:foo, klass: 'Foo')
+# dependencies/services.rb
+Shirinji::Map.new do
+  bean(:foo_service, klass: 'FooService')
 end
 
-resolver = Shirinji::Resolver.new(map)
+# dependencies/queries.rb
+Shirinji::Map.new do
+  bean(:foo_query, klass: 'FooQuery')
+end
 
-class Foo
-  attr_reader :config
+# dependencies.rb
+
+root = Pathname.new(File.expand_path('../dependencies', __FILE__))
+
+Shirinji::Map.new do
+  bean(:config, value: -> { MyApp.config })
   
-  def initialize(config:)
-    @config = config
-  end
+  # paths must be absolute 
+  include_map(root.join('queries.rb'))
+  include_map(root.join('services.rb'))
 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.
+- 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 `ArgumentError` if you 
+  try to use it with "standard" method arguments.
+  
+## TODOS
+
+- solve absolute paths problems for `include_map` (`instance_eval` is a problem)
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/fdutey/shirinji.
+Bug reports and pull requests are welcome on GitHub at 
+https://github.com/fdutey/shirinji.

data/lib/shirinji.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module Shirinji
-  # Your code goes here...
 end
 
 require 'shirinji/version'
@@ -10,3 +9,4 @@ require 'shirinji/bean'
 require 'shirinji/map'
 require 'shirinji/resolver'
 require 'shirinji/scope'
+require 'shirinji/utils'

data/lib/shirinji/attribute.rb

@@ -2,11 +2,12 @@
 
 module Shirinji
   class Attribute
-    attr_reader :name, :reference
+    attr_reader :name, :reference, :value
 
-    def initialize(name, reference)
+    def initialize(name, reference = nil, value = nil)
       @name = name
       @reference = reference
+      @value = value
     end
   end
 end

data/lib/shirinji/bean.rb

@@ -2,9 +2,12 @@
 
 module Shirinji
   class Bean
-    attr_reader :name, :class_name, :value, :access, :attributes
+    attr_reader :name, :class_name, :value, :access, :attributes, :construct
 
-    def initialize(name, class_name: nil, value: nil, access:, &block)
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(
+      name, class_name: nil, value: nil, access:, construct: true, &block
+    )
       check_params!(class_name, value)
 
       @name = name
@@ -12,12 +15,14 @@ module Shirinji
       @value = value
       @access = access
       @attributes = {}
+      @construct = construct
 
       instance_eval(&block) if block
     end
+    # rubocop:enable Metrics/ParameterLists
 
-    def attr(name, ref:)
-      attributes[name] = Attribute.new(name, ref)
+    def attr(name, ref: nil, value: nil)
+      attributes[name] = Attribute.new(name, ref, value)
     end
 
     private

data/lib/shirinji/map.rb

@@ -4,10 +4,34 @@ module Shirinji
   class Map
     attr_reader :beans
 
+    # Loads a map at a given location
+    #
+    # @param location [string] path to the map to load
+    def self.load(location)
+      eval(File.read(location))
+    end
+
     def initialize(&block)
       @beans = {}
 
-      instance_eval(&block)
+      instance_eval(&block) if block
+    end
+
+    # Merges another map at a given location
+    #
+    # @param location [string] the file to include - must be an absolute path
+    def include_map(location)
+      merge(self.class.load(location))
+    end
+
+    # Merges a map into another one
+    #
+    # @param map [Shirinji::Map] the map to merge into this one
+    # @raise [ArgumentError] if both map contains a bean with the same bean
+    def merge(map)
+      map.beans.keys.each { |name| raise_if_name_already_taken!(name) }
+
+      beans.merge!(map.beans)
     end
 
     # Returns a bean based on its name
@@ -26,6 +50,7 @@ module Shirinji
     def get(name)
       bean = beans[name.to_sym]
       raise ArgumentError, "Unknown bean #{name}" unless bean
+
       bean
     end
 
@@ -47,20 +72,20 @@ module Shirinji
     #
     # @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 [Object] :value the object registered by the bean
+    # @option [Boolean] :construct whether the bean should be constructed or not
     # @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)
+    def bean(name, klass: nil, access: :singleton, **others, &block)
       name = name.to_sym
 
       raise_if_name_already_taken!(name)
 
-      options = {
+      options = others.merge(
         access: access,
-        class_name: klass ? klass.freeze : nil,
-        value: value
-      }
+        class_name: klass&.freeze
+      )
 
       beans[name] = Bean.new(name, **options, &block)
     end
@@ -113,6 +138,9 @@ module Shirinji
     # @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
+    # @option options [Boolean] :auto_klass generates klass from name
+    # @option options [Boolean] :auto_prefix generates prefix from module
+    # @option options [Boolean] :construct applies `construct` on every bean
     # @yield a standard map
     def scope(**options, &block)
       Scope.new(self, **options, &block)
@@ -122,6 +150,7 @@ module Shirinji
 
     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

data/lib/shirinji/resolver.rb

@@ -24,6 +24,11 @@ module Shirinji
       end
     end
 
+    def reload(map)
+      @map = map
+      reset_cache
+    end
+
     def reset_cache
       @singletons = {}
     end
@@ -40,12 +45,13 @@ module Shirinji
 
     def resolve_class_bean(bean)
       klass, params = resolve_class(bean)
+      return klass unless bean.construct
       return klass.new if params.empty?
 
       check_params!(params)
 
       args = params.each_with_object({}) do |(_type, arg), memo|
-        memo[arg] = resolve(resolve_attribute(bean, arg))
+        memo[arg] = resolve_attribute(bean, arg)
       end
 
       klass.new(**args)
@@ -59,12 +65,16 @@ module Shirinji
     end
 
     def resolve_attribute(bean, arg)
-      (attr = bean.attributes[arg]) ? attr.reference : arg
+      return resolve(arg) unless (attr = bean.attributes[arg])
+      return attr.value if attr.value
+
+      resolve(attr.reference)
     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

data/lib/shirinji/scope.rb

@@ -2,42 +2,86 @@
 
 module Shirinji
   class Scope
-    VALID_OPTIONS = %i[module prefix suffix klass_suffix].freeze
+    VALID_OPTIONS = %i[
+      module prefix suffix klass_suffix auto_klass auto_prefix construct
+    ].freeze
 
-    attr_reader :parent, :mod, :prefix, :suffix, :klass_suffix
+    attr_reader :parent, :mod, :prefix, :suffix, :klass_suffix, :auto_klass,
+                :construct, :auto_prefix
 
     def initialize(parent, **options, &block)
       validate_options(options)
 
       @parent = parent
       @mod = options[:module]
-      @prefix = options[:prefix]
       @suffix = options[:suffix]
       @klass_suffix = options[:klass_suffix]
+      @auto_klass = options[:auto_klass]
+      @auto_prefix = options[:auto_prefix]
+      @prefix = generate_prefix(options[:prefix])
+      @construct = options.fetch(:construct, true)
 
       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
-      }
+    def bean(name, klass: nil, **options, &block)
+      default_opts = compact({ construct: construct })
+
+      klass = generate_klass(name, klass) unless options[:value]
+      options = compact(default_opts.merge(options).merge(klass: klass))
+      scoped_name = generate_scope(name)
 
-      parent.bean([prefix, name, suffix].compact.join('_'), **options, &block)
+      parent.bean(scoped_name, **options, &block)
     end
 
     def scope(**options, &block)
-      Scope.new(self, **options, &block)
+      opts = {
+        auto_klass: auto_klass,
+        auto_prefix: auto_prefix,
+        construct: construct
+      }.merge(options)
+
+      Scope.new(self, **opts, &block)
     end
 
     private
 
+    def compact(h)
+      h.reject { |_,v| v.nil? }
+    end
+
+    def generate_scope(name)
+      [prefix, name, suffix].compact.join('_')
+    end
+
+    def generate_klass(name, klass)
+      return if !klass && !auto_klass
+
+      klass ||= klassify(name)
+      chunks = [mod, "#{klass}#{klass_suffix}"].compact
+
+      chunks.join('::')
+    end
+
+    def generate_prefix(prefix)
+      return prefix if prefix
+      return nil unless auto_prefix
+
+      mod && underscore(mod.to_s).to_sym
+    end
+
+    def klassify(name)
+      Shirinji::Utils::String.camelcase(name)
+    end
+
+    def underscore(name)
+      Shirinji::Utils::String.snakecase(name)
+    end
+
     def validate_options(args)
       args.each_key do |k|
         next if Shirinji::Scope::VALID_OPTIONS.include?(k)
+
         raise ArgumentError, "Unknown key #{k}"
       end
     end

data/lib/shirinji/utils.rb

@@ -0,0 +1,6 @@
+module Shirinji
+  module Utils
+  end
+end
+
+require_relative 'utils/string'

data/lib/shirinji/utils/string.rb

@@ -0,0 +1,24 @@
+module Shirinji
+  module Utils
+    module String
+      CAMEL =
+        /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/
+
+      module_function
+
+      def camelcase(str)
+        chunks = str.to_s.split('_').map do |w|
+          w = w.downcase
+          w[0] = w[0].upcase
+          w
+        end
+
+        chunks.join
+      end
+
+      def snakecase(str)
+        str.gsub(CAMEL) { |s| s.split('').join('_') }.downcase
+      end
+    end
+  end
+end

data/lib/shirinji/version.rb

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

data/shirinji.gemspec

@@ -1,7 +1,6 @@
-
 # frozen_string_literal: true
 
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'shirinji/version'
 
@@ -22,7 +21,6 @@ Gem::Specification.new do |spec|
   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 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.0'
 end

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: shirinji
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.7
 platform: ruby
 authors:
 - Florian Dutey
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2018-03-12 00:00:00.000000000 Z
+date: 2021-04-15 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'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -59,12 +45,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-gemset"
 - ".ruby-version"
 - ".travis.yml"
+- CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
 - README.md
@@ -77,12 +65,14 @@ files:
 - lib/shirinji/map.rb
 - lib/shirinji/resolver.rb
 - lib/shirinji/scope.rb
+- lib/shirinji/utils.rb
+- lib/shirinji/utils/string.rb
 - lib/shirinji/version.rb
 - shirinji.gemspec
 homepage: https://github.com/fdutey/shirinji
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -97,9 +87,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Dependencies injection made easy
 test_files: []