spare 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95b4a7463baf2b1727fa3a4d7cef198dbab3eb62
-  data.tar.gz: aa448ecb6a763756efdaa0285f7ac897b1b838c8
+  metadata.gz: eebcabc4cfa5cc1016e4792fcb33d1d3ad3f8ecc
+  data.tar.gz: dd194a9dcb89d2b274f3bbe511d0545ff25320c9
 SHA512:
-  metadata.gz: 253b3557cbf75fd7679dc9a0e37f90e549cba3e96812ddd771db46b57ac937052c6118da53224f84704a19c465cd3a49b21ed3a28f79b9b3b2fcd07b1974479f
-  data.tar.gz: 1a1ebe0650e871f944e1b103ad5ec459d84d9a976d837143d8ea57121f7c71de288db778b975ca6a6818094814b161fbb701830735e255a9fbe3d0f9b8871080
+  metadata.gz: 01199811e2ceb6df16f47ee095bc9786a7d02a65172ff4f68fbbb3ed299467f1050a2a6a9976e3a153112b9de11fd2208d32a46dfa01d117995ed0f7a27643b5
+  data.tar.gz: 33888abe01749bd5b32c951f8e66eb7b1d5b63477417509ae41eedc0d7e643eb6bceedb1979caf4457344e57868d8d867de74c99f32c464330fc678eeed61275

data/lib/spare/exceptions.rb

@@ -1,4 +1,5 @@
 require 'active_record'
 module ActiveRecord
   class StoredProcedureNotFound < StandardError; end
+  class StoredProcedureNotExecuted < RecordNotSaved;end
 end

data/lib/spare/execution.rb

@@ -0,0 +1,62 @@
+module Spare
+  module Execution
+    module ClassMethods
+      # Build an object (or multiple objects) and executes, if validations pass.
+      # The resulting object is returned whether the object was executed successfully to the database or not.
+      #
+      # The +attributes+ parameter can be either a Hash or an Array of Hashes. These Hashes describe the
+      # attributes on the objects that are to be created.
+      def execute(attributes = nil)
+        if attributes.is_a?(Array)
+          attributes.map { |attr| excute(attr) }
+        else
+          object = new(attributes)
+          object.execute
+          object
+        end
+      end
+      alias :call :execute
+
+     # Build an object (or multiple objects) and executes,
+     # if validations pass. Raises a RecordInvalid error if validations fail,
+     # unlike Base#create.
+     #
+     # The +attributes+ parameter can be either a Hash or an Array of Hashes.
+     # These describe which attributes to be created on the object, or
+     # multiple objects when given an Array of Hashes.
+      def execute!(attributes = nil)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create!(attr) }
+        else
+          object = new(attributes)
+          object.execute!
+          object
+        end
+      end
+      alias :call! :execute!
+    end
+
+    attr_accessor :call_results
+
+    def execute
+      if valid?
+        self.class.connection_pool.with_connection do |conn|
+          call_results = conn.execute_stored_procedure(self)
+        end
+      end
+      valid?
+    end
+    alias :call :execute
+
+    def execute!
+      unless valid?
+        raise(ActiveRecord::StoredProcedureNotExecuted.new("Failed to execute the stored procedure", self))
+      end
+    end
+    alias :call! :execute!
+
+    def self.included(base)
+      base.extend(Spare::Execution::ClassMethods)
+    end
+  end
+end

data/lib/spare/mysql_abstract_adapter.rb

@@ -44,12 +44,79 @@ module ActiveRecord
           else
             column = new_column(field_name, nil, sql_type, false, collation)
           end
-          
+
           column.param_type = param_type
           params << column
         end
         params
       end
+
+      def stored_procedure_to_sql(sp)
+        sql = []
+        sql << sp_inout_sql(sp)
+        sql << sp_call_sql(sp)
+        sql << sp_out_sql(sp)
+        sql.compact!
+        sql.join("\n")
+      end
+
+      def execute_stored_procedure(sp)
+
+        call_results = execute(stored_procedure_to_sql(sp))
+
+        if sp_out_params(sp).length != 0
+          clnt = instance_variable_get(:@connection)
+          while clnt.next_result
+            if result_array = clnt.store_result.to_a[0]
+              sp_out_params(sp).each_with_index do |param,i|
+                sp.__send__ "#{param.name}=", result_array[i]
+              end
+            end
+          end
+          nil
+        else
+          call_results
+        end
+      end
+
+      private
+
+      def sp_in_params(sp)
+        prms = []
+        sp.class.stored_procedure[:param_list].each do |param|
+          if param.param_type == "IN"
+            prms << quote(sp.read_attribute(param.name))
+          else # OUT
+            prms << "@#{param.name}"
+          end
+        end
+        prms
+      end
+
+      def sp_out_params(sp)
+        sp.class.stored_procedure[:param_list].select { |param| param.param_type.to_s =~ /out/i }
+      end
+
+      def sp_inout_params(sp)
+        sp.class.stored_procedure[:param_list].select { |param| param.param_type.to_s =~ /inout/i }
+      end
+
+      def sp_out_sql(sp)
+        "SELECT #{sp_out_params(sp).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 sp_inout_sql(sp)
+        sql = []
+        sp_inout_params(sp).each do |param|
+          sql << "SET @#{param.name} = #{quote(sp.send(param.name))};"
+        end
+        sql
+      end
+
+      def sp_call_sql(sp)
+        "CALL #{sp.class.stored_procedure[:db]}.#{sp.class.stored_procedure[:specific_name]}(#{sp_in_params(sp).join(',')});"
+      end
     end
   end
 end

data/lib/spare/stored_procedure.rb

@@ -2,89 +2,24 @@ require "active_record"
 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 
+  # 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
+    include Spare::Execution
 
     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} = #{self.class.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
+        self.class.connection.stored_procedure_to_sql(self)
       end
-      valid?
     end
   end
 end

data/lib/spare/version.rb

@@ -1,3 +1,3 @@
 module Spare
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/lib/spare.rb

@@ -5,6 +5,7 @@ require "spare/attributes"
 require "spare/mysql_abstract_adapter"
 require "spare/model_schema"
 require "spare/schema_cache"
+require "spare/execution"
 require "spare/stored_procedure"
 
 module Spare

data/spec/lib/spare/mysql_abstract_adapter_spec.rb

@@ -21,13 +21,13 @@ describe  ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter do
                         END})
       end
       context "called with the stored procedure's name" do
-        let (:sp) {ActiveRecord::Base.connection.stored_procedure("sp_test_adapter")}
+        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")}
+        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
@@ -35,12 +35,13 @@ describe  ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter do
   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')}
+    let (:sp_params) do
+      %q{IN  p_name           VARCHAR(255)  ,
+         IN  p_bar           	DECIMAL(10,2) ,
+         IN  p_other          DATE		  ,
+         OUT results			    INT(11)}
+    end
+    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)}

data/spec/lib/spare/stored_procedure_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 require 'byebug'
-class SpInsert < ActiveRecord::StoredProcedure;end
+class SpInsert < ActiveRecord::StoredProcedure
+  validates :p_name, presence: true
+end
 
 class Foo < ActiveRecord::Base;end
 
@@ -14,20 +16,25 @@ describe ActiveRecord::StoredProcedure do
   end
 
   describe '#execute' do
-    let (:sp_insert) {SpInsert.new(:p_name => "foo",:p_deci => 2.0, :p_date => Date.today, :in_out_add => 4)}
+    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
@@ -35,4 +42,36 @@ describe ActiveRecord::StoredProcedure do
       end
     end
   end
+
+  context "class methods" do
+    context "#execute" do
+      it "should work" do
+        expect {
+          SpInsert.execute(:p_name => "foo",:p_deci => 2.0, :p_date => Date.today, :in_out_add => 4)
+        }.to change(Foo, :count).by(1)
+      end
+
+      context "out parameters" do
+        it "should work" do
+          sp = SpInsert.execute(:p_name => "foo",:p_deci => 2.0, :p_date => Date.today, :in_out_add => 4)
+          expect(sp.o_id).to be_a(Fixnum)
+        end
+      end
+
+      context "inout parameters" do
+        it "should work" do
+          sp = SpInsert.execute(:p_name => "foo",:p_deci => 2.0, :p_date => Date.today, :in_out_add => 4)
+          expect(sp.in_out_add).to eql(5)
+        end
+      end
+    end
+
+    context "#execute!" do
+      context "not valid" do
+        it "should work" do
+          expect { SpInsert.execute! }.to raise_error(ActiveRecord::StoredProcedureNotExecuted)
+        end
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spare
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Joshua Mckinney
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-11 00:00:00.000000000 Z
+date: 2016-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -117,6 +117,7 @@ files:
 - lib/spare/attributes.rb
 - lib/spare/core.rb
 - lib/spare/exceptions.rb
+- lib/spare/execution.rb
 - lib/spare/model_schema.rb
 - lib/spare/mysql_abstract_adapter.rb
 - lib/spare/schema_cache.rb
@@ -149,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: StoredProcedure models for ActiveRecord.