mini_object 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 42c7b681ee29460d5b652d07069aa46b50dbd3f7
+  data.tar.gz: 6b9083abe99eed8a6c42b777984e7f0cab6491ae
+SHA512:
+  metadata.gz: fae92c73f7def24ddb55120650925f6ecfedb8e322ce1be48d6aa970be5979e8a76ebbb29625ea8d5efae1f03b468e7a57204378d4f2b4b2fcb90445d777c59d
+  data.tar.gz: 696a5b683d06e54a23ebecb377245c71fd2620c8b785b5502671dc6134eec557253fb5c2241fef0c6711e30803952bd72a1e8a551f31f93f17ee868a39e8381c

data/.yardoc/checksums

@@ -0,0 +1,7 @@
+lib/lazy.rb 7e4d5fabe9a99f5a2751823cd1ea4e67f446ee2e
+lib/inline.rb df7b92b051d5e5072ad5b486576a801fb3a336a7
+lib/section.rb b05f398196140a836f5e125c20f9988f7a7ef000
+lib/version.rb 2b03a00fee65075ba6f4715792ec212a3b47d654
+lib/resolver.rb c4cf365fd98c2d454e2d11404be070b3d46690f6
+lib/injectable.rb c95a2ea2a7500684d293be0c89196887c72ee68a
+lib/mini_object.rb c4541e47c74f1d904221f2067ad9c0fc0e551ea9

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test, :development do
+  gem 'rspec', require: false
+  gem 'pry', require: false
+end

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    mini_object (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    method_source (0.8.2)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  mini_object!
+  pry
+  rake
+  rspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright (c) 2014 Manuel Morales, Workshare ltd., et al.
+
+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,120 @@
+# MiniObject
+
+A set of tools which will make easier to work with objects instead of classes
+and injecting dependencies.
+
+
+## Inline
+
+Allows defining objects ad-hoc passing an initialization block.
+
+```ruby
+homer = Inline.new 'Homer Simpson' do
+  def talk
+    'Doh!'
+  end
+
+  def sleep
+  end
+end
+# => < Homer Simpson / Inline : talk, sleep >
+
+homer.talk
+# => 'Doh!'
+```
+
+## Injectable
+
+Makes easier and nicer to assign values and inject dependencies to objects. 
+The key feature is the ability to assign lambdas as way to resolve the value:
+
+```ruby
+class UsersRepository
+  include Injectable
+  attr_injectable :store
+end
+
+users_repo = UsersRepository.new
+users_repo.store{ app.stores.redis }
+```
+
+In the example, if `app.stores.persistent` changes, the repository
+will inmediately see the new store.
+
+
+## RemarkableInspect
+
+Provides an `inspect` and `to_s` which focus on methods:
+
+```ruby
+class Application
+  include RemarkableInspect
+
+  def config; end
+  def config=; end
+  def stores; end
+end
+# => Application( config/=, stores )
+
+Application.new
+# => < Application : config/=, stores >
+```
+
+## Lazy
+
+A proxy that will lazy evaluate the proxied object.
+Useful when an object expect an dependency but we want to
+instantiate it only on demand:
+
+```ruby
+users_repository.store = Lazy.new { Redis.new }
+```
+
+This way `Redis.new` will only be  executed when `users_repository.store`
+it is called for the first time.
+
+It also allows defining build callbacks:
+
+```ruby
+users_repository.store = Lazy.new { Redis.new }
+users_repository.build_step(:clear) { |redis| redis.flushdb }
+```
+
+
+## Resolver
+
+A proxy that will always evaluate the given block.
+Useful when an object expect an dependency but we want it 
+to be resolved on demand:
+
+```ruby
+users_repository.store = Lazy.new{ app.stores.redis }
+```
+
+In the example, if `app.stores.redis`, the repository
+will inmediately see the new store.
+
+
+## Contributing
+
+Do not forget to run the tests with:
+
+```bash
+rake
+```
+
+And bump the version with any of:
+
+```bash
+$ gem bump --version 1.1.1       # Bump the gem version to the given version number
+$ gem bump --version major       # Bump the gem version to the next major level (e.g. 0.0.1 to 1.0.0)
+$ gem bump --version minor       # Bump the gem version to the next minor level (e.g. 0.0.1 to 0.1.0)
+$ gem bump --version patch       # Bump the gem version to the next patch level (e.g. 0.0.1 to 0.0.2)
+```
+
+
+## License
+
+Released under the MIT License.
+See the [LICENSE](LICENSE.txt) file for further details.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake'
+
+require 'rspec/core/rake_task'
+task :default => :spec
+task :test => :spec
+desc 'Run all specs'
+RSpec::Core::RakeTask.new('spec') do |spec|
+  spec.rspec_opts = %w{}
+end

data/lib/box.rb

@@ -0,0 +1,10 @@
+module MiniObject
+  class Box
+    include Injectable
+    include RemarkableInspect
+
+    def initialize attrs = {}
+      self.attributes= attrs
+    end
+  end
+end

data/lib/injectable.rb

@@ -0,0 +1,73 @@
+module MiniObject
+  module Injectable
+    NULL = Object.new
+
+    def initialize &block
+      super
+      block.call self if block
+    end
+
+    def self.included klass
+      klass.extend self
+    end
+
+    def self.getsetter_definition_for name
+      lambda do |value = NULL, &block|
+        if block
+          if value == NULL || value == nil
+            instance_variable_set("@#{name}_proc", block)
+          else
+            send("#{name}=", value)
+          end
+        else
+          if value == NULL
+            p = instance_variable_get("@#{name}_proc")
+            p || raise("No #{name} defined yet for #{inspect}")
+            p.call
+          else
+            send("#{name}=", value)
+          end
+        end
+      end
+    end
+
+    def self.setter_definition_for name
+      lambda do |value|
+        instance_variable_set("@#{name}_proc", lambda{ value })
+        value
+      end
+    end
+
+    def cattr_injectable name
+      define_singleton_method name, &Injectable.getsetter_definition_for(name)
+      define_singleton_method "#{name}=", &Injectable.setter_definition_for(name)
+    end
+
+    def attr_injectable name
+      define_method name, &Injectable.getsetter_definition_for(name)
+      define_method "#{name}=", &Injectable.setter_definition_for(name)
+    end
+
+    def let name, &block
+      var_name = :"@#{name}"
+
+      define_singleton_method "#{name}=" do |value|
+        instance_variable_set var_name, value
+      end
+
+      define_singleton_method name do
+        if instance_variable_defined? var_name
+          instance_variable_get var_name
+        else
+          instance_variable_set var_name, block.call(self)
+        end
+      end
+    end
+
+    def attributes= attrs
+      attrs.each do |k,v|
+        public_send "#{k}=", v
+      end
+    end
+  end
+end

data/lib/inline.rb

@@ -0,0 +1,24 @@
+module MiniObject
+  class Inline
+    include Injectable
+    include RemarkableInspect
+
+    attr_accessor :inline_name
+
+    def initialize name = nil, &block
+      @inline_name = name || 'inline'
+      instance_exec self, &block if block
+    end
+
+    def remarkable_methods
+      methods - self.class.instance_methods
+    end
+
+    def remarkable_name
+      "#{inline_name || 'anon'} / Inline"
+    end
+
+    # TODO: Explore the possiblity of allowing access to methods and 
+    # vars defined outside the block.
+  end
+end

data/lib/lazy.rb

@@ -0,0 +1,63 @@
+require 'delegate'
+
+module MiniObject
+  class Lazy < Delegator
+    attr_accessor :lazy_name
+
+    def initialize name = nil, &block
+      self.lazy_name = name
+      @block = block
+    end
+
+    def __getobj__
+      @obj ||= @block.call.tap do |obj|
+        build_steps.each do |name, block|
+          block.call obj
+        end
+      end
+    end
+
+    alias get_obj __getobj__
+
+    def resolver_bound
+      @block.binding.eval('self')
+    end
+
+    def build_step name, &block
+      build_steps[name] = block
+    end
+
+    def build &block
+      @block = block
+    end
+
+    def inspect
+      prefix = lazy_name ? "#{lazy_name}: " : ""
+      steps = " " + build_steps.keys.join(", ") if build_steps.any?
+      "< #{prefix}Lazy(#{formatted_block_source}#{steps}) >"
+    end
+
+    alias to_s inspect
+
+    private
+
+    def build_steps
+      @build_steps ||= {}
+    end
+
+    def block_source
+      require 'method_source'
+      begin
+        MethodSource.source_helper(@block.source_location)
+      rescue MethodSource::SourceNotFoundError
+        '{???}'
+      end
+    end
+
+    def formatted_block_source
+      code = block_source.split("\n").map(&:strip).join("; ")
+      code = code[0..59] + "\u2026" if code.length > 60
+      code.inspect
+    end
+  end
+end

data/lib/mini_object.rb

@@ -0,0 +1,12 @@
+require "version"
+
+module MiniObject
+  autoload :Lazy, 'lazy'
+  autoload :Injectable, 'injectable'
+  autoload :Resolver, 'resolver'
+  autoload :Inline, 'inline'
+  autoload :Toolbox, 'toolbox'
+  autoload :Tool, 'tool'
+  autoload :ForwardingDSL, 'forwarding_dsl'
+  autoload :RemarkableInspect, 'remarkable_inspect'
+end

data/lib/remarkable_inspect.rb

@@ -0,0 +1,47 @@
+module MiniObject
+  module RemarkableInspect
+    def to_s
+      "< #{remarkable_name} : #{remarkable_methods.join(", ")} >"
+    end
+
+    alias inspect to_s
+
+    def self.included klass
+      klass.extend ClassMethods
+    end
+
+    private
+
+    def remarkable_methods
+      self.class.remarkable_methods
+    end
+
+    def remarkable_name
+      self.class.name
+    end
+
+    module ClassMethods
+      def inspect
+        "#{formatted_name}( #{remarkable_methods.join(", ")} )"
+      end
+
+      def remarkable_methods
+        (self.instance_methods - Box.instance_methods).map(&:to_s).tap do |mm|
+          # Substittues [my_method, my_method=] by [my_method/=]
+          mm.grep(/\=$/).each do |setter|
+            getter = setter.gsub /\=$/, ''
+            if mm.include? getter
+              mm.delete setter
+              mm[mm.find_index(getter)] = setter.gsub /\=$/, '/='
+            end
+          end
+        end
+      end
+
+      def formatted_name
+        first_ancestor_name = ancestors.map(&:name).compact.first
+        name || "#{first_ancestor_name}:0x#{'%x' % (object_id << 1)}"
+      end
+    end
+  end
+end

data/lib/resolver.rb

@@ -0,0 +1,15 @@
+module MiniObject
+  class Resolver < Delegator
+    def initialize &block
+      @block = block
+    end
+
+    def __getobj__
+      @block.call
+    end
+
+    def resolver_bound
+      @block.binding.eval('self')
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module MiniObject
+  VERSION = "0.0.1"
+end

data/mini_object.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+gem_name = "mini_object"
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "#{gem_name}"
+
+Gem::Specification.new do |spec|
+  spec.name          = gem_name
+  spec.version       = MiniObject::VERSION
+  spec.authors       = ["Manuel Morales"]
+  spec.email         = ['manuelmorales@gmail.com']
+  spec.description   = File.read('README.md').split("\n").reject{|l| l.length == 0 || l =~ /^[#=]+/ }.first
+  spec.summary       = spec.description
+  spec.homepage      = "https://github.com/manuelmorales/#{spec.name.gsub('_','-')}"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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.3"
+  spec.add_development_dependency "rake"
+end

data/spec/box_spec.rb

@@ -0,0 +1,126 @@
+require_relative 'spec_helper'
+require 'box'
+
+describe 'Box' do
+  it 'allows nested boxes' do
+
+    stub_const 'Stores', Class.new(Box) {
+      def memory
+        :memory_store
+      end
+    }
+
+    stub_const 'BoxApp', Class.new(Box) {
+      def stores
+        @stores ||= Stores.new
+      end
+    }
+
+    expect(BoxApp.new.stores.memory).to eq :memory_store
+  end
+
+  it 'allows tools requiring a config' do
+
+    stub_const 'Stores', Class.new(Box) {
+      attr_accessor :config
+
+      def hash; {}; end
+      def array; []; end
+
+      def default
+        case config[:default]
+        when 'array' then array
+        when 'hash' then hash
+        end
+      end
+    }
+
+    stub_const 'Config', Class.new(Box) {
+      def stores
+        @stores ||= { default: 'hash' }
+      end
+    }
+
+    stub_const 'BoxApp', Class.new(Box) {
+      def stores
+        @stores ||= Stores.new config: config.stores
+      end
+
+      def config
+        @config ||= Config.new
+      end
+    }
+
+    subject = BoxApp.new
+    expect(subject.stores.default).to eq({})
+
+    subject.config.stores[:default] = 'array'
+    expect(subject.stores.default).to eq([])
+  end
+
+  it 'allows overriding a tool' do
+
+    stub_const 'BoxApp', Class.new(Box) {
+      attr_accessor :store
+
+      def store
+        @store ||= :memory
+      end
+    }
+
+    subject = BoxApp.new
+    expect(subject.store).to be :memory
+
+    subject.store = :persistent
+    expect(subject.store).to be :persistent
+  end
+
+  it 'allows overriding config files with inheritance' do
+    stub_const 'Defaults', { persistent: true, adapter: 'mysql' }
+    stub_const 'Overrides',  { adapter: 'postgres' }
+
+    stub_const 'Conf', Class.new(Box) {
+      def db
+        @db ||= Defaults.merge db_overrides
+      end
+
+      def db_overrides
+        {}
+      end
+    }
+
+    stub_const 'BoxApp', Class.new(Box) {
+      def config
+        @config ||= Conf.new
+      end
+    }
+
+    stub_const 'TestConf', Class.new(Conf) {
+      def db_overrides
+        Overrides
+      end
+    }
+
+    stub_const 'TestBoxApp', Class.new(BoxApp) {
+      def config
+        @config ||= TestConf.new
+      end
+    }
+
+    expect(BoxApp.new.config.db).to eq({ persistent: true, adapter: 'mysql' })
+    expect(TestBoxApp.new.config.db).to eq({ persistent: true, adapter: 'postgres' })
+  end
+
+  it 'looks pretty' do
+    stub_const 'BoxApp', Class.new(Box){
+      def config; end
+      def config=; end
+      def stores; end
+    }
+
+    subject = BoxApp.new
+
+    expect(subject.to_s).to eq('< BoxApp : config/=, stores >')
+    expect(BoxApp.inspect).to eq('BoxApp( config/=, stores )')
+  end
+end

data/spec/injectable_spec.rb

@@ -0,0 +1,81 @@
+require_relative 'spec_helper'
+require 'injectable'
+
+RSpec.describe 'Injectable' do
+  shared_examples_for 'having an injectable name' do
+    it 'provides getter and setter' do
+      expect(subject.name = 'A name').to eq 'A name'
+      expect(subject.name).to eq 'A name'
+    end
+
+    it 'allows setting a value without the = sign' do
+      expect(subject.name 'A name').to eq 'A name'
+      expect(subject.name).to eq 'A name'
+    end
+
+    it 'allows setting nil' do
+      subject.name = 'A name'
+      expect(subject.name nil).to eq nil
+      expect(subject.name).to eq nil
+    end
+
+    it 'allows setting a value with a lambda' do
+      subject.name { 'A name' }
+      expect(subject.name).to eq 'A name'
+    end
+
+    it 'does not memoize the lambda' do
+      counter = 0
+      subject.name { counter += 1 }
+      expect(subject.name).to eq 1
+      expect(subject.name).to eq 2
+    end
+
+    it 'gives priority to the value if both, block and value == nil are given' do
+      subject.name('value'){ 'block' }
+      expect(subject.name).to eq('value')
+
+      subject.name(nil) { 'block' }
+      expect(subject.name).to eq('block')
+    end
+  end
+
+  context 'attr_accessor within a class' do
+    let(:subject_class) do
+      Class.new do
+        include Injectable
+        attr_injectable :name
+      end
+    end
+
+    subject { subject_class.new }
+    it_behaves_like 'having an injectable name'
+  end
+
+  context 'cattr_accessor within a class' do
+    let(:subject_class) do
+      Class.new do
+        include Injectable
+        cattr_injectable :name
+      end
+    end
+
+    subject { subject_class }
+    it_behaves_like 'having an injectable name'
+  end
+
+  describe '#attributes=' do
+    let(:subject_class) do
+      Class.new do
+        include Injectable
+        cattr_injectable :name
+      end
+    end
+
+    it 'assings each attr' do
+      subject = subject_class
+      subject.attributes=({ name: 'MyName' })
+      expect(subject.name).to eq 'MyName'
+    end
+  end
+end

data/spec/inline_spec.rb

@@ -0,0 +1,28 @@
+require_relative 'spec_helper'
+
+RSpec.describe 'Inline' do
+  it 'allows defining methods with an initialization block' do
+    subject = Inline.new do
+      def bark
+        'woof'
+      end
+    end
+
+    expect(subject.bark).to eq('woof')
+  end
+
+  it 'has an inspect and to_s' do
+    subject = Inline.new 'some name' do
+      def bark
+        'woof'
+      end
+
+      def sleep
+        'zzz'
+      end
+    end
+
+    expect(subject.inspect).to eq("< some name / Inline : bark, sleep >")
+    expect(subject.to_s).to eq("< some name / Inline : bark, sleep >")
+  end
+end

data/spec/lazy_spec.rb

@@ -0,0 +1,71 @@
+require_relative 'spec_helper'
+
+RSpec.describe 'Lazy' do
+  let(:klass) { double('class', new: instance) }
+  let(:instance) { double('instance', a_method: 'a_result') }
+
+  it 'forwards messages to the result of the lambda' do
+    subject = Lazy.new{ klass.new }
+    expect(subject.a_method).to eq('a_result')
+  end
+
+  it 'is lazy' do
+    expect(klass).not_to receive(:new)
+    subject = Lazy.new{ klass.new }
+  end
+
+  it 'memoizes the result' do
+    expect(klass).to receive(:new).once
+    subject = Lazy.new{ klass.new }
+
+    subject.a_method
+    subject.a_method
+  end
+
+  describe 'inspect' do
+    it 'has the source code' do
+      subject = Lazy.new { klass.new }
+      expect(subject.inspect).to match('klass.new')
+    end
+
+    it 'has a name' do
+      subject = Lazy.new('The Subject') { klass.new }
+      expect(subject.inspect).to match('The Subject')
+    end
+
+    it 'doesn\'t have the name when blank' do
+      subject = Lazy.new { klass.new }
+      expect(subject.inspect).to match('< Lazy')
+    end
+
+    it 'is aliased as to_s' do
+      subject = Lazy.new { klass.new }
+      expect(subject.to_s).to match('klass.new')
+    end
+  end
+
+  describe 'build_steps' do
+    it 'invokes them at build time' do
+      subject = Lazy.new { [] }
+      subject.build_step(:add_one) { |array| array << 1 }
+
+      expect(subject.get_obj).to eq([1])
+    end
+
+    it 'allows substituting them' do
+      subject = Lazy.new { [] }
+      subject.build_step(:add_one) { |array| array << 1 }
+      subject.build_step(:add_one) { |array| array << :one }
+
+      expect(subject.get_obj).to eq([:one])
+    end
+  end
+
+  describe 'build' do
+    it 'assigns the build block' do
+      subject = Lazy.new
+      subject.build { :one }
+      expect(subject.get_obj).to eq :one
+    end
+  end
+end

data/spec/mini_object_spec.rb

@@ -0,0 +1,7 @@
+require_relative 'spec_helper'
+
+describe MiniObject do
+  it 'has a version' do
+    expect(MiniObject::VERSION).not_to be_nil
+  end
+end

data/spec/remarkable_inspect_spec.rb

@@ -0,0 +1,43 @@
+require_relative 'spec_helper'
+
+RSpec.describe 'RemarkableInspect' do
+  subject { SubjectClass.new }
+
+  before do
+    stub_const 'SubjectClass', Class.new {
+      include RemarkableInspect
+
+      def config; end
+      def config=; end
+      def stores; end
+    }
+  end
+
+  describe '#to_s' do
+    it 'contains class name and class specific methods' do
+      expect(subject.to_s).to eq('< SubjectClass : config/=, stores >')
+    end
+  end
+
+  describe '#inspect' do
+    it 'contains class name and class specific methods' do
+      expect(subject.inspect).to eq('< SubjectClass : config/=, stores >')
+    end
+  end
+
+  describe '.to_s' do
+    it 'contains just the class name' do
+      expect(SubjectClass.to_s).to eq('SubjectClass')
+    end
+  end
+
+  describe '.inspect' do
+    it 'contains class name and class specific methods' do
+      expect(SubjectClass.inspect).to eq('SubjectClass( config/=, stores )')
+    end
+
+    it 'contains the object hash in anonymous classes' do
+      expect(Class.new(SubjectClass).inspect).to match(/SubjectClass:0x.*\( config\/=, stores \)/)
+    end
+  end
+end

data/spec/resolver_spec.rb

@@ -0,0 +1,26 @@
+require_relative 'spec_helper'
+
+RSpec.describe 'Resolver' do
+  it 'delegates to the result of evaluating the lambda' do
+    target = double('target')
+    subject = Resolver.new { target }
+
+    expect(target).to receive(:a_method)
+    subject.a_method
+  end
+
+  it 'will always point to the latest value' do
+    target = old_target = double('OLD target')
+    subject = Resolver.new { target }
+
+    target = new_target = double('NEW target')
+    expect(new_target).to receive(:a_method)
+
+    subject.a_method
+  end
+
+  it '#resolver_bound returns the object owner of the binding' do
+    subject = Resolver.new { 2 + 2 }
+    expect(subject.resolver_bound).to eq self
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rspec'
+require 'pry'
+
+RSpec.configure do |config|
+   config.color = true
+   config.tty = true
+end
+
+$LOAD_PATH.unshift File.expand_path('lib')
+require 'mini_object'
+include MiniObject
+
+$LOAD_PATH.unshift File.expand_path('spec/support')
+

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: mini_object
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Manuel Morales
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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'
+description: A set of tools which will make easier to work with objects instead of
+  classes
+email:
+- manuelmorales@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".yardoc/checksums"
+- ".yardoc/object_types"
+- ".yardoc/objects/root.dat"
+- ".yardoc/proxy_types"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/box.rb
+- lib/injectable.rb
+- lib/inline.rb
+- lib/lazy.rb
+- lib/mini_object.rb
+- lib/remarkable_inspect.rb
+- lib/resolver.rb
+- lib/version.rb
+- mini_object.gemspec
+- spec/box_spec.rb
+- spec/injectable_spec.rb
+- spec/inline_spec.rb
+- spec/lazy_spec.rb
+- spec/mini_object_spec.rb
+- spec/remarkable_inspect_spec.rb
+- spec/resolver_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/manuelmorales/mini-object
+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: A set of tools which will make easier to work with objects instead of classes
+test_files:
+- spec/box_spec.rb
+- spec/injectable_spec.rb
+- spec/inline_spec.rb
+- spec/lazy_spec.rb
+- spec/mini_object_spec.rb
+- spec/remarkable_inspect_spec.rb
+- spec/resolver_spec.rb
+- spec/spec_helper.rb
+has_rdoc: