tradesman 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3709e7f3b27cda92aaf6dc131eaf6aa1b3de869
+  data.tar.gz: 9862de5df502cccce9682806e1710df738f4bde1
+SHA512:
+  metadata.gz: c1219785e7c94d998ba219a11764daf8df4d76d1073e43ba0a73ee9f31b40df982f90e15d602ebdb53f7ac7fbdd805331207765074549fdde8c9e0817d0f5da2
+  data.tar.gz: 56650c880247e12f10b6638bfab459bbddd5cbcc1c5c6d533235221175d7aa27c1ee2059f185d49dbe4bcddae3b1b26cc7aa9ab6a6bea1514a653cb63e0b56fb

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Blake Turner
+
+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,85 @@
+# Tradesman
+
+Encapsulate common application behaviour with dynamically generated classes.
+
+Tradesman dynamically generates classes with human-readble names that handle the pass, fail, and invalid results of common create, update, and delete actions.
+
+## Usage
+
+```ruby
+# Simple - Returns an Outcome
+outcome = Tradesman::CreateUser.run(user_params)
+outcome.success? #=> true
+outcome.result #=> User Entity
+
+# Passing a block - Well-suited for Controllers
+Tradesman::UpdateUser.run(params[:id], user_update_params) do
+  success do |result|
+    render(text: 'true', status: 200)
+  end
+
+  invalid do |error|
+    render(text: 'false', status: 404)
+  end
+
+  failure do |result|
+    render(text: 'false', status: 400)
+  end
+end
+
+# Can also Delete
+Tradesman::DeleteUser.run(params[:id])
+
+# Or Create as a child of an existing record
+Tradesman::CreateUserForEmployer.run(employer_id, user_params)
+```
+
+## Why is this necessary?
+
+At Onfido, we observed that many Create, Update and Delete actions we programmed were are simple and repeated (albeit with different records and parameter lists) in several locations. They can generally be broken in to the following steps:
+
+- Query existing record by some group of parameters, but generally just by :id (Update and Delete only)
+- Return 404 if record does not exist
+- Update or Create a new record with a given set of parameters. For Deletion, no parameters are required.
+- Return a success, invalid, or failure message based on the result of this persistence action.
+
+Example:
+```ruby
+# users_controller.rb
+def update
+  @user = User.find(params[:id])
+  return render(text: 'false', status: 404) unless @user
+
+  @user.assign_attributes(user_params)
+  return render(text: 'false', status: 400) unless @user.save
+
+  render 'user'
+end
+
+private
+
+def user_params
+  params.permit(:first_name, :last_name, :email)
+end
+```
+
+Yes, the above example is trivial, but many such trivial actions are necessary in web applications.
+Tradesman is designed to handle the above and a few other common use-cases to reduce such tedious, often-repeated boilerplate code.
+
+Tradesman version of the above:
+```ruby
+Tradesman::UpdateUser.run(params[:id], user_params) do
+  success do |result|
+    @user = result
+    render 'user'
+  end
+
+  invalid do |error|
+    render(text: 'false', status: 404)
+  end
+
+  failure { |result| render(text: 'false', status: 400) } # If you prefer one-liners
+end
+```
+
+The Tradesman version says exactly what it does, is cruft free, and is much quicker to test (more on that later).

data/lib/tradesman/builders/base.rb

@@ -0,0 +1,24 @@
+module Tradesman
+  module Builders
+    class Base
+      def initialize(class_name)
+        parser = ::Tradesman::Parser.new(class_name)
+        @subject = parser.subject
+        @parent = parser.parent
+      end
+
+      def class
+        template_class(class_args)
+      end
+
+      private
+
+      def class_args
+        {
+          subject: @subject,
+          parent: @parent
+        }
+      end
+    end
+  end
+end

data/lib/tradesman/builders/create.rb

@@ -0,0 +1,19 @@
+module Tradesman
+  module Builders
+    class Create < Base
+      private
+
+      def template_class(args)
+        Class.new(::Tradesman::Template) do
+          @store = Tradesman.adapter.context_for_entity(args[:subject])
+
+          private
+
+          def execute(params)
+            self.class.adapter.create!(params)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradesman/builders/create_for_parent.rb

@@ -0,0 +1,34 @@
+module Tradesman
+  module Builders
+    class CreateForParent < Base
+      private
+
+      def template_class(args)
+        Class.new(::Tradesman::Template) do
+          @store = Tradesman.adapter.context_for_entity(args[:subject])
+          @parent_store = Tradesman.adapter.context_for_entity(args[:parent])
+          @parent_key = args[:parent]
+
+          class << self
+            attr_reader :parent_store, :parent_key
+
+            def parent_adapter
+              Tradesman.adapter.new(parent_store)
+            end
+          end
+
+          private
+
+          def execute(params)
+            parent = self.class.parent_adapter.get!(params[:parent_id])
+            self.class.adapter.create!(params.except(:parent_id).merge(relation_id => parent.id))
+          end
+
+          def relation_id
+            "#{self.class.parent_key}_id"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradesman/builders/delete.rb

@@ -0,0 +1,19 @@
+module Tradesman
+  module Builders
+    class Delete < Base
+      private
+
+      def template_class(args)
+        Class.new(::Tradesman::Template) do
+          @store = Tradesman.adapter.context_for_entity(args[:subject])
+
+          private
+
+          def execute(params)
+            self.class.adapter.delete!(params[:id])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradesman/builders/update.rb

@@ -0,0 +1,19 @@
+module Tradesman
+  module Builders
+    class Update < Base
+      private
+
+      def template_class(args)
+        Class.new(::Tradesman::Template) do
+          @store = Tradesman.adapter.context_for_entity(args[:subject])
+
+          private
+
+          def execute(params)
+            self.class.adapter.update!(params[:id], params.except(:id))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tradesman/builders.rb

@@ -0,0 +1,20 @@
+module Tradesman
+  module Builders
+    class << self
+      def generate_class(parser)
+        Tradesman.const_set(parser.class_name, builder_for_action(parser.action, parser.parent).new(parser.class_name).class)
+      end
+
+      def builder_for_action(action, parent)
+        case action
+        when :create
+          parent ? CreateForParent : Create
+        when :update
+          Update
+        when :delete
+          Delete
+        end
+      end
+    end
+  end
+end

data/lib/tradesman/configuration.rb

@@ -0,0 +1,30 @@
+module Tradesman
+  module Configuration
+    def configuration
+      @configuration ||= Config.new
+    end
+
+    def reset
+      @configuration = Config.new
+      @adapter, @adapter_map = nil, nil # Class-level cache clear
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def adapter
+      raise ::Tradesman::Errors::Base.new('Adapter has not been configured') unless configuration.adapter
+      @adapter ||= configuration.adapter
+    end
+  end
+
+  class Config
+    attr_accessor :adapter
+
+    def set_adapter(adapter)
+      Horza.configure { |config| config.adapter = adapter }
+      @adapter = Horza.adapter
+    end
+  end
+end

data/lib/tradesman/errors.rb

@@ -0,0 +1,12 @@
+module Tradesman
+  module Errors
+    class Base < StandardError
+    end
+
+    class MethodNotImplemented < StandardError
+    end
+
+    class RecordNotFound < StandardError
+    end
+  end
+end

data/lib/tradesman/parser.rb

@@ -0,0 +1,41 @@
+module Tradesman
+  class Parser
+    attr_reader :class_name, :action_string, :subject_string, :parent_string
+
+    PARSE_REGEX = /(Create|Update|Delete)(.+)/
+    PARSE_REGEX_WITH_PARENT = /(Create|Update|Delete)(.+)4(.+)/
+
+    def initialize(class_name)
+      @class_name = class_name
+      @match = class_name.to_s.match(regex)
+      @action_string, @subject_string, @parent_string = @match.values_at(1, 2, 3) if @match
+    end
+
+    def match?
+      !!@match
+    end
+
+    def action
+      str_to_sym(@action_string)
+    end
+
+    def subject
+      str_to_sym(@subject_string)
+    end
+
+    def parent
+      return nil unless @parent_string
+      str_to_sym(@parent_string)
+    end
+
+    private
+
+    def regex
+      /.+4.+/.match(@class_name) ? PARSE_REGEX_WITH_PARENT : PARSE_REGEX
+    end
+
+    def str_to_sym(str)
+      str.underscore.symbolize
+    end
+  end
+end

data/lib/tradesman/run_methods.rb

@@ -0,0 +1,11 @@
+module Tradesman
+  module RunMethods
+    def run(*context)
+      new(*context).run
+    end
+
+    def run!(*context)
+      new(*context).run!
+    end
+  end
+end

data/lib/tradesman/template.rb

@@ -0,0 +1,26 @@
+module Tradesman
+  class Template
+    include ::Tzu
+    include ::Tzu::Validation
+
+    class << self
+      attr_reader :store
+
+      def adapter
+        Tradesman.adapter.new(store)
+      end
+    end
+
+    def call(params)
+      execute(params)
+    rescue Horza::Errors::RecordInvalid, Horza::Errors::RecordNotFound => e
+      invalid! e
+    end
+
+    private
+
+    def execute(params)
+      raise Tradesman::Errors::MethodNotImplemented.new
+    end
+  end
+end

data/lib/tradesman.rb

@@ -0,0 +1,44 @@
+require 'horza'
+require 'tzu'
+require 'tradesman/builders'
+require 'tradesman/builders/base'
+require 'tradesman/builders/create'
+require 'tradesman/builders/create_for_parent'
+require 'tradesman/builders/delete'
+require 'tradesman/builders/update'
+require 'tradesman/configuration'
+require 'tradesman/errors'
+require 'tradesman/parser'
+require 'tradesman/run_methods'
+require 'tradesman/template'
+
+module Tradesman
+  extend Tradesman::Configuration
+
+  class << self
+    attr_writer :configuration
+
+    def included(base)
+      base.class_eval do
+        extend ::Tradesman::RunMethods
+      end
+    end
+
+    def const_missing(class_name)
+      parser = ::Tradesman::Parser.new(class_name)
+      return super(class_name) unless parser.match?
+      Builders.generate_class(parser)
+    end
+  end
+
+  def run
+    run!
+  rescue ::Tradesman::Errors::Base
+  end
+
+  def run!
+    call
+  rescue *Tradesman.adapter.expected_errors => e
+    raise ::Tradesman::Errors::Base.new(e.message)
+  end
+end

data/spec/builders_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Tradesman::Builders do
+  context '#builder_for_action' do
+    context 'Create' do
+      it 'returns Create class' do
+        expect(Tradesman::Builders.builder_for_action(:create, nil)).to eq Tradesman::Builders::Create
+      end
+    end
+
+    context 'Create with Parent' do
+      it 'returns Create class' do
+        expect(Tradesman::Builders.builder_for_action(:create, :user)).to eq Tradesman::Builders::CreateForParent
+      end
+    end
+
+    context 'Update' do
+      it 'returns Create class' do
+        expect(Tradesman::Builders.builder_for_action(:update, nil)).to eq Tradesman::Builders::Update
+      end
+    end
+
+    context 'Delete' do
+      it 'returns Create class' do
+        expect(Tradesman::Builders.builder_for_action(:delete, nil)).to eq Tradesman::Builders::Delete
+      end
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Tradesman::Parser do
+  context 'when pattern is valid' do
+    context 'CreateUser' do
+      subject { Tradesman::Parser.new('CreateUser') }
+
+      it 'finds a match' do
+        expect(subject.match?).to be true
+      end
+
+      it 'parses the action' do
+        expect(subject.action).to eq :create
+      end
+
+      it 'parses the subject' do
+        expect(subject.subject).to eq :user
+      end
+    end
+
+    context 'CreateUser4Employer' do
+      subject { Tradesman::Parser.new('CreateUser4Employer') }
+
+      it 'finds a match' do
+        expect(subject.match?).to be true
+      end
+
+      it 'parses the action' do
+        expect(subject.action).to eq :create
+      end
+
+      it 'parses the subject' do
+        expect(subject.subject).to eq :user
+      end
+
+      it 'parses the parent' do
+        expect(subject.parent).to eq :employer
+      end
+    end
+
+    context 'DeleteCustomerInvoice' do
+      subject { Tradesman::Parser.new('DeleteCustomerInvoice') }
+
+      it 'finds a match' do
+        expect(subject.match?).to be true
+      end
+
+      it 'parses the action' do
+        expect(subject.action).to eq :delete
+      end
+
+      it 'parses the subject' do
+        expect(subject.subject).to eq :customer_invoice
+      end
+    end
+
+    context 'UpdateTransaction' do
+      subject { Tradesman::Parser.new('UpdateTransaction') }
+
+      it 'finds a match' do
+        expect(subject.match?).to be true
+      end
+
+      it 'parses the action' do
+        expect(subject.action).to eq :update
+      end
+
+      it 'parses the subject' do
+        expect(subject.subject).to eq :transaction
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'byebug'
+require 'rspec'
+require 'active_record'
+require 'bundler/setup'
+Bundler.setup
+
+require 'tradesman'

data/spec/tradesman_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+if !defined?(ActiveRecord::Base)
+  puts "** require 'active_record' to run the specs in #{__FILE__}"
+else
+  ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+  ActiveRecord::Migration.suppress_messages do
+    ActiveRecord::Schema.define(:version => 0) do
+      create_table(:employers, force: true) {|t| t.string :name }
+      create_table(:users, force: true) {|t| t.string :first_name; t.string :last_name; t.references :employer; }
+      create_table(:strict_users, force: true) {|t| t.string :first_name; t.string :last_name; t.references :employer; }
+    end
+  end
+
+  module TradesmanSpec
+    class Employer < ActiveRecord::Base
+      has_many :users
+    end
+
+    class User < ActiveRecord::Base
+      belongs_to :employer
+    end
+
+    class StrictUser < ActiveRecord::Base
+      belongs_to :employer
+
+      validates :last_name, presence: true
+    end
+  end
+end
+
+describe Tradesman do
+  let(:adapter) { :active_record }
+  before { Tradesman.configure { |config| config.set_adapter(adapter) } }
+  after do
+    TradesmanSpec::User.delete_all
+    TradesmanSpec::StrictUser.delete_all
+    TradesmanSpec::Employer.delete_all
+  end
+
+  context '#configure' do
+    context 'when the adapter is set' do
+      it 'returns the correct adapter class' do
+        expect(Tradesman.adapter).to eq Horza::Adapters::ActiveRecord
+      end
+    end
+
+    context 'when the adapter is not set' do
+      before { Tradesman.reset }
+      after { Tradesman.reset }
+
+      it 'throws error' do
+        expect { Tradesman.adapter }.to raise_error(Tradesman::Errors::Base)
+      end
+    end
+  end
+
+  context '#run' do
+    context 'Create' do
+      context 'when parameters are valid' do
+        let(:outcome) { Tradesman::CreateUser.run(last_name: 'Turner') }
+
+        it 'creates a new record' do
+          expect(outcome.success?).to be true
+          expect(outcome.result.id.is_a? Integer).to be true
+        end
+
+        it 'returns Horza Entity' do
+          expect(outcome.result.is_a? Horza::Entities::Single).to be true
+        end
+      end
+
+      context 'when parameters are invalid' do
+        let(:outcome) { Tradesman::CreateStrictUser.run(first_name: 'Turner') }
+        it 'returns an invalid outcome' do
+          expect(outcome.success?).to be false
+          expect(outcome.type).to eq :validation
+        end
+      end
+
+      context 'for parent' do
+        let(:employer) { TradesmanSpec::Employer.create }
+        let(:outcome) { Tradesman::CreateUser4Employer.run(parent_id: employer.id, last_name: 'Turner') }
+
+        it 'creates a new record' do
+          expect(outcome.success?).to be true
+          expect(outcome.result.id.is_a? Integer).to be true
+        end
+
+        it 'associates child with parent' do
+          expect(outcome.result.employer_id).to eq employer.id
+        end
+
+        it 'associates parent with child' do
+          outcome
+          expect(employer.users.first.id).to eq outcome.result.id
+        end
+      end
+    end
+  end
+
+  context 'Update' do
+    let(:user) { TradesmanSpec::User.create(last_name: 'Smith') }
+    context 'when parameters are valid' do
+      let(:outcome) { Tradesman::UpdateUser.run(id: user.id, last_name: 'Turner') }
+
+      it 'executes successfully' do
+        expect(outcome.success?).to be true
+      end
+
+      it 'updates record' do
+        expect(outcome.result.last_name).to eq 'Turner'
+        expect(user.reload.last_name).to eq 'Turner'
+      end
+    end
+
+    context 'when parameters are invalid' do
+      let(:strict_user) { TradesmanSpec::StrictUser.create(last_name: 'Smith') }
+      let(:outcome) { Tradesman::UpdateStrictUser.run(id: strict_user.id, last_name: nil) }
+
+      it 'returns an invalid outcome' do
+        expect(outcome.success?).to be false
+        expect(outcome.type).to eq :validation
+      end
+    end
+  end
+
+  context 'Delete' do
+    context 'when parameters are valid' do
+      let!(:user) { TradesmanSpec::User.create }
+      let(:outcome) { Tradesman::DeleteUser.run(id: user.id) }
+
+      it 'executes successfully' do
+        expect(outcome.success?).to be true
+        expect(outcome.result).to be true
+      end
+
+      it 'deletes record' do
+        expect { outcome }.to change(TradesmanSpec::User, :count).by(-1)
+      end
+    end
+
+    context 'when input parameters are invalid' do
+      let(:outcome) { Tradesman::DeleteUser.run(id: 999) }
+      it 'returns an invalid outcome' do
+        expect(outcome.success?).to be false
+        expect(outcome.type).to eq :validation
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: tradesman
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Blake Turner
+- Morgan Bruce
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: horza
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: tzu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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: byebug
+  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: Encapsulate common application behaviour with dynamically generated classes
+email: mail@blakewilliamturner.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/tradesman.rb
+- lib/tradesman/builders.rb
+- lib/tradesman/builders/base.rb
+- lib/tradesman/builders/create.rb
+- lib/tradesman/builders/create_for_parent.rb
+- lib/tradesman/builders/delete.rb
+- lib/tradesman/builders/update.rb
+- lib/tradesman/configuration.rb
+- lib/tradesman/errors.rb
+- lib/tradesman/parser.rb
+- lib/tradesman/run_methods.rb
+- lib/tradesman/template.rb
+- spec/builders_spec.rb
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+- spec/tradesman_spec.rb
+homepage: https://github.com/onfido/tradesman
+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: Tradesman dynamically generates classes with human-readble names that handle
+  the pass, fail, and invalid results of common create, update, and delete actions.
+test_files:
+- spec/builders_spec.rb
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+- spec/tradesman_spec.rb
+has_rdoc: