hypo 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a5df4c1be9652a444db79865461197009cf9b49
-  data.tar.gz: 71d0370d8cf8f3e9f672651c1ecab2e61e477047
+  metadata.gz: f95c8eb6eb6a8fdcef40c219b52f93ef7f019e57
+  data.tar.gz: 3026722dd03cdb35709b13c0325b72fd248c3841
 SHA512:
-  metadata.gz: 19459aa0a3c3a230855b25d3750c2540d958732698791f02dce185ff6b2a7c3de885b10ba84e8b303495a5aa11cb811a6eaf862efce9f98265613c855892e58b
-  data.tar.gz: d852deaa4743bcf8783c5a4da1a3f752c6e9897926005acae1873107b22607edd68c1065fc1619eca12e40fea0e5ec621cdc72a71deb3c97ae82d5894a595528
+  metadata.gz: ea62c01f490442eb5456e23294dda1559b2c96837e85c3f04fe9a2aa4b2b263f24fb16c5c086d3171bd67176f0c94041db39883039d14325a236b064f9bf5c23
+  data.tar.gz: 1f26a3b5bedefd8a8ab10a5527e20228769e910402686519dd291c55b461bcd88d5a389eba52595dd170fcb3d4abd34279310e6c26d96e4765fa1d450ce22dce

data/README.md

@@ -62,7 +62,7 @@ and if you registered both of them, you can do:
   # user.company is resolved as well
 ```
 
-Sometimes you're not able to manage a type lifecycle, i.e. when you use 3rd-party static stuff, like:
+Sometimes you're not able to manage a type lifetime, i.e. when you use 3rd-party static stuff, like:
 ```ruby
 class DB
   def self.connect
@@ -74,37 +74,21 @@ In that case you can register an instance instead of a type:
 ```ruby
 connection = DB.connect
 container.register_instance(connection, :connection)    
-``` 
-## Component Life Cycle
-By default all registered components have life cycle Hypo::Transient (:transient). 
+```
+
+## Advanced Usage 
+### Component Lifetime
+By default all registered components have lifetime Hypo::Lifetime::Transient (:transient). 
 It means, every time when you resolve a component Hypo returns new instance of its type.
 If you wanna change this behavior then you can replace lifetime strategy. 
-Out of the box Hypo provides Hypo::Singleton (:singleton) strategy, you can use it when register a component:
+Out of the box Hypo provides Hypo::Lifetime::Singleton (:singleton) strategy, you can use it when register a component:
 
 ```ruby
-container.register(User).using_life_cycle(:singleton)
+container.register(User).using_lifetime(:singleton)
 ``` 
-Actually you can implement your own life cycle, 
-i.e. makes sense to think about HttpRequest strategy for your web applications.
-
-**Instances support only :singleton life cycle.** 
-
-Sometimes you need to manage a component life cycle manually. Especially it can be useful for "instances".
-For example, you're going to inject new instance of request parameters every http request in your web application:
-
-```ruby
-# somewhere in Rack application
-# ...
-query_string = env['QUERY_STRING']
-container.register_instance(query_string, :query_string)
-
-# handle the request
 
-container.remove(:query_string)
-# ...
-```
-
-Hypo resolves components with different life cycle strategies independently. 
+#### Lifetime compatibility 
+Hypo resolves components with different lifetime strategies independently. 
 In other words you can inject a dependency with less lifespan than acceptor type. I.e.:
 
 ```ruby
@@ -117,14 +101,89 @@ class B
 end
 
 
-container.register(A, :type_a).using_life_cycle(:transient)
-container.register(B, :type_b).using_life_cycle(:singleton)
+container.register(A, :type_a).using_lifetime(:transient)
+container.register(B, :type_b).using_lifetime(:singleton)
 
+container.resolve(:type_b)
 ```
 
 According to :transient strategy every time when you try to resolve a singleton 
 you retrieve exactly the same instance of the singleton **but with new instance** of transient dependency.    
 
+#### Custom Lifetime
+Actually you can implement your own lifetime, 
+i.e. makes sense to think about HttpRequest strategy for your web applications. You can do that using "add_lifetime" method:
+
+```ruby
+# somewhere in Rack application: application initialization
+lifetime = Lifetime::Request.new
+container.add_lifetime(lifetime, :request)
+```
+
+A class of new lifetime must respond to "instance" method. This method just a factory method which creates new instance according to your strategy. For example, Lifetime::Request could cache instanes of a components during http request lifespan. Take a look to [:singleton implementation](https://github.com/cylon-v/hypo/blob/master/lib/hypo/lifetime/singleton.rb). You can manually purge internal state of components registry according your strategy. In case of http-request lifetime you could clean up it right after request has done:
+
+```ruby
+# somewhere in Rack application: application initialization
+# ...
+container
+  .register(SQLTransation, :transaction)
+  .using_lifetime(:request)
+```
+
+```ruby
+# somewhere in Rack application: request handling
+container.register_instance(query_string, :query_string)
+
+# handle the request
+# ...
+
+lifetime.purge
+```
+
+#### Lifetime :scope
+For most of cases when you need to bind dependency lifetime to lifetime of another item of your application
+you can use Hypo::Lifetime::Scope (:scope) strategy.
+
+
+```ruby
+# somewhere in Rack application: application initialization
+# ...
+container
+  .register(SQLTransation, :transaction)
+  .using_lifetime(:scope)
+  .bound_to(:request) # you can use symbol
+```
+
+```ruby
+# somewhere in Rack application: request handling
+container
+    .register_instance(request, :request)
+    .using_lifetime(:scope)
+    .bound_to(request) # an object
+
+# handle the request
+# ...
+
+lifetime.purge(request)
+``` 
+
+### Remove components
+Sometimes you need to manage a component lifetime manually. Especially it can be useful for "instances".
+For example, you're going to inject new instance of request parameters every http request in your web application:
+
+```ruby
+# somewhere in Rack application: request handling
+# ...
+query_string = env['QUERY_STRING']
+container.register_instance(query_string, :query_string)
+
+# handle the request
+# ...
+
+container.remove(:query_string)
+# ...
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -137,4 +196,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/[USERN
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/hypo/component.rb

@@ -1,22 +1,24 @@
-require 'hypo/life_cycle/transient'
-require 'hypo/chainable'
+require 'hypo/lifetime/transient'
+require 'hypo/scope_friendly'
+require 'hypo/lifetime_friendly'
 
 module Hypo
   class Component
-    include Chainable
+    include ScopeFriendly
+    include LifetimeFriendly
 
-    attr_reader :name, :type, :container, :life_cycle
+    attr_reader :name, :type, :container, :lifetime, :scope
 
     def initialize(type, container, name = nil)
       @container = container
       @type = type
       @name = name || type.name.gsub(/(.)([A-Z](?=[a-z]))/, '\1_\2').delete('::').downcase.to_sym
-      @life_cycle = container.life_cycles[:transient]
+      @lifetime = container.lifetimes[:transient]
       @dependency_names = @type.instance_method(:initialize).parameters.map {|p| p[1]}
     end
 
     def instance
-      instance = @life_cycle.instance(self)
+      instance = @lifetime.instance(self)
 
       @dependency_names.each do |dependency|
         instance.instance_variable_set "@#{dependency}".to_sym, @container.resolve(dependency)
@@ -28,13 +30,5 @@ module Hypo
     def dependencies
       @dependency_names.map { |dependency| @container.resolve(dependency) }
     end
-
-    def use_life_cycle(life_cycle)
-      @life_cycle = container.life_cycles[life_cycle]
-
-      self
-    end
-
-    alias using_life_cycle use_life_cycle
   end
 end

data/lib/hypo/container.rb

@@ -1,18 +1,19 @@
 require 'hypo/container_error'
 require 'hypo/component'
 require 'hypo/instance'
-require 'hypo/life_cycle/transient'
-require 'hypo/life_cycle/singleton'
+require 'hypo/lifetime/transient'
+require 'hypo/lifetime/singleton'
 
 module Hypo
   class Container
-    attr_reader :life_cycles
+    attr_reader :lifetimes
 
     def initialize
       @components = {}
-      @life_cycles = {}
-      add_life_cycle(LifeCycle::Transient.new, :transient)
-      add_life_cycle(LifeCycle::Singleton.new, :singleton)
+      @lifetimes = {}
+      add_lifetime(Lifetime::Transient.new, :transient)
+      add_lifetime(Lifetime::Singleton.new, :singleton)
+      add_lifetime(Lifetime::Scope.new, :scope)
       register_instance self, :container
     end
 
@@ -24,11 +25,11 @@ module Hypo
 
       component = Component.new(item, self, name)
 
-      if @components.key?(component.name)
-        raise ContainerError, "Component \"#{component.name}\" has already been registered"
+      unless @components.key?(component.name)
+        @components[component.name] = component
       end
 
-      @components[component.name] = component
+      @components[component.name]
     end
 
     def register_instance(item, name)
@@ -37,12 +38,12 @@ module Hypo
           'If you wanna register a type please use method "register".'
       end
 
-      if @components.key?(name)
-        raise ContainerError, "Component \"#{name}\" has already been registered"
+      unless @components.key?(name)
+        instance = Instance.new(item, self, name)
+        @components[name] = instance
       end
 
-      instance = Instance.new(item, self, name)
-      @components[name] = instance
+      @components[name]
     end
 
     def resolve(name)
@@ -53,12 +54,8 @@ module Hypo
       @components[name].instance
     end
 
-    def remove(name)
-      @components.delete(name)
-    end
-
-    def add_life_cycle(life_cycle, name)
-      @life_cycles[name] = life_cycle
+    def add_lifetime(lifetime, name)
+      @lifetimes[name] = lifetime
 
       self
     end

data/lib/hypo/container_error.rb

@@ -1,7 +1,4 @@
 module Hypo
   class ContainerError < StandardError
-    def initialize(message)
-      super(message)
-    end
   end
 end

data/lib/hypo/instance.rb

@@ -1,21 +1,24 @@
-require 'hypo/chainable'
+require 'hypo/scope_friendly'
+require 'hypo/lifetime_friendly'
 
 module Hypo
   class Instance
-    include Chainable
+    include ScopeFriendly
+    include LifetimeFriendly
 
-    attr_reader :name, :container
+    attr_reader :name, :container, :scope, :object
 
     def initialize(object, container, name)
       raise ContainerError, 'Registered object should have a name' if name.nil?
 
       @object = object
       @container = container
+      @lifetime = container.lifetimes[:transient]
       @name = name
     end
 
     def instance
-      @object
+      @lifetime.instance(self)
     end
   end
 end

data/lib/hypo/lifetime/scope.rb

@@ -0,0 +1,33 @@
+module Hypo
+  module Lifetime
+    class Scope
+      def initialize
+        @instances = {}
+      end
+
+      def instance(component)
+        if component.scope.nil?
+          raise ContainerError, "Component \"#{component.name}\" must be bound to a scope" \
+            " according to Hupo::Lifetime::Scope lifetime strategy"
+        end
+
+        scope = component.scope.object_id
+        @instances[scope] = {} unless @instances.key? scope
+
+        unless @instances[scope].key? component.name
+          if component.respond_to? :type
+            @instances[scope][component.name] = component.type.new(*component.dependencies)
+          else
+            @instances[scope][component.name] = component.object
+          end
+        end
+
+        @instances[scope][component.name]
+      end
+
+      def purge(scope)
+        @instances.delete scope.object_id
+      end
+    end
+  end
+end

data/lib/hypo/{life_cycle → lifetime}/singleton.rb

@@ -1,5 +1,5 @@
 module Hypo
-  module LifeCycle
+  module Lifetime
     class Singleton
       def initialize
         @instances = {}
@@ -7,7 +7,11 @@ module Hypo
 
       def instance(component)
         unless @instances.key? component.name
-          @instances[component.name] = component.type.new(*component.dependencies)
+          if component.respond_to? :type
+            @instances[component.name] = component.type.new(*component.dependencies)
+          else
+            @instances[component.name] = component.object
+          end
         end
 
         @instances[component.name]

data/lib/hypo/lifetime/transient.rb

@@ -0,0 +1,13 @@
+module Hypo
+  module Lifetime
+    class Transient
+      def instance(component)
+        if component.respond_to? :type
+          component.type.new(*component.dependencies)
+        else
+          component.object
+        end
+      end
+    end
+  end
+end

data/lib/hypo/lifetime_friendly.rb

@@ -0,0 +1,11 @@
+module Hypo
+  module LifetimeFriendly
+    def use_lifetime(lifetime)
+      @lifetime = @container.lifetimes[lifetime]
+
+      self
+    end
+
+    alias using_lifetime use_lifetime
+  end
+end

data/lib/hypo/scope_friendly.rb

@@ -0,0 +1,15 @@
+module Hypo
+  module ScopeFriendly
+    def bind_to(scope)
+      if scope.is_a? Symbol
+        @scope = @container.resolve(scope)
+      else
+        @scope = scope
+      end
+
+      self
+    end
+
+    alias bound_to bind_to
+  end
+end

data/lib/hypo/version.rb

@@ -1,3 +1,3 @@
 module Hypo
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hypo
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Vladimir Kalinkin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-18 00:00:00.000000000 Z
+date: 2017-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,13 +70,15 @@ files:
 - bin/setup
 - hypo.gemspec
 - lib/hypo.rb
-- lib/hypo/chainable.rb
 - lib/hypo/component.rb
 - lib/hypo/container.rb
 - lib/hypo/container_error.rb
 - lib/hypo/instance.rb
-- lib/hypo/life_cycle/singleton.rb
-- lib/hypo/life_cycle/transient.rb
+- lib/hypo/lifetime/scope.rb
+- lib/hypo/lifetime/singleton.rb
+- lib/hypo/lifetime/transient.rb
+- lib/hypo/lifetime_friendly.rb
+- lib/hypo/scope_friendly.rb
 - lib/hypo/version.rb
 homepage: https://github.com/cylon-v/hypo
 licenses:

data/lib/hypo/chainable.rb

@@ -1,7 +0,0 @@
-module Hypo
-  module Chainable
-    def register(item, name = nil)
-      @container.register(item, name)
-    end
-  end
-end

data/lib/hypo/life_cycle/transient.rb

@@ -1,9 +0,0 @@
-module Hypo
-  module LifeCycle
-    class Transient
-      def instance(component)
-        component.type.new(*component.dependencies)
-      end
-    end
-  end
-end