shirinji 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f263ef5a2e01c4aa04a72dccf8c114b250559983
-  data.tar.gz: 70517a5f3fe891b5bf4061156af846c657a0b8d9
+  metadata.gz: 77fda6000796dd02133fae4778b4501bc570990f
+  data.tar.gz: 46c1303d621e5fb851a4cc01514a4451df06535f
 SHA512:
-  metadata.gz: e64293607acfd7fa5fa90a853a799521c2d9eb1c29b7c4dfae4a5ed8d293be40507d370b535f6133b1ef22aacafb9f1e8709dc1cf0fd8ae3baa646fd5e697d8f
-  data.tar.gz: e14c3e48100be30c67057578a303353e65b9e0d01acd0435358a5fe796f8bdb0a119c49d6b26452bb84ce6a62675affa4b9d63552b8db9978bc1b7b7cec40c2d
+  metadata.gz: 12e6a82f1e8b7fea438a05bdd7020cabc0197ed2e1ec6398bd0d19b81031a98bb29eeaeeba85b9064d3b11cd213156b9123ff813961e4b374f3a32bbc53d75b3
+  data.tar.gz: 35f01c0f061af476ccab1704656c4187fa5284c025aabd332e89dd7b8b511e5a19f9ab2c73380649e6fc715d71965e6e6066f5c01d632f7163b35a6d8fa53133

data/.codeclimate.yml

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

data/.travis.yml

@@ -1,5 +1,14 @@
 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.5.0
+  - 2.5.1
+  - 2.5.2
+  - 2.5.3
+  - 2.6.0
+before_install: gem install bundler -v 1.16.6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    shirinji (0.0.3)
+    shirinji (0.0.4)
 
 GEM
   remote: https://rubygems.org/
@@ -26,10 +26,9 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.16)
   rake (~> 10.0)
   rspec (~> 3.0)
   shirinji!
 
 BUNDLED WITH
-   1.16.1
+   2.0.2

data/README.md

@@ -1,333 +1,335 @@
 # 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)
 
-## 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.
+Dependencies Injection made clean and easy for Ruby.
 
-Yet, it's heavily used in javascript world and fit perfectly with prototyped language.
+## Supported ruby versions
 
-```javascript
-function updateUI(evt) { /* ... */ }
-
-$.ajax('/action', { onSuccess: updateUI, ... })
-```
+- 2.4.x
+- 2.5.x
+- 2.6.x
 
-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.
+## Principles
 
-Dependencies injection is nothing more than the exact same principle but applied to objects instead 
-of functions.
+Remove hard dependencies between your objects and delegate object tree building
+to an unobtrusive framework with cool convention over configuration. 
 
-Let's follow an example step by step from "the rails way" to a proper way to understand it better.
+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.
 
 ```ruby
-class User < ActiveRecord::Base
-  after_create :publish_statistics, :send_confirmation_email
-  
-  private
+class FooService
+  attr_reader :bar_service
   
-  def publish_statistics
-    StatisticsGateway.publish_event(:new_user, user.id)
+  def initialize(bar_service:)
+    @bar_service = bar_service
   end
   
-  def send_confirmation_email
-    UserMailer.confirm_email(user).deliver
+  def call(obj)
+    obj.foo = 123
+    
+    bar_service.call(obj)
   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 ...)
+map = Shirinji::Map.new do
+  bean(:foo_service, klass: 'FooService')
+  bean(:bar_service, klass: 'BarService')
+end
 
-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. 
+resolver = Shirinji::Resolver.new(map)
+
+resolver.resolve(:foo_service)
+# => <#FooService @bar_service=<#BarService>> 
+```
+
+Shirinji is unobtrusive. Basically, any of your objects can be used 
+outside of its context.
 
 ```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
+bar_service = BarService.new
+foo_service = FooService.new(bar_service: bar_service)
+# => <#FooService @bar_service=<#BarService>>
 
-## test
+# tests
 
-RSpec.describe SignUpUserService do
-  let(:service) { described_class.new }
+RSpec.describe FooService do
+  let(:bar_service) { double(call: nil) }
+  let(:service) { described_class.new(bar_service: bar_service) }
   
   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
 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.
+## Constructor arguments
 
-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 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.
 
-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. 
+Shirinji doesn't accept anything else than named parameters. This way,
+arguments order doesn't matter and it makes everybody's life easier. 
 
-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.
+## Name resolution
 
-```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
-```
+By default, when you try to resolve a bean, Shirinji will look for a bean named 
+accordingly for each constructor parameter. 
 
-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
+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!
-    
-    publish_user_statistics_service.call(user)
-    send_user_email_confirmation_service.call(user)
-  end
-    
-  private
+class FooService
+  attr_reader :bar_service
   
-  def publish_user_statistics_service
-    PublishUserStatisticsService.new
-  end
-  
-  def send_user_email_confirmation_service
-    SendUserEmailConfirmationService.new
+  def initialize(my_service:)
+    @bar_service = my_service
   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)
+map = Shirinji::Map.new do
+  bean(:foo_service, klass: 'FooService') do
+    attr :my_service, ref: :bar_service
   end
   
-  # ...
+  bean(:bar_service, klass: 'BarService')
 end
+
+resolver = Shirinji::Resolver.new(map)
+
+resolver.resolve(:foo_service)
+# => <#FooService @bar_service=<#BarService>>
 ```
 
-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.
+## Caching and singletons
 
-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.
+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). 
 
-```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
+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. 
 
-  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
+Singleton is the default access mode for a bean.
+
+```ruby
+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).object_id #=> 1
+resolver.resolve(:foo).object_id #=> 1
+
+resolver.resolve(:bar).object_id #=> 2 
+resolver.resolve(:bar).object_id #=> 3 
 ```
 
-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. 
+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).
 
-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.  
+## Other type of beans
 
-## Usage
+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
+module MyApp
+  def self.config
+    @config
+  end
+  
+  def self.load!
+    @config = OpenStruct.new  
+  end
+end
+
+class FooService
+  attr_reader :config
+  
+  def initialize(config:)
+    @config = config
+  end
+end
+
+MyApp.load!
+
 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(:config, value: Proc.new { MyApp.config })
+  
+  bean(:foo_service, klass: 'FooService')
 end
 
 resolver = Shirinji::Resolver.new(map)
 
-resolver.resolve(:sign_up_user_service)
-#=> <#SignUpUserService @publish_user_statistics_service=<#PublishUserStatisticsService ...> ...> 
+resolver.resolve(:foo_service)
+#=> <#FooService @config=<#OpenStruct ...> ...>
 ```
 
-In this example, because `SingUpUserService` constructor parameters match beans with the same name,
-Shirinji will automatically resolve them. 
+A value can be anything. `Proc` will be lazily evaluated. It also obeys the 
+cache mechanism described before.
+
+## Skip construction mechanism
 
-In a case where a parameter name match no bean, it has to be mapped explicitly.
+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") 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")
+  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
 ```
 
-Shirinji provides scopes to help you organize your dependencies
+## Scopes
+
+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
   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(:signup, klass: 'Signup')
-    end
+      bean(:bar, klass: 'Bar')
+      # same as bean(:user_bar_service, klass: 'Services::User::BarService')
+    end 
   end
-  
-  # is the same as
-  bean(:user_signup_service, klass: 'Services::User::SignupService') 
 end
 ```
 
-If you need a dependency to return a class instead of an instance, you can disable
-the bean construction
+Scopes also come with an `auto_klass` attribute to save even more time for 
+common cases
 
 ```ruby
 map = Shirinji::Map.new do
-  bean(:foo, klass: 'Foo', construct: false)
+  scope module: :Services, 
+        suffix: :service, 
+        klass_suffix: :Service, 
+        auto_klass: true do
+    bean(:foo)
+    # same as bean(:foo_service, klass: 'Services::FooService')
+  end
 end
-
-resolver.resolve(:foo) #=> Foo 
 ```
 
-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/bean.rb

@@ -4,6 +4,7 @@ module Shirinji
   class Bean
     attr_reader :name, :class_name, :value, :access, :attributes, :construct
 
+    # rubocop:disable Metrics/ParameterLists
     def initialize(
       name, class_name: nil, value: nil, access:, construct: true, &block
     )
@@ -18,6 +19,7 @@ module Shirinji
 
       instance_eval(&block) if block
     end
+    # rubocop:enable Metrics/ParameterLists
 
     def attr(name, ref:)
       attributes[name] = Attribute.new(name, ref)

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,7 +72,7 @@ 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
@@ -59,7 +84,7 @@ module Shirinji
 
       options = others.merge(
         access: access,
-        class_name: klass && klass.freeze
+        class_name: klass&.freeze
       )
 
       beans[name] = Bean.new(name, **options, &block)
@@ -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

@@ -71,6 +71,7 @@ module Shirinji
     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,39 +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, **others, &block)
-      chunks = [mod, "#{klass}#{klass_suffix}"].compact
-      options = others.merge(klass: klass ? chunks.join('::') : nil)
-      scoped_name = [prefix, name, suffix].compact.join('_')
+    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(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/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/utils.rb

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

data/lib/shirinji/version.rb

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

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/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 'rspec', '~> 3.0'
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: shirinji
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Florian Dutey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-11 00:00:00.000000000 Z
+date: 2019-08-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
@@ -59,6 +45,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -78,6 +65,8 @@ 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