servizio 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 25af1f3c4241dedbd2d60a9d627af897f1bbe0c0
-  data.tar.gz: ca482c365183cf69145f15189f4ef717ae788088
+  metadata.gz: 33a8b3cbe124642d0826b788731ae4931e6b53b4
+  data.tar.gz: 3fc2848c7b95a28eb5a3759c04f9bfe95d3f817b
 SHA512:
-  metadata.gz: f59fbd2c26a199000bdbb1bd3861eefc44da6b6066deac132c8e4fc926b351b1dd34e75d8c008dabfdfce44f8a1c89c0436c70c0aef054e3a9c20c9ead3395bb
-  data.tar.gz: 3237d8c48890fd5a961a7b6b13154a3602292f8f510cd73702799763b40abe5144236b96d180ed5900d26e6d820acd8e923d85189c58424a2d00c0a7865429d2
+  metadata.gz: e012d8e1b27275d4f6ee02b5f27d5ed70444356359637127d771b094acddffdd9cf321df765f9747300955844f1f7e4dae868ba7cb6d02c22cf4e0beeb3ed4fd
+  data.tar.gz: 84fb4472010155b31d22db0b276bb789c506f6d1423e3ee4cf74e225ce1bd7b24afc62a3da1f0e8c62b5831b6040f8f6db81667390535eefcbd3b72b2c9da99e

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - "2.0"
+  - "2.1"
+  - "2.2"

data/Gemfile

@@ -2,3 +2,10 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in servizio.gemspec
 gemspec
+
+gem "codeclimate-test-reporter", group: :test, require: nil
+
+gem "pry",                "~> 0.9.12.6"
+gem 'pry-byebug',         "<= 1.3.2"
+gem "pry-stack_explorer", "~> 0.4.9.1"
+gem "pry-syntax-hacks",   "~> 0.0.6"

data/README.md

@@ -1,24 +1,410 @@
 # Servizio
 
-TODO: Write a gem description
+[![Build Status](https://travis-ci.org/msievers/servizio.svg?branch=master)](https://travis-ci.org/msievers/servizio)
+[![Test Coverage](https://codeclimate.com/github/msievers/servizio/badges/coverage.svg)](https://codeclimate.com/github/msievers/servizio)
+[![Code Climate](https://codeclimate.com/github/msievers/servizio/badges/gpa.svg)](https://codeclimate.com/github/msievers/servizio)
 
-## Installation
+Servizio is a gem to support you creating service objects. It was created after I read a blog post about [service objects](http://brewhouse.io/blog/2014/04/30/gourmet-service-objects.html) from [Philippe Creux](https://twitter.com/pcreux). Realy great post, check it out.
 
-Add this line to your application's Gemfile:
+I liked the ideas presented there, so I began to use them. Quickly I realised, that combining the basic concepts presented in this post with something like ```ActiveModel``` would be awesome. So there was ```Servizio```.  
 
-    gem 'servizio'
+## The basic ideas
 
-And then execute:
+For those who haven't read the original [post](http://brewhouse.io/blog/2014/04/30/gourmet-service-objects.html), let's sum up it's basic thoughts.
 
-    $ bundle
+A service object *does one thing*. It should hold the business logic to perform one action, e.g. to change a users password. It should start with a verb (but your mileage may vary). When used with rails, the should be homed in ```app/services```.
 
-Or install it yourself as:
+In order to keep things organzied, subdirectories/modules should be used, e.g. ```app/services/user/change_password``` which corresponds to ```User::ChangePassword```. Generally subdirectories/modules holding services should be named with the singular noun, representing the object they manipulate, e.g. ```app/services/user/...``` not ```users```, resulting in ```User::ChangePassword``` not ```Users::...``` That way, things are consistent with the rails naming convention regarding models.
 
-    $ gem install servizio
+That does not there has to be a corresponding model if you create a service subdirectory. It's only a convention. So you are free to create something like ```app/services/statistic/create.rb```, allthough there is no ```Statistic``` model. It should be all about business logic. If there is a corresponding model, fine. If not, never mind.
+
+A service object should respond to the ```call``` method. It's the way lambdas and procs are called, so its obvious to use it as a convention. At this point we have something like this
+
+```ruby
+# app/services/user/change_password
+class User::ChangePassword
+  def call(user, old_password, new_password)
+    # check if the old_password is valid
+    # set the users password to new_password
+    ...
+  end
+end
+```
+
+### Why is this cool?!
+
+#### Clean-up models and controllers
+
+In your everyday's rails app, business logic is often cluttered over controllers, models and so on. In order to understand, what it means to *change a users password* you have to walk through a couple of files and pick the relevant parts.
+
+Service objects concentrate this logic, so you can have a look at ```app/services/user/change_password``` and you know whats going on. On the other side, this means that your controllers/models get much simpler. They can do, what they should do. Models should only be concerned about associations, scopes, persistence etc. Controllers should handle incoming requests and pass them down to appropriate services.
+
+#### Quick overview of what an app can do
+
+So you want to know, what your app does/is able to do? Just look into ```app/services```. There you can see very quickly, which uses cases (services) are present and can be used.
+
+#### Splitting up complex business logic is easy
+
+It's easy for an service object to call another one. That way you can split up complex uses cases into simpler ones. Let's get back to our ```User::ChangePassword```. This could be involve two actions
+* verify, that the *current_password* is correct
+* set the users password to *new_password* if the former check passes
+
+So there could be two services ```User::Authenticate``` and ```User::SetPassword``` and of course our ```User::ChangePassword``` service.
+
+```ruby
+class User::ChangePassword
+  def call(user, old_password, new_password)
+    if User::Authenticate.new.call(user, old_password)
+      User::SetPassword.new.call(user, new_password)
+    end
+  end
+end
+```
+
+This is a simple example, but the idea should be clear. Split up complex workflows in to many single one's.
+
+#### Call them from anywhere
+
+Have you ever been in a situation, where you find yourself duplicating functionality for an api or a rake task, allthough you knew you had this functionality allready in your app ? Well, with service objects, this functionality can be called from anywhere. No more duplication. Call your service objects from other service objects, from DelayedJob/Rescue/Sidekiq jobs, inside a rake task or simply the console.
+
+```ruby
+$> User::ChangePassword(my_user, "test", "123")
+```
+
+## What does servizio add to these basic ideas
+
+If you read the *basic ideas* paragraph you noticed, you may noticed, that this can all be done just with POROs. So why Servizio? Well, it simple extends the basic ideas and goes some steps further.
+
+### Common service class
+
+Servizio provides a super class, your services can be inherited from. I will explain the benefits later.
+
+```ruby
+class User::ChangePassword < Servizio::Service
+...
+end
+```
+
+### Service objects are activemodel objects
+
+Because ```Servizio::Service``` includes ```ActiveModel::Model``` all subclass are activemodel objects. This is especially cool, if you work with rails, as you can use activemodel objects similarly to activerecord objects. Besides ```ActiveModel::Model```, ```Servizio::Service``` includes some other activemodel modules.
+
+```ruby
+class Servizio::Service
+  ...
+  extend ActiveModel::Callbacks
+  include ActiveModel::Model
+  include ActiveModel::Validations
+  ...
+end
+```
+
+#### Calling semantic
+
+Because every service is an activemodel object, the calling semantic changes slightly. With servizio, you create an instance of an service with all necessary parameters as a hash and call the resulting instance (an operation).
+
+```ruby
+operation = User::ChangePassword.new(user: current_user, current_password: "123", new_password: "test")
+operation.call
+```
+
+#### Validations
+
+Because ```Servizio::Service``` also includes ```ActiveModel::Validations```, you can validate your operation before calling it, using activerecord-style validators.
+
+```ruby
+class User::ChangePassword < Servizio::Service
+  attr_accessor :current_password
+  attr_accessor :new_password
+  attr_accessor :new_password_confirmation
+  attr_accessor :user
+
+  validates_presence_of :current_password
+  validates_presence_of :new_password
+  validates_presence_of :new_password_confirmation
+  validates_confirmation_of :new_password
+  validates_presence_of :user
+
+  def call
+    Some::External::Service.change_user_password(user.id, current_password, new_password)
+  end
+end
+
+operation = User::ChangePassword.new(user: current_user, current_password: "123", new_password: "test")
+operation.call if operation.valid?
+```
+
+#### Generic error reporting
+
+As a side-effect of including ```ActiveModel::Validations```, any service has an ```errors``` object. If something goes wrong inside your call, you can add an entry there to signal this event to the caller. This solves the problem, how to get notified/react on errors.
+
+One could also simply return ```nil``` from a call in case of an error. But this is not a good solution, because maybe the call returns without a result in any case. ```true``` or ```false``` are also ambiguous. Thatswhy error reporting should be separate from the call result.
+
+```ruby
+class User::ChangePassword < Servizio::Service
+  ...
+  def call
+    begin
+      Some::External::Service.change_user_password(user.id, current_password, new_password)
+    rescue
+      errors.add(:call, "The call failed!")
+    end
+  end
+end
+```
+
+### Operation state accessors
+
+If you subclass ```Servizio::Service``` your service has several state accessors
+* called?
+* error? (alias failed?)
+* success? (alias succeeded?)
+* valid?
+
+You can use them to react on the result of an operation.
+
+```ruby
+operation = User::ChangePassword.new(user: current_user, current_password: "123", new_password: "test")
+operation.call if operation.valid?
+
+if operation.failed?
+  render "..."
+elsif operation.succeeded?
+  redirect_to "..."
+end
+```
+
+### Some meta programming to ease service creation
+
+Have you wondered, where ```operation.result``` comes from ? In no example above it's explictly set. Well let's dig into how ```call``` actualy is implemented.
+
+When you execute the call method of an operation, you actually call ```Servizio::Service:Call.call```, which in fact calls the operations call method later, but wraps it, so that callbacks can be triggered, validations can take place in front of an call and the state of the operation changes automatically.
+
+That's the reason you don't have to do anything but implement your ```call``` method for most simple use cases. Everything else is handled for you automatically.
+
+This is achived by using ruby's ```prepend``` in association with ```inherited```. If you want to know how it works exactly, have a look.
+
+```ruby
+module Servizio::Service::Call
+
+  def call
+    run_callbacks :call do
+      if authorized? && valid?
+        @called = true
+        self.result = super
+      end
+    end
+  end
+
+  ...
+end
+
+class Servizio::Service
+  require_relative "./service/call"
+
+  def self.inherited(subclass)
+    subclass.prepend(Servizio::Service::Call)
+  end
+  
+  ...
+```
+
+As you can see, before a operation is called, it's validated. So an operation, that's invalid, will not execute the acutal call method.
+
+
+### Service objects can be validated
+
+Because each service is an activemodel object, you can
+
+
+## Terminology, conventions and background
+
+Let's clear some terms first, so that they can be used later without further explanation.
+
+### Service
+
+A service is a subclass of ```Servizio::Service```. It has to implement a method named ```call```. It may implement ```ActiveModel```-style validations.
+
+```ruby
+require "servizio"
+
+class ChangePassword < Servizio::Service
+  attr_accessor :current_password
+  attr_accessor :new_password
+  attr_accessor :new_password_confirmation
+  attr_accessor :user
+
+  validates_presence_of :current_password
+  validates_presence_of :new_password
+  validates_presence_of :new_password_confirmation
+  validates_confirmation_of :new_password
+  validates_presence_of :user
+
+  def call
+    Some::External::Service.change_user_password(user.id, current_password, new_password)
+  end
+end
+```
+
+### Operation
+
+An operation is an instance of an service. Let's assume you have a service called ```ChangePassword```, then ```operation = ChangePassword.new```
+
+```ruby
+operation = ChangePassword.new(
+  user: current_user,
+  current_password: "test",
+  new_password: "123",
+  new_password_confirmation: "123"
+)
+```
+
+### Errors
+
+Due to the fact, that ```Servizio::Service``` inludes ```ActiveModel::Validations``` we already got an error store in each derived class in form of an ```errors``` object. One point, all errors can happily reside. You can add entries there, e.g. if you call fails.
+
+```
+class ChangePassword < Servizio::Service
+  attr_accessor :current_password
+  ...
+  
+  def call
+    begin
+      Some::External::Service.change_user_password(user.id, current_password, new_password)
+    rescue
+      errors.add(:call, "Call went wrong!")
+    end
+  end
+end
+```
+
+***Convention***
+If the call fails without an result, e.g. if you are calling an external webservice and get an 500, you should set errors[:call].
+
+### States and callbacks
+
+Servizio knows various states an operation can be in, namely```(denied)```, ```invalid```, ```error```, ```success```. You can hook on to those states by using callbacks.
+
+An call is assumed to be successfull, if the operation was called and ```errors``` is empty. An operation is invalid if it was tried to be called, but didn't validated.
+
+```ruby
+operation.on_invalid -> (operation) do
+  render change_password_user_path
+end
+
+# there can be more than one
+operation.on_invalid -> (operation) do
+  log "Somebody failed to change it's password!"
+end
+
+operation.call
+
+# will be executed immediately (if the call was successfull)
+operation.on_success -> (operation) do
+  flash[:success] = "Password changed!"
+  redirect_to :user_path
+end
+```
+
+Callbacks work like jQuery promises. You can even add callbacks after an operation was called, which will trigger the corresponding callback immediately.
+
+### Call it magic
+
+When you execute the call method of an operation, you actually call ```Servizio::Service:Call.call```, which in fact calls the operations call method later, but wraps it, so that callbacks can be triggered, validations can take place in front of an call and the state of the operation changes automatically.
+
+That's the reason you don't have to do anything but implement your ```call``` method for most simple use cases. Everything else is handled for you automatically.
+
+This is achived by using ruby's ```prepend``` in association with ```inherited```. If you want to know how it works exactly, have a look.
+
+```ruby
+module Servizio::Service::Call
+
+  def call
+    run_callbacks :call do
+      if authorized? && valid?
+        @called = true
+        self.result = super
+      end
+    end
+  end
+
+  ...
+end
+
+class Servizio::Service
+  require_relative "./service/call"
+
+  def self.inherited(subclass)
+    subclass.prepend(Servizio::Service::Call)
+  end
+  
+  ...
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+### Basic example
+
+```ruby
+require "servizio"
+
+class ChangePassword < Servizio::Service
+  attr_accessor :current_password
+  attr_accessor :new_password
+  attr_accessor :new_password_confirmation
+  attr_accessor :user
+
+  validates_presence_of :current_password
+  validates_presence_of :new_password
+  validates_presence_of :new_password_confirmation
+  validates_confirmation_of :new_password
+  validates_presence_of :user
+  
+  def call
+    Some::External::WebService.change_user_password(user.id, current_password, new_password)
+  end
+end
+
+operation = ChangePassword.new(
+  user: current_user,
+  current_password: "test",
+  new_password: "123",
+  new_password_confirmation: "123"
+)
+
+operation.on_invalid -> (operation) do
+  render change_password_user_path
+end
+
+operation.on_success -> (operation) do
+  flash[:success] = "Password changed!"
+  redirect_to :user_path
+end
+
+operation.call
+```
+
+### Why is it cool?!
+
+#### Validations included
+
+Most operations need some kind of input to operate. If we take the ```ChangePassword``` service from the basic example, it needs
+* *current_password*
+* *new_password*
+* *new_password_confirmation* (which must match *new_password*)
+
+The external service which actually changes the password should only be called, if the requirements are met. Because ```Servizio::Service``` is in fact an ```ActiveModel``` class and includes ```ActiveModel::Validations``` you can write ```ActiveRecord``` style validators right into your service object. Than you can call ```valid?``` to check, if everything is ready. Or you simply hook up with an ```on_invalid``` callback.
+
+More than this, because validations work like in ```ActiveRecord```, you can simply build forms for your services, which will exactly behave like for an ```ActiveRecord``` model. That means you can have a ```ChangePassword``` form, not an ```User``` form and it will work with gems like ```simple_form``` out-of-the-box.
+
+#### Callbacks
+
+There is nothing asynchronous in ```Servizio``` till now, but you can register callbacks for various states of an service object instance. Known states are ```(denied)```, ```invalid```, ```error```, ```success```. ```denied``` only works, if the service was instantiated with an ```cancan(can)```-like ability, else an operation is never denied.
+
+
+## Additional readings
+* http://brewhouse.io/blog/2014/04/30/gourmet-service-objects.html
+* https://netguru.co/blog/service-objects-in-rails-will-help
 
 ## Contributing
 

data/Rakefile

@@ -1,2 +1,6 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/servizio/service/define_column_type.rb

@@ -0,0 +1,39 @@
+#
+# In order to make service objects more compatible with simple_form, one should
+# define column types for attributes, so that the input types can be determined
+# by simple_form automatically. Simple include this into your service class.
+#
+module Servizio::Service::DefineColumnType
+  def self.included(base)
+    base.extend ClassMethods
+    base.include InstanceMethods
+  end
+
+  def self.column_type_getter_name(attribute)
+    "defined_column_type_for_#{attribute}"
+  end
+
+  module ClassMethods
+    def define_column_type(attribute, type)
+      define_method(Servizio::Service::DefineColumnType.column_type_getter_name(attribute)) do
+        type.to_sym
+      end
+    end
+  end
+
+  module InstanceMethods
+    def column_for_attribute(attribute)
+      if has_attribute?(attribute)
+        Struct.new(:limit, :name, :type).new(
+          nil,
+          attribute,
+          send(Servizio::Service::DefineColumnType.column_type_getter_name(attribute))
+        )
+      end
+    end
+
+    def has_attribute?(attribute)
+      respond_to?(Servizio::Service::DefineColumnType.column_type_getter_name(attribute))
+    end
+  end
+end

data/lib/servizio/service.rb

@@ -0,0 +1,68 @@
+require "active_model"
+
+class Servizio::Service
+  include ActiveModel::Model
+  include ActiveModel::Validations
+
+  attr_accessor :result
+
+  OperationNotCalledError = Class.new(StandardError)
+
+  # http://stackoverflow.com/questions/14431723/activemodelvalidations-on-anonymous-class
+  def self.name
+    super ? super : "__anonymous_servizio_service_class__"
+  end
+
+  def result
+    called? ? @result : (raise OperationNotCalledError)
+  end
+
+  def called?
+    @called == true
+  end
+
+  def failed?
+    called? && errors.present?
+  end
+
+  def succeeded?
+    called? && errors.blank?
+  end
+
+  #
+  # This code does some metaprogramming magic. It overwrites .new, so that every
+  # instance of a class derived from Servizio::Service, gets a module prepended
+  # automatically. This way, one can easily "wrap" the methods, e.g. #call.
+  #
+  module MethodDecorators
+    module Call
+      def call
+        if valid?
+          self.result = super
+          @called = true
+        else
+          @called = false
+        end
+
+        self
+      end
+    end
+
+    def inherited(subclass)
+      subclass.instance_eval do
+        alias :original_new :new
+
+        def self.inherited(subsubclass)
+          subsubclass.extend(Servizio::Service::MethodDecorators)
+        end
+
+        def self.new(*args, &block)
+          (obj = original_new(*args, &block)).singleton_class.send(:prepend, Servizio::Service::MethodDecorators::Call)
+          return obj
+        end
+      end
+    end
+  end
+
+  extend MethodDecorators
+end

data/lib/servizio/version.rb

@@ -1,3 +1,3 @@
 module Servizio
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/servizio.rb

@@ -1,5 +1,5 @@
 require "servizio/version"
 
 module Servizio
-  # Your code goes here...
+  require_relative "./servizio/service"
 end

data/servizio.gemspec

@@ -16,6 +16,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_dependency "activemodel", ">= 4.0.0"
+  
+  spec.add_development_dependency "bundler",   "~> 1.7"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec",     ">= 3.0.0", "< 4.0.0"
+  spec.add_development_dependency "simplecov", ">= 0.8.0"
 end

data/spec/servizio/service_spec.rb

@@ -0,0 +1,135 @@
+describe Servizio::Service do
+  context "if derived" do
+    let(:service) do
+      Class.new(described_class) do
+        attr_accessor :should_fail
+        attr_accessor :summands
+
+        validates_presence_of :summands
+
+        def should_fail?
+          @should_fail == true
+        end
+
+        def call
+          if should_fail?
+            errors.add(:call, "failed")
+          else
+            summands.reduce(:+)
+          end
+        end
+      end
+    end
+
+    let(:summands)             { [1,2,3] }
+    let(:succeeding_operation) { service.new summands: summands }
+    let(:failing_operation)    { service.new summands: summands, should_fail: true }
+    let(:invalid_operation)    { service.new }
+
+    context "if derived as anonymous class" do
+      # http://stackoverflow.com/questions/14431723/activemodelvalidations-on-anonymous-class
+      it "sets the class name to something non-blank to allow validations" do
+        expect(service.name).not_to be_blank
+      end
+    end
+
+    context "if derived from a derived class" do
+      let(:derived_service) { Class.new(service) }
+
+      it "works as expected" do
+        expect(derived_service.new(summands: summands).call.result).to eq(summands.reduce(:+))
+      end
+    end
+
+    #
+    # call
+    #
+    describe "#call" do
+      context "if the operation is valid with respect to its validators" do
+        it "makes #called? return true" do
+          expect(succeeding_operation.call.called?).to eq(true)
+        end
+      end
+
+      context "if the operation is not valid with respect to its validators" do
+        it "makes #called? return false" do
+          expect(invalid_operation.call.called?).to eq(false)
+        end
+      end
+    end
+
+    #
+    # called?
+    #
+    describe "#called?" do
+      context "if the operation was called (whether there were failures or not)" do
+        it "returns true" do
+          expect(succeeding_operation.call.called?).to be(true)
+          expect(failing_operation.call.called?).to be(true)
+        end
+      end
+    end
+
+    describe "#failed?" do
+      context "if the operation was called without errors" do
+        it "returns false" do
+          expect(succeeding_operation.call.failed?).to be(false)
+        end
+      end
+
+      context "if the operation added something to \"errors\"" do
+        it "returns true" do
+          expect(failing_operation.call.failed?).to be(true)
+        end
+      end
+
+      context "if the operation was not called" do
+        it "returns false" do
+          expect(succeeding_operation.failed?).to be(false)
+          expect(failing_operation.failed?).to be(false)
+        end
+      end
+    end
+
+    #
+    # result
+    #
+    describe "result" do
+      context "if the operation was called" do
+        it "provides the return value of the call method" do
+          expect(succeeding_operation.call.result).to eq(summands.reduce(:+))
+        end
+      end
+
+      context "if the operation was not called" do
+        it "raises an error" do
+          expect { succeeding_operation.result}.to raise_error(described_class::OperationNotCalledError)
+        end
+      end
+    end
+
+    #
+    # succeeded?
+    #
+    describe "#succeeded?" do
+      context "if the operation was called without errors" do
+        it "returns true" do
+          expect(succeeding_operation.call.succeeded?).to be(true)
+        end
+      end
+
+      context "if the operation added something to \"errors\"" do
+        it "returns false" do
+          expect(failing_operation.call.succeeded?).to be(false)
+        end
+      end
+
+      context "if the operation was not called" do
+        it "returns false" do
+          expect(succeeding_operation.succeeded?).to be(false)
+          expect(failing_operation.succeeded?).to be(false)
+        end
+      end
+    end
+  end
+end

data/spec/servizio_spec.rb

@@ -0,0 +1,2 @@
+describe Servizio do
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+if ENV["TRAVIS"]
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+else
+  require "simplecov"
+  SimpleCov.start
+end
+
+begin
+  require "pry"
+rescue LoadError
+end
+
+require "servizio"
+
+RSpec.configure do |config|
+  # begin --- rspec 3.1 generator
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+  # end --- rspec 3.1 generator
+end

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: servizio
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Michael Sievers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-24 00:00:00.000000000 Z
+date: 2015-02-04 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +52,40 @@ dependencies:
     - - ">="
       - !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
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
 description: 
 email: 
 executables: []
@@ -45,13 +93,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/servizio.rb
+- lib/servizio/service.rb
+- lib/servizio/service/define_column_type.rb
 - lib/servizio/version.rb
 - servizio.gemspec
+- spec/servizio/service_spec.rb
+- spec/servizio_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/msievers/servizio
 licenses:
 - MIT
@@ -72,8 +127,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.2
 signing_key: 
 specification_version: 4
 summary: Yet another service object support library
-test_files: []
+test_files:
+- spec/servizio/service_spec.rb
+- spec/servizio_spec.rb
+- spec/spec_helper.rb
+has_rdoc: