service_bureau 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjdhMDFkZTZlNTMxMWMyMzA1YTRlMDQ5ODU1Yzg1ZjQyMDE3YTFlZg==
+  data.tar.gz: !binary |-
+    OGE4OTI2NDI3MTE2MWZiODM0MGE1YTZjZWU1M2RjYzY0MzcyMzM5ZQ==
+SHA512:
+  metadata.gz: !binary |-
+    NWUzY2IyMDQ5MjVjOTNlNDYxYWM2Nzk4NjkwOWIwNTMyYWFjYjE5NDJiZjVi
+    ZjkyNjBhYjhlMzU4Y2U5MDVmNWRiYmYyMWZjNDRmZTdlNTNjNWRiZDkzZjU4
+    MGY1ZTc5NzQ1MzA4Njg5MjRlMDYxMWNlZWZkOWRmYzZjYzEzMTQ=
+  data.tar.gz: !binary |-
+    NWM0YzgwZDc5NmEwMDU4ODIyMzg1ZGE4YmQ2NjczOThmZDg2M2Y2ZDhjNmE1
+    ZDRiOWQ1Y2Y5MDNmNzdlZDIzM2UwMzg1NWI1MDJhODA1NDQ5OGMxMGIyYmVm
+    MWJkNmM2ZGI5NDhjNjJjODVmODhkNzhkYjY3NzM5YzA3YjI2ZmE=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in service_bureau.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Matt Van Horn
+
+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,128 @@
+# ServiceBureau
+
+ServiceBureau provides an easy way to use extracted service objects, as described
+by Bryan Helmkamp, in this great article on dealing with fat models: http://blog.codeclimate.com/blog/2012/10/17/7-ways-to-decompose-fat-activerecord-models/
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'service_bureau'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install service_bureau
+
+## Configuration
+
+The ServiceBureau is configured with names of services and factories that
+will provide an instance of the service. For services that are classes instead of
+instances, you can provide a lambda that returns the class.
+
+A factory can be any object that responds to `#call` - a Proc, lambda, method obj, etc.
+
+If your service requires arguments to initialize it, make sure the proc accepts them.
+
+```ruby
+  ServiceBureau::Locations.configure do |config|
+    config.my_service ->{ MyService.instance }
+    config.another_service AnotherService.public_method(:new)
+    config.a_svc_that_needs_args ->(arg1, arg2){ OtherService.new(arg1).setup(arg2) }
+    config.static_service ->{ ServiceClass }
+  end
+```
+
+## Usage
+
+In your client classes, you can use this a couple of ways:
+
+### As a mixin:
+
+You get a handle to the service:
+
+```ruby
+class MyClass
+  include ServiceBureau::Services
+
+  def my_method
+    result = my_service.do_something
+  end
+
+  # if initialization is needed, just pass in the args.
+  def my_method
+    result = my_service(42).do_something
+  end
+end
+```
+
+And you get an injector to keep your tests fast and decoupled:
+```ruby
+describe MyClass
+  let(:stubbed_service){ double('fake service', do_something: "a result") }
+
+  subject(:my_obj){ MyClass.new }
+
+  before do
+    my_class.my_service = stubbed_service
+  end
+
+  # stubbed
+  it "does something" do
+    expect(my_class.my_method).to eq("a result")
+  end
+
+  # mocked
+  it "does something" do
+    expect(stubbed_service).to receive(:do_something).and_return("a result")
+    my_class.my_method
+  end
+end
+```
+
+### As a regular class method lookup
+```ruby
+class MyClass
+  def my_method
+    service = ServiceBureau::Locator.get_service(:my_service, 'any', 'arguments')
+    result = service.do_something
+  end
+end
+```
+
+The handle to the instance will memoize it, and only instantiate it the first time it is called.
+If you need a new instance, you can use the injector to clear out the old one,
+or you can use the class method on Locator to get a new instance (and you can use the injector
+if you want to replace the old one.)
+
+```ruby
+class MyClass
+  include ServiceBureau::Services
+
+  def use_service_with_foo
+    result = my_service(:foo).do_something
+  end
+
+  def use_service_with_bar
+    service = ServiceBureau::Locator.get_service(:my_service, :bar)
+    result = service.do_something
+  end
+
+  def set_service_to_baz
+    new_service_obj = ServiceBureau::Locator.get_service(:my_service, :baz)
+    my_service = new_service_obj
+  end
+end
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/service_bureau/locations.rb

@@ -0,0 +1,26 @@
+module ServiceBureau
+  class Locations
+    class << self
+      def configure(&block)
+        yield self
+      end
+
+      def factory_map
+        @factory_map ||= {}
+      end
+
+      def clear
+        factory_map.clear
+      end
+
+      def method_missing(method_name, *args, &block)
+        if args.size == 1 && !block_given?
+          factory_map[method_name] = args.first
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/service_bureau/locator.rb

@@ -0,0 +1,25 @@
+module ServiceBureau
+  class Locator
+    def initialize
+      @service_factories = ServiceBureau::Locations.factory_map
+    end
+
+    def get_service service_key, *args
+      service_factories.fetch(service_key).call *args
+
+    rescue KeyError
+      raise UnknownServiceError.new("Cannot locate factory for '#{service_key}' - please check your configuration")
+
+    rescue NoMethodError => err
+      if err.message =~ /undefined method `call'/
+        raise UncallableFactoryError.new("The factory registered for '#{service_key}' did not respond to #call")
+      else
+        raise
+      end
+    end
+
+    private
+
+    attr_reader :service_factories
+  end
+end

data/lib/service_bureau/services.rb

@@ -0,0 +1,30 @@
+module ServiceBureau
+  module Services
+    def self.included(base)
+      ServiceBureau::Locations.factory_map.keys.each do |service|
+        # Provide a method to inject the service obj
+        define_method "#{service}=" do |service_obj|
+          __set_service__ service, service_obj
+        end
+
+        # Provide a handle to the service instance
+        define_method service do |*args|
+          __get_service__ service, *args
+        end
+      end
+    end
+
+    private
+
+    def __set_service__(key, service_obj)
+      instance_variable_set :"@__#{key}__", service_obj
+    end
+
+    def __get_service__(key, *args)
+      memoized = instance_variable_get :"@__#{key}__"
+      return memoized || begin
+        __set_service__ key, ServiceBureau::Locator.new.get_service(key, *args)
+      end
+    end
+  end
+end

data/lib/service_bureau/version.rb

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

data/lib/service_bureau.rb

@@ -0,0 +1,9 @@
+require "service_bureau/version"
+require "service_bureau/locations"
+require "service_bureau/locator"
+require "service_bureau/services"
+
+module ServiceBureau
+  class UnknownServiceError < StandardError;end
+  class UncallableFactoryError < StandardError;end
+end

data/service_bureau.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'service_bureau/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "service_bureau"
+  spec.version       = ServiceBureau::VERSION
+  spec.authors       = ["Matt Van Horn"]
+  spec.email         = ["mattvanhorn@gmail.com"]
+  spec.description   = %q{Something of a cross between a Service Locator and an Abstract Factory to enable easier use of the ServiceObject pattern.}
+  spec.summary       = %q{An easy way to provide access to your service classes without creating a lot of coupling}
+  spec.homepage      = ""
+  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"
+  spec.add_development_dependency "rspec", "~> 2.14"
+end

data/spec/service_bureau_spec.rb

@@ -0,0 +1,110 @@
+require "service_bureau"
+
+describe ServiceBureau::Locator do
+  let(:a_service_obj){ double('some service instance') }
+  let(:factory){ ->(arg){ double('other service') } }
+
+  subject(:locator){ ServiceBureau::Locator.new }
+
+  before(:each) do
+    ServiceBureau::Locations.configure do |config|
+      config.bones_mccoy "Dammit, Jim! I'm a String, not a callable."
+      config.some_service ->{ a_service_obj }
+      config.other_service factory
+    end
+  end
+
+  describe '#get_service' do
+    it "gets a configured service" do
+      found_svc = locator.get_service :some_service
+      expect(found_svc).to equal a_service_obj
+    end
+
+    it "instantiates a service with args given" do
+      expect(factory).to receive(:call).with('foo')
+      locator.get_service :other_service, 'foo'
+    end
+
+    context 'when no service is registered' do
+      it "raises UnknownServiceError" do
+        expect{ locator.get_service :no_such_svc }
+          .to raise_error(ServiceBureau::UnknownServiceError)
+      end
+    end
+
+    context 'when the factory registered is not callable' do
+      it "raises UncallableFactoryError" do
+        expect{ locator.get_service :bones_mccoy }
+          .to raise_error(ServiceBureau::UncallableFactoryError)
+      end
+    end
+  end
+end
+
+describe ServiceBureau::Locations do
+  describe ".configure" do
+    it "should not register a service with no arguments" do
+      expect{ ServiceBureau::Locations.configure { |cfg| cfg.no_args } }.to raise_error(NoMethodError)
+    end
+
+    it "should not register a service with multiple arguments" do
+      expect{ ServiceBureau::Locations.configure { |cfg| cfg.two_args :foo, :bar } }.to raise_error(NoMethodError)
+    end
+
+    it "should not register a service with a block argument" do
+      expect{ ServiceBureau::Locations.configure { |cfg| cfg.block_args(:foo){ :bar } } }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '.clear' do
+    before(:each) do
+      ServiceBureau::Locations.configure do |config|
+        config.a_service :foo
+      end
+    end
+
+    it "should clear the factory_map" do
+      ServiceBureau::Locations.clear
+      expect(ServiceBureau::Locations.factory_map).to eq({})
+    end
+  end
+
+  describe '.factory_map' do
+    before(:each) do
+      ServiceBureau::Locations.clear
+      ServiceBureau::Locations.configure do |config|
+        config.a_service :foo
+        config.another_service :bar
+      end
+    end
+
+    it "should return the hash of factories" do
+      expect(ServiceBureau::Locations.factory_map).to eq(a_service: :foo, another_service: :bar)
+    end
+  end
+end
+
+describe ServiceBureau::Services do
+  let(:a_service){ double('some service') }
+  let(:factory){ ->(arg){ a_service } }
+  let(:locator){ ServiceBureau::Locator.new }
+
+  subject(:test_obj){ (Class.new{include ServiceBureau::Services}).new }
+
+  before(:each) do
+    ServiceBureau::Locations.clear
+    ServiceBureau::Locations.configure do |config|
+      config.my_service factory
+    end
+  end
+
+  it "provides access to a service instance" do
+    expect(test_obj.my_service(42)).to equal(a_service)
+  end
+
+  it "provides a way to inject a different service object (e.g. for tests)" do
+    injected = double('injected')
+    test_obj.my_service = injected
+    expect(test_obj.my_service(42)).to equal(injected)
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: service_bureau
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Matt Van Horn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-13 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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+description: Something of a cross between a Service Locator and an Abstract Factory
+  to enable easier use of the ServiceObject pattern.
+email:
+- mattvanhorn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/service_bureau.rb
+- lib/service_bureau/locations.rb
+- lib/service_bureau/locator.rb
+- lib/service_bureau/services.rb
+- lib/service_bureau/version.rb
+- service_bureau.gemspec
+- spec/service_bureau_spec.rb
+homepage: ''
+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.1.4
+signing_key: 
+specification_version: 4
+summary: An easy way to provide access to your service classes without creating a
+  lot of coupling
+test_files:
+- spec/service_bureau_spec.rb
+has_rdoc: