spare 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 873733b8d4c0bd086905e31617ac095c57ac0812
+  data.tar.gz: b334da59cae6adcb6e0978129c40897ea40e9e41
+SHA512:
+  metadata.gz: 1d4308c1a397c3c162d3dbc2280b1835e9a9117c0a86ad18741253b41f43270b1d70143dcb07ca59dc4e5b1b8dd00e31d48bc0e893a2be295feaf0cc9a6c8cb7
+  data.tar.gz: cf3653c5db93a1f14cf8bcd1ba150c86b9bc9b139f65dd85642ddc541ccee9ac72d848ba69503e6eec5823cbe774b9055e96804b4a8e4fb044fee35e7833b75f

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_record-stored_procedure.gemspec
+gemspec
+gem 'byebug'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Joshua Mckinney
+
+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,31 @@
+# Spare
+
+Stored procedure models for ActiveRecord. I work in an environment where stored procedures are used extensively. Many of these stored procedures implement business rules for inserting records and quite a few parameters. I needed a better way to models is objects than the current MO which was to concatenate strings can call the `ActiveRecord::Base.connection.execute` directly. This a very early version and right now only supports Rails 3.2 with Mysql.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'spare'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install spare
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/spare/fork )
+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 a new Pull Request

data/Rakefile

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

data/lib/spare/attributes.rb

@@ -0,0 +1,11 @@
+module Spare
+  module Attributes
+    def columns
+      @columns ||= stored_procedure[:param_list].map do |col|
+        col = col.dup
+        col.primary = false
+        col
+      end
+    end
+  end
+end

data/lib/spare/core.rb

@@ -0,0 +1,17 @@
+module Spare
+  module Core
+    # Returns a string like 'MyStoredProcedure(p_id:integer, p_title:string, p_body:text)'
+    def inspect
+      if self == Base
+        super
+      elsif abstract_class?
+        super
+      elsif table_exists?
+        super
+      else
+        "#{name}(Stored procedure doesn't exist)"
+      end
+    end
+    #########################
+  end
+end

data/lib/spare/model_schema.rb

@@ -0,0 +1,24 @@
+module Spare
+  module ModelSchema
+
+    def schema
+      table_name_prefix
+    end
+
+    def schema=schema
+      self.table_name_prefix = schema
+    end
+
+    def stored_procedure
+      connection.schema_cache.stored_procedure(self.stored_procedure_name)
+    end
+
+    def stored_procedure_name=stored_procedure_name
+      self.table_name=stored_procedure_name
+    end
+
+    def stored_procedure_name
+      table_name
+    end
+  end
+end

data/lib/spare/mysql_abstract_adapter.rb

@@ -0,0 +1,43 @@
+require 'active_record/connection_adapters/abstract_mysql_adapter'
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractMysqlAdapter < AbstractAdapter
+
+      # Returns hash describing the stored procedure.
+      def stored_procedure(name)#:nodoc:
+        name = name.split('.').reverse
+
+        sql = "SELECT db,specific_name,param_list,db_collation FROM mysql.proc WHERE specific_name = #{quote(name[0])}"
+        sql << " AND db = #{quote(name[1])}" if name[1]
+
+        result = execute(sql)
+        keys = result.fields.collect{|k| k.to_sym}
+        values = result.to_a[0]
+        return nil unless values
+        sp = Hash[keys.zip(values)]
+        sp[:param_list] = stored_procedure_params(sp[:param_list], sp[:db_collation])
+        sp
+      end
+
+      # Consider adding the AbstractAdapter::Column when exploring postgres integration
+      class AbstractMysqlAdapter::Column
+        attr_accessor :param_type
+      end
+
+      def stored_procedure_params(param_list,collation)
+        params = []
+        param_list = param_list.to_s.split("\n").collect{ |r| r.gsub(/\s+/, ' ').strip.split(" ")}
+        param_list.delete([])
+        param_list.each do |param|
+          param_type = param[0].upcase
+          field_name = param[1].to_s.underscore #set_field_encoding(param[1])
+          sql_type = param[2]
+          column = new_column(field_name, nil, sql_type, false, collation)
+          column.param_type = param_type
+          params << column
+        end
+        params
+      end
+    end
+  end
+end

data/lib/spare/schema_cache.rb

@@ -0,0 +1,12 @@
+require 'active_record/connection_adapters/schema_cache'
+module ActiveRecord
+  module ConnectionAdapters
+    class SchemaCache
+      # Get the stored procedure
+      def stored_procedure(sp_name)
+        @stored_procedure ||= {}
+        @stored_procedure[sp_name] ||= connection.stored_procedure(sp_name)
+      end
+    end
+  end
+end

data/lib/spare/stored_procedure.rb

@@ -0,0 +1,91 @@
+require "active_record"
+require 'byebug'
+module ActiveRecord
+
+  # TODO - Refactor using only those modules necessary for things to work, should
+  # be a lot easier when updated to support only Rails 4. Also, move any methods here 
+  # to their own module
+  class StoredProcedure < Base
+
+    extend Spare::Core
+    extend Spare::ModelSchema
+    extend Spare::Attributes
+
+    self.pluralize_table_names = false # Stored procedure names are what they are.
+    self.abstract_class = true
+
+    attr_accessor :call_results
+
+    def in_params
+      @in_params ||= in_fetch_params
+    end
+
+    def in_fetch_params
+      prms = []
+      self.class.stored_procedure[:param_list].each do |param|
+        if param.param_type == "IN"
+          prms << self.class.connection.quote(self.send(param.name.to_sym))
+        else # OUT
+          prms << "@#{param.name}"
+        end
+      end
+      prms
+    end
+
+    def out_params
+      @out_params ||= self.class.stored_procedure[:param_list].select{|param| param.param_type.to_s =~ /out/i}
+    end
+
+    def inout_params
+      @inout_params ||= self.class.stored_procedure[:param_list].select{|param| param.param_type.to_s =~ /inout/i}
+    end
+
+    def out_sql
+      "SELECT #{out_params.collect{|param| "@#{param.name}"}.join(',')};"
+    end
+
+    # In MySQL even with multi-statements flag set variables must be set 1 at a time, so return an array
+    def inout_sql
+      sql = []
+      inout_params.each do |param|
+        sql << "SET @#{param.name} = #{connection.quote(send(param.name))}"
+      end
+      sql
+    end
+
+    def call_sql
+      "CALL #{self.class.stored_procedure[:db]}.#{self.class.stored_procedure[:specific_name]}(#{in_params.join(',')});"
+    end
+
+    def to_sql(skip_valid=false)
+      if skip_valid || valid?
+        # sql = (inout_sql.blank? ? "" : inout_sql)
+        sql = call_sql
+        sql << out_sql unless out_params.blank?
+        sql
+      end
+    end
+
+    def execute
+      if valid?
+        conn = self.class.connection
+        unless inout_params.blank?
+          self.inout_sql.each do |inout_to_set|
+            conn.execute(inout_to_set)
+          end
+        end
+        self.call_results = conn.execute(self.to_sql(true))
+        if out_params.length != 0
+          clnt = conn.instance_variable_get(:@connection)
+          while clnt.next_result
+            result_array = clnt.store_result.to_a[0]
+            out_params.each_with_index do |param,i|
+              send "#{param.name}=", result_array[i]
+            end
+          end
+        end
+      end
+      valid?
+    end
+  end
+end

data/lib/spare/version.rb

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

data/lib/spare.rb

@@ -0,0 +1,10 @@
+require "active_record"
+require "spare/core"
+require "spare/attributes"
+require "spare/mysql_abstract_adapter"
+require "spare/model_schema"
+require "spare/schema_cache"
+require "spare/stored_procedure"
+
+module Spare
+end

data/spare.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'spare/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "spare"
+  spec.version       = Spare::VERSION
+  spec.authors       = ["Joshua Mckinney"]
+  spec.email         = ["joshmckin@gmail.com"]
+  spec.summary       = %q{StoredProcedure models for ActiveRecord.}
+  spec.description   = %q{Provides stored procedure modeling for ruby applications that use ActiveRecord}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  
+  spec.add_runtime_dependency 'activerecord', '~> 3.2.0' #,'>= 3.0', '< 5.0'
+  
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-autotest"
+  spec.add_development_dependency "autotest"
+  spec.add_development_dependency "factory_girl"
+  spec.add_development_dependency "mysql2"
+end

data/spec/database.yml

@@ -0,0 +1,16 @@
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+common: &common
+  pool: 100
+  timeout: 5000
+  adapter: mysql2
+  reconnect: true
+  username: root
+
+without_db:
+  <<: *common
+
+test:
+  <<: *common
+  database: sp_test

data/spec/helpers/database_spec_helper.rb

@@ -0,0 +1,100 @@
+require 'active_record/connection_adapters/mysql2_adapter.rb'
+module ActiveRecord
+  class Base
+    # Establishes a connection to the database that's used by all Active Record objects.
+    def self.mysql2_connection(config)
+      config[:username] = 'root' if config[:username].nil?
+      if Mysql2::Client.const_defined? :FOUND_ROWS
+        config[:flags] = Mysql2::Client::FOUND_ROWS | Mysql2::Client::MULTI_STATEMENTS
+      end
+      client = Mysql2::Client.new(config.symbolize_keys)
+      options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
+      ConnectionAdapters::Mysql2Adapter.new(client, logger, options, config)
+    end
+  end
+end
+
+class TestDB
+  def self.yml
+    YAML::load(File.open(File.join(File.dirname(__FILE__),'..',"database.yml")))
+  end
+
+  def self.connect(logging=false)
+    
+    ActiveRecord::Base.configurations = yml
+    ActiveRecord::Base.establish_connection(:test)
+    ActiveRecord::Base.logger = Logger.new(STDOUT) if logging
+  end
+
+  def self.clean
+    DBSpecManagement.connection.execute("DELETE FROM sp_test.foos")
+  end
+
+  #Class to clean tables
+  class DBSpecManagement < ActiveRecord::Base
+  end
+end
+
+#Put all the test migrations here
+class TestMigrations < ActiveRecord::Migration
+  # all the ups
+  def self.up
+    ActiveRecord::Base.establish_connection(:without_db)
+    begin
+      ActiveRecord::Base.connection.execute("CREATE DATABASE IF NOT EXISTS sp_test;")
+    rescue => e
+      puts "Error creating database: #{e}"
+    end
+
+    ActiveRecord::Base.establish_connection(:test)
+    begin
+      create_table "foos" do |t|
+        t.string :name
+        t.decimal :bar
+        t.date :date
+      end
+    rescue => e
+      puts "tables failed to create: #{e}"
+    end
+
+    begin
+      conn = ActiveRecord::Base.connection
+      puts "Dropping \"sp_insert\""
+      conn.execute("DROP procedure IF EXISTS `sp_insert`;")
+      puts "Creating \"sp_insert\""
+      conn.execute(%q{CREATE PROCEDURE `sp_insert`(
+                        IN  p_name    VARCHAR(255)  ,
+                        IN  p_deci    DECIMAL(10,2) ,
+                        IN  p_date    DATE          ,
+                        OUT o_id      INT,
+                        INOUT in_out_add INT
+                      )
+                      BEGIN
+                      SET in_out_add =  in_out_add + 1;
+                      INSERT INTO foos (
+                        name,
+                        bar,
+                        date
+                      )
+                      VALUES (
+                        p_name,
+                        p_deci,
+                        p_date
+                      );
+                      SET o_id = LAST_INSERT_ID();
+                      END})
+
+    rescue => e
+      puts "sp failed to create: #{e}"
+    end
+  end
+
+  # all the downs
+  def self.down
+    begin
+      drop_table "sp_test.foos"
+    rescue => e
+      puts "tables were not dropped: sp_test"
+    end
+  end
+end

data/spec/lib/base_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe ActiveRecord::StoredProcedure do
+	
+end

data/spec/lib/spare/mysql_abstract_adapter_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+describe  ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter do
+
+  describe '#stored_procedure' do
+
+    context "stored procedure does not exist" do
+      it {expect(ActiveRecord::Base.connection.stored_procedure("bad")).to be_nil}
+    end
+
+    context "stored procedure does exist" do
+      before(:each) do
+        conn = ActiveRecord::Base.connection
+        conn.execute("DROP procedure IF EXISTS `sp_test_adapter`;")
+        conn.execute(%q{CREATE PROCEDURE `sp_test_adapter`(
+                          IN  p_name            VARCHAR(255)  ,
+                          IN  p_bar           	DECIMAL(10,2) ,
+                          IN  p_other           DATE		  ,
+                          OUT results			INT(11)
+                        )
+                        BEGIN
+                        END})
+      end
+      context "called with the stored procedure's name" do
+        let (:sp) {ActiveRecord::Base.connection.stored_procedure("sp_test_adapter")}
+        it {expect(sp).to be_a(Hash)}
+        it {expect(sp[:param_list]).to be_a(Array)}
+      end
+
+      context "called the stored procedure and database name" do
+        let (:sp) {ActiveRecord::Base.connection.stored_procedure("sp_test.sp_test_adapter")}
+        it {expect(sp).to be_a(Hash)}
+        it {expect(sp[:param_list]).to be_a(Array)}
+      end
+    end
+  end
+
+  describe '#stored_procedure_params' do
+    let (:sp_params) { %q{IN  p_name            VARCHAR(255)  ,
+                          IN  p_bar           	DECIMAL(10,2) ,
+                          IN  p_other           DATE		  ,
+                          OUT results			INT(11)}
+                       }
+    let (:parsed_params) {ActiveRecord::Base.connection.stored_procedure_params(sp_params, 'utf8_general_ci')}
+
+    it {expect(parsed_params).to be_a(Array)}
+    it {expect(parsed_params.length).to eql(4)}
+    it {expect(parsed_params[0]).to be_a(ActiveRecord::ConnectionAdapters::Mysql2Adapter::Column)}
+    it {expect(parsed_params[0].collation).to eql('utf8_general_ci')}
+    it {expect(parsed_params[0].param_type).to eql('IN')}
+    it {expect(parsed_params[0].name).to eql('p_name')}
+    it {expect(parsed_params[0].type).to eql(:string)}
+    it {expect(parsed_params[1].param_type).to eql('IN')}
+    it {expect(parsed_params[1].name).to eql('p_bar')}
+    it {expect(parsed_params[1].type).to eql(:decimal)}
+    it {expect(parsed_params[2].param_type).to eql('IN')}
+    it {expect(parsed_params[2].name).to eql('p_other')}
+    it {expect(parsed_params[2].type).to eql(:date)}
+    it {expect(parsed_params[3].param_type).to eql('OUT')}
+    it {expect(parsed_params[3].name).to eql('results')}
+    it {expect(parsed_params[3].type).to eql(:integer)}
+  end
+end

data/spec/lib/spare/stored_procedure_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+class SpInsert < ActiveRecord::StoredProcedure;end
+
+class Foo < ActiveRecord::Base;end
+
+describe ActiveRecord::StoredProcedure do
+  it {expect(SpInsert.stored_procedure_name).to eql('sp_insert') }
+
+  context 'attributes' do
+    let(:sp_insert) {SpInsert.new}
+
+    it { expect(sp_insert).to respond_to(:p_name, :p_deci, :p_date, :o_id) }
+  end
+
+  describe '#execute' do
+    let (:sp_insert) {SpInsert.new(:p_name => "foo",:p_deci => 2.0, :p_date => Date.today, :in_out_add => 4)}
+    it {expect(sp_insert).to be_valid}
+    it {expect(sp_insert.execute).to eql(true)}
+    it "should work" do
+      expect {
+        sp_insert.execute
+      }.to change(Foo, :count).by(1)
+    end
+    context "out parameters" do
+      it "should work" do
+        sp_insert.execute
+        expect(sp_insert.o_id).to be_a(Fixnum)
+      end
+    end
+    context "inout parameters" do
+      it "should work" do
+        sp_insert.execute
+        expect(sp_insert.in_out_add).to eql(5)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,85 @@
+ENV["AR_ENV"] = "test"
+require 'spare'
+require 'rspec'
+require 'bundler/setup'
+require 'active_record'
+require 'logger'
+require 'helpers/database_spec_helper'
+
+TestDB.connect
+TestMigrations.down
+TestMigrations.up
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: spare
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joshua Mckinney
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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-autotest
+  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: autotest
+  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: factory_girl
+  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: mysql2
+  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: Provides stored procedure modeling for ruby applications that use ActiveRecord
+email:
+- joshmckin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/spare.rb
+- lib/spare/attributes.rb
+- lib/spare/core.rb
+- lib/spare/model_schema.rb
+- lib/spare/mysql_abstract_adapter.rb
+- lib/spare/schema_cache.rb
+- lib/spare/stored_procedure.rb
+- lib/spare/version.rb
+- spare.gemspec
+- spec/database.yml
+- spec/helpers/database_spec_helper.rb
+- spec/lib/base_spec.rb
+- spec/lib/spare/mysql_abstract_adapter_spec.rb
+- spec/lib/spare/stored_procedure_spec.rb
+- spec/spec_helper.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.4.3
+signing_key: 
+specification_version: 4
+summary: StoredProcedure models for ActiveRecord.
+test_files:
+- spec/database.yml
+- spec/helpers/database_spec_helper.rb
+- spec/lib/base_spec.rb
+- spec/lib/spare/mysql_abstract_adapter_spec.rb
+- spec/lib/spare/stored_procedure_spec.rb
+- spec/spec_helper.rb