jerry 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 602f20059904dc280342beeba26963492e75a566
+  data.tar.gz: e41a4ebdb936fa0beee388d153cbb505ba8f6c90
+SHA512:
+  metadata.gz: 0a96708a2dc2bf0d3e8ce206e7763760ca08bf1570e58fa5ef8dd12530e03d432ab1bbcd6e4085f2f29efce794bfb236bed57a3bf93bde039849e9be70dc7f38
+  data.tar.gz: 93da221784a25aecda8d98ac356110a791a0b8e7aeca64923a6e7a81b38d2755ce17f34e6cc9c7f217461a19fc8ea62ab5b822a807608033b08c9e0655da8673

data/.gitignore

@@ -0,0 +1,38 @@
+# Created by http://www.gitignore.io
+
+### Ruby ###
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.1.2
+  - 1.9.3
+  - jruby-19mode
+  - rbx-2

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'coveralls', require: false

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Boris Bera
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,117 @@
+Jerry
+=====
+
+[![Build Status](https://travis-ci.org/beraboris/jerry.svg?branch=master)](https://travis-ci.org/beraboris/jerry)
+[![Coverage Status](https://coveralls.io/repos/beraboris/jerry/badge.png)](https://coveralls.io/r/beraboris/jerry)
+
+Jerry rigs your application together. It's an [Inversion of Control](https://en.wikipedia.org/wiki/Inversion_of_control)
+container for ruby. Just tell Jerry how to build your application and it will set it all up for you.
+
+Installation
+============
+
+The usual stuff. Either
+
+```ruby
+gem 'jerry'
+```
+
+then
+
+    $ bundle install
+
+or
+
+    $ gem install jerry
+
+Usage
+=====
+
+Let's say you have the following code:
+
+```ruby
+class Window; end
+class Door; end
+
+class House
+  attr_reader :window, :door
+  
+  def initialize(window, door)
+    @window = window
+    @door = door
+  end
+end
+```
+
+First, require jerry:
+
+```ruby
+require 'jerry'
+```
+    
+Then, define a config class. This class tells jerry how to construct your application.
+
+```ruby
+class MyConfig < Jerry::Config
+  component(:window) { Window.new }
+  component(:door) { Door.new }
+  component(:house) { House.new rig(:window), rig(:door) }
+end
+```
+
+The `component` method defines a component. Usually you'll want a component per class. The `rig` method tells jerry to
+build a component.
+
+Finally, when you want to build your application, ask jerry to do it for you.
+
+```ruby
+jerry = Jerry.new MyConfig.new
+house = jerry.rig :house
+```
+
+Scopes
+------
+
+The `component` method lets you specify a scope. The scope can either be `:single` or `:instance` and the default is
+`:single`. If you set the scope to `:single` only one instance of the component will be created. If you set it to
+`:instance`, a new instance of the component will be created each time you call `rig`.
+
+```ruby
+class MyConfig < Jerry::Config
+  component(:window, scope: :instance) { Window.new }
+  component(:door, scope: :single) { Door.new }
+end
+jerry = Jerry.new MyConfig.new
+
+window_a = jerry.rig :window
+window_b = jerry.rig :window
+window_a.object_id == window_b.object_id
+#=> false
+
+door_a = jerry.rig :door
+door_b = jerry.rig :door
+door_a.object_id == door_b.object_id
+#=> true
+```
+
+Multiple configs
+----------------
+
+Jerry lets you use multiple configs. This way you can organize your configs however you want. You can pass multiple
+configs to `Jerry.new` or you can use `jerry << SomeConfig.new` to add configs to jerry.
+
+If two configs define the same component, the config that was inserted last will have priority. With `Jerry.new`, the
+later arguments have priority.
+
+```ruby
+class ConfA < Jerry::Config
+  component(:thing) { "from a" }
+end
+class ConfB < Jerry::Config
+  component(:thing) { "from b" }
+end
+jerry = Jerry.new ConfA.new, ConfB.new
+
+jerry.rig :thing
+#=> "from b"
+```

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new :spec
+task :default => :spec

data/jerry.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jerry/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'jerry'
+  spec.version       = Jerry::VERSION
+  spec.authors       = ['Boris Bera']
+  spec.email         = ['bboris@rsoft.ca']
+  spec.summary       = %q{Jerry rigs your application together. It's an Inversion of Control container.}
+  spec.description   = %q{Jerry is an Inversion of Control container. It allows you to decouple the code that bootstraps your application from the rest of your application}
+  spec.homepage      = 'http://github.com/beraboris/jerry'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0.0'
+  spec.add_development_dependency 'yard', '~> 0.8.7.4'
+end

data/lib/jerry/config.rb

@@ -0,0 +1,47 @@
+require 'jerry/sugar'
+
+class Jerry
+  # Base class for all jerry configs.
+  #
+  # It defines all of the instance methods for a config
+  #
+  # @abstract Subclass to define a config
+  # @example
+  #   class MyConfig < Jerry::Config
+  #     component(:service) { MyService.new }
+  #     component(:app) { MyApp.new rig(:service) }
+  #   end
+  # @see Jerry::Sugar injected class methods
+  class Config
+    # Injects Jerry::Sugar into inherited classes
+    def self.inherited(subclass)
+      subclass.send :extend, Jerry::Sugar
+    end
+
+    # @return [Array<Symbol>] list of components defined by the config
+    def components
+      self.class.components
+    end
+
+    # Jerry instance the config is part of
+    #
+    # This gets set by Jerry when it loads a config
+    attr_writer :jerry
+
+    protected
+
+    # Creates a component
+    def rig(component)
+      @jerry.rig component
+    end
+
+    # Check if given component exists
+    def knows?(component)
+      @jerry.knows? component
+    end
+
+    def cache
+      @cache ||= {}
+    end
+  end
+end

data/lib/jerry/sugar.rb

@@ -0,0 +1,41 @@
+class Jerry
+  class ComponentError < StandardError; end
+
+  # Contains all the class helper methods that are injected when you inherit from Jerry::Config
+  module Sugar
+    # @return [Array<Symbol>] list of the components defined by the config
+    def components
+      @components ||= []
+    end
+
+    # Defines a component
+    #
+    # @param [Symbol] name name of the component
+    # @param [Hash] options options hash see supported options
+    # @option options [Symbol] (:single) The scope of the component. Can be either :single or :instance.
+    #   When the scope is :single, only one instance of the component will be created and every call
+    #   to Jerry#rig will return the same instance. When the scope is :instance, every call to Jerry#rig
+    #   will return a new instance.
+    # @yield Block used to instantiate the component. This block in only called when Jerry#rig is called.
+    # @raise [Jerry::ComponentError] when the block is missing or the scope is invalid
+    def component(name, options={}, &block)
+      raise Jerry::ComponentError, "could not define component #{name}, block is missing" if block.nil?
+
+      scope = options[:scope] || :single
+      unless [:single, :instance].include? scope
+        raise Jerry::ComponentError, "could not define component #{name}, scope #{scope} is unknown"
+      end
+
+      define_method name do
+        case scope
+          when :single
+            cache[name] ||= instance_eval(&block)
+          when :instance
+            instance_eval(&block)
+        end
+      end
+
+      components << name
+    end
+  end
+end

data/lib/jerry/version.rb

@@ -0,0 +1,3 @@
+class Jerry
+  VERSION = '1.0.0'
+end

data/lib/jerry.rb

@@ -0,0 +1,52 @@
+require 'jerry/version'
+require 'jerry/config'
+
+# Inversion of Control container.
+#
+# This class is in charge of bootstrapping your application. This is done by defining {Jerry::Config configs}.
+#
+# @example
+#   class MyConfig < Jerry::Config
+#     component(:app) { MyApp.new }
+#   end
+#   jerry = Jerry.new MyConfig.new
+#   jerry.rig :app #=> #<MyApp:...>
+class Jerry
+  class RigError < StandardError; end
+
+  # @param [Jerry::Config] configs Configs used to rig components. Multiple config can be given. If two configs
+  #   define the same component, the later one will have priority.
+  def initialize(*configs)
+    @index = {}
+
+    configs.each { |config| self << config }
+  end
+
+  # Load a config
+  #
+  # @param [Jerry::Config] config Config to be loaded. If the loaded config defines a component already defined
+  #   by another config, the component from the new config will take priority.
+  def <<(config)
+    components = config.components
+    components.each { |component| @index[component] = config }
+    config.jerry = self
+  end
+
+  # Rigs a component
+  #
+  # @param [Symbol] component Component to rig.
+  # @return The component requested
+  # @raise [Jerry::RigError] when the requested component does not exist
+  def rig(component)
+    raise RigError, "could not find component #{component}" unless knows? component
+
+    @index[component].public_send component
+  end
+
+  # Checks if a component exists
+  #
+  # @param [Symbol] component component to check
+  def knows?(component)
+    @index.has_key? component
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,64 @@
+require 'rspec'
+require 'jerry/config'
+
+describe Jerry::Config do
+  let(:klass) {Class.new(Jerry::Config)}
+
+  it 'should extend the its subclass with Jerry::Sugar when inherited' do
+    expect(klass.singleton_class.included_modules).to include Jerry::Sugar
+    expect(klass).to respond_to :components
+    expect(klass).to respond_to :component
+  end
+
+  describe '#components' do
+    it 'should call the class contents method' do
+      instance = klass.new
+
+      expect(klass).to receive(:components).and_return([:something])
+
+      expect(instance.components).to eq([:something])
+    end
+  end
+
+  describe '#rig' do
+    it 'should call rig on the previously set jerry' do
+      jerry = double('jerry')
+      config = klass.new
+      config.jerry = jerry
+
+      expect(jerry).to receive(:rig).with(:target)
+
+      config.instance_eval { rig :target }
+    end
+
+    it 'should return the result from the jerry rig method' do
+      jerry = double('jerry')
+      allow(jerry).to receive(:rig).with(anything).and_return 42
+      config = klass.new
+      config.jerry = jerry
+
+      expect(config.instance_eval { rig :something }).to eq(42)
+    end
+  end
+
+  describe '#knows?' do
+    it 'should call the knows? method on the previously set jerry' do
+      jerry = double('jerry')
+      config = klass.new
+      config.jerry = jerry
+
+      expect(jerry).to receive(:knows?).with(:target)
+
+      config.instance_eval { knows? :target }
+    end
+
+    it 'should return the results from the jerry knows? method' do
+      jerry = double('jerry')
+      allow(jerry).to receive(:knows?).with(anything).and_return true
+      config = klass.new
+      config.jerry = jerry
+
+      expect(config.instance_eval { knows? :something }).to be_truthy
+    end
+  end
+end

data/spec/jerry_spec.rb

@@ -0,0 +1,132 @@
+require 'rspec'
+require 'jerry'
+
+describe Jerry do
+  it 'should work with all the pieces' do
+    house = Class.new do
+      attr_reader :window, :door
+
+      def initialize(window, door)
+        @window = window
+        @door = door
+      end
+    end
+    window = Class.new
+    door = Class.new
+
+    config = Class.new(Jerry::Config) do
+      component(:window) { window.new }
+      component(:door) { door.new }
+      component(:house) {
+        house.new rig(:window), rig(:door)
+      }
+    end
+    jerry = Jerry.new config.new
+
+    instance = jerry.rig :house
+
+    expect(instance).not_to be_nil
+    expect(instance).to be_a house
+    expect(instance.window).not_to be_nil
+    expect(instance.window).to be_a window
+    expect(instance.door).not_to be_nil
+    expect(instance.door).to be_a door
+  end
+
+  describe '#rig' do
+    it 'should raise error if the component does not exist' do
+      jerry = Jerry.new
+
+      expect{jerry.rig :not_actually_a_thing}.to raise_error(Jerry::RigError)
+    end
+
+    it 'should call the component method on the config' do
+      config = double('config', components: [:doomsday_device]).as_null_object
+      jerry = Jerry.new config
+
+      expect(config).to receive(:doomsday_device).with(no_args)
+
+      jerry.rig :doomsday_device
+    end
+
+    it 'should call the component method registered last' do
+      target = double('target')
+      jerry = Jerry.new double('old config', components: [:target]).as_null_object,
+                        double('new config', components: [:target], target: target).as_null_object
+
+      component = jerry.rig :target
+
+      expect(component).to eq(target)
+    end
+  end
+
+  describe '#<<' do
+    let(:jerry) { Jerry.new }
+
+    it 'should fetch the config components' do
+      config = double('config').as_null_object
+
+      expect(config).to receive(:components).and_return([])
+
+      jerry << config
+    end
+
+    it 'should register components' do
+      config = double('config', components: [:target]).as_null_object
+
+      jerry << config
+
+      expect(jerry.knows? :target).to be_truthy
+    end
+
+    it 'should overwrite previous components' do
+      target = double('target')
+      config = double('config', components: [:target], target: target).as_null_object
+
+      jerry << config
+
+      expect(jerry.rig :target).to eq(target)
+    end
+
+    it 'should pass an instance of itself to the config' do
+      config = double('config', components: []).as_null_object
+
+      expect(config).to receive(:jerry=).with(jerry)
+
+      jerry << config
+    end
+  end
+
+  describe '#knows?' do
+    it 'should be true when the component is defined by a config' do
+      jerry = Jerry.new double('config', components: [:target]).as_null_object
+
+      expect(jerry.knows? :target).to be_truthy
+    end
+
+    it 'should be false if the component is defined by no config' do
+      jerry = Jerry.new double('config', components: [:not_target]).as_null_object
+
+      expect(jerry.knows? :target).to be_falsey
+    end
+  end
+
+  describe '#initialize' do
+    it 'should register all the config components' do
+      configs = 'a'.upto('c').map {|i| double("config #{i}", components: [i.to_sym]).as_null_object}
+      jerry = Jerry.new(*configs)
+
+      expect(jerry.knows? :a).to be_truthy
+      expect(jerry.knows? :b).to be_truthy
+      expect(jerry.knows? :c).to be_truthy
+    end
+
+    it 'should give priority to the components of later configs' do
+      target = double('target')
+      jerry = Jerry.new double('old config', components: [:target]).as_null_object,
+                        double('new config', components: [:target], target: target).as_null_object
+
+      expect(jerry.rig :target).to eq(target)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+silence_warnings do
+  require 'coveralls'
+  Coveralls.wear!
+end
+
+RSpec.configure do |config|
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+end

data/spec/sugar_spec.rb

@@ -0,0 +1,111 @@
+require 'rspec'
+require 'jerry/config'
+
+describe Jerry::Sugar do
+  let(:sugar) {Class.new Jerry::Config}
+
+  describe '#component' do
+    it 'should create a method with the given name' do
+      sugar.component(:my_component) {}
+
+      expect(sugar.new).to respond_to(:my_component)
+    end
+
+    it 'should add the name to the list of components' do
+      sugar.component(:target) {}
+
+      expect(sugar.components).to include(:target)
+    end
+
+    it 'should raise an error when scope is unknown' do
+      expect{sugar.component(:target, scope: :not_a_thing) {}}.to raise_error(Jerry::ComponentError)
+    end
+
+    it 'should raise an error when block is missing' do
+      expect{sugar.component :target}.to raise_error(Jerry::ComponentError)
+    end
+
+    describe 'defined method' do
+      it 'should have the right self set' do
+        sugar.component(:_self) { self }
+        instance = sugar.new
+
+        expect(instance._self).not_to be_a Class
+        expect(instance._self).to be_a sugar
+        expect(instance._self).to eq(instance)
+      end
+
+      context 'with scope set to :single' do
+        it 'should only call the block once' do
+          call_count = 0
+          sugar.component(:target, scope: :single) {call_count += 1}
+          instance = sugar.new
+
+          3.times {instance.target}
+
+          expect(call_count).to eq(1)
+        end
+
+        it 'should keep returning the first created component' do
+          call_count = 0
+          sugar.component(:target, scope: :single) {call_count += 1}
+          instance = sugar.new
+
+          expect(instance.target).to eq(1)
+          expect(instance.target).to eq(1)
+          expect(instance.target).to eq(1)
+        end
+      end
+
+      context 'with scope set to :instance' do
+        it 'should call the block every time' do
+          call_count = 0
+          sugar.component(:target, scope: :instance) {call_count += 1}
+          instance = sugar.new
+
+          3.times {instance.target}
+
+          expect(call_count).to eq(3)
+        end
+
+        it 'should return a new instance every time' do
+          call_count = 0
+          sugar.component(:target, scope: :instance) {call_count += 1}
+          instance = sugar.new
+
+          expect(instance.target).to eq(1)
+          expect(instance.target).to eq(2)
+          expect(instance.target).to eq(3)
+        end
+      end
+
+      context 'with no scope' do
+        it 'should only call the block once' do
+          call_count = 0
+          sugar.component(:target) {call_count += 1}
+          instance = sugar.new
+
+          3.times {instance.target}
+
+          expect(call_count).to eq(1)
+        end
+
+        it 'should keep returning the first created component' do
+          call_count = 0
+          sugar.component(:target) {call_count += 1}
+          instance = sugar.new
+
+          expect(instance.target).to eq(1)
+          expect(instance.target).to eq(1)
+          expect(instance.target).to eq(1)
+        end
+      end
+    end
+  end
+
+  describe '#components' do
+    it 'should default to an empty array' do
+      expect(sugar.components).to eq([])
+    end
+  end
+end

data/spec/support/silence_warnings.rb

@@ -0,0 +1,7 @@
+def silence_warnings
+  original = $VERBOSE
+  $VERBOSE = nil
+  result = yield
+  $VERBOSE = original
+  result
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: jerry
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Boris Bera
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7.4
+description: Jerry is an Inversion of Control container. It allows you to decouple
+  the code that bootstraps your application from the rest of your application
+email:
+- bboris@rsoft.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- jerry.gemspec
+- lib/jerry.rb
+- lib/jerry/config.rb
+- lib/jerry/sugar.rb
+- lib/jerry/version.rb
+- spec/config_spec.rb
+- spec/jerry_spec.rb
+- spec/spec_helper.rb
+- spec/sugar_spec.rb
+- spec/support/silence_warnings.rb
+homepage: http://github.com/beraboris/jerry
+licenses:
+- MIT
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Jerry rigs your application together. It's an Inversion of Control container.
+test_files:
+- spec/config_spec.rb
+- spec/jerry_spec.rb
+- spec/spec_helper.rb
+- spec/sugar_spec.rb
+- spec/support/silence_warnings.rb
+has_rdoc: