mass_record 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 054417da2bfb6c27e10c6cab4a43749a4e7c5928
-  data.tar.gz: 2cc23822c8fadd28876fa92ddeedd0d55d020611
+  metadata.gz: 5eaa64bad4860bb2f6d3630a437f539b02e94598
+  data.tar.gz: c46e691401efbe81bd591d98eceda9166edc1f27
 SHA512:
-  metadata.gz: 796999b036af5527ac05d769d037f46ec45d22cca212348fe012dd147e736f047792ef2f98858b8d94a565db16e665127e9f77583c969c6e7243af2f9478892d
-  data.tar.gz: 03a884f22b6df45f46fe11cc0a192b115a86a22302015abc434792ab89c64faa7037b17e1962755a2f3cc9a715ace191536340bcee17a2d6955c5b236bde2aff
+  metadata.gz: 33bfc72ba9cc48048035faa29702ea843fe50e3dcece44c5017c683fd92876bd665a2878c81c6f5d666ccf6e369c850fea9f6015e54b00d31703112ebf96460e
+  data.tar.gz: 2c35b274cf2f33e2c5971dadf0d1926679956781a9f192397a48577c1c1cb15ade952f9692f300516d929d85a082c27c95c9953d2feca1c67c133a8819b35bd9

data/lib/mass_record/version.rb

@@ -1,3 +1,3 @@
 module MassRecord
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/mass_record.rb

@@ -9,6 +9,7 @@ module MassRecord
 	self.path[:errored_queries] = "tmp/#{Rails.env}"
 	self.path[:completed_queries] = "tmp/#{Rails.env}"
 
+
 	module Actions
 		path = {}
 		folder_path = "tmp/#{Rails.env}"
@@ -17,6 +18,27 @@ module MassRecord
 		path[:errored_queries] = "#{path[:queries]}/errored"
 		path[:completed_queries] = "#{path[:queries]}/completed"
 
+		class IndividualError < Exception
+			attr_accessor :operation,:table,:json_object,:original_exception,:backtrace,:backtrace_locations,:cause,:exception,:message
+
+			def initialize exception, json_object:nil, operation:nil, table:nil
+				self.backtrace = exception.backtrace
+				self.backtrace_locations = exception.backtrace_locations
+				self.cause = exception.cause
+				self.exception = exception.exception
+				self.message = exception.message
+
+				self.original_exception = exception
+				self.json_object = json_object
+				self.operation = operation
+				self.table = table
+			end
+
+			def to_s
+				original_exception.to_s
+			end
+		end
+
 		# accepts an array of objects with the option to specify what rails operation to perform
 		def queue_for_quick_query object_array, 
 			operation: :save, 
@@ -45,7 +67,9 @@ module MassRecord
 			},synonyms:{
 				insert: [:create, :new, :add, :insert, :post],
 				update: [:update,:edit,:modify,:put,:patch],
-				select: [:read,:select,:get]
+				select: [:read,:select,:get],
+				save:   [:save],
+				delete: [:delete]
 			},folder:{
 				queued:path[:queued_queries],
 				errored:path[:errored_queries],
@@ -82,25 +106,271 @@ module MassRecord
 					errors[:insert] = mass_insert_by_table json_objects.select{|x| synonyms[:insert].include? x[key[:operation]].to_sym.downcase}, key:key
 				elsif synonyms[:update].include? op
 					errors[:update] = mass_update_by_table json_objects.select{|x| synonyms[:update].include? x[key[:operation]].to_sym.downcase}, key:key
-				elsif op == :save	# needs to intelligently determine if the order already exists, insert if not, update if so
+				elsif synonyms[:save].include? op	# needs to intelligently determine if the order already exists, insert if not, update if so
 					errors[:save] = mass_save_by_table json_objects.select{|x| :save == x[key[:operation]].to_sym.downcase}, key:key
-				elsif op == :delete
+				elsif synonyms[:delete].include? op
 				elsif synonyms[:select].include? op
 				else
 				end
 			end
 
 			# close database connection
-			database_connection.close
 
 			# move to appropriate folder and remove '.processing' from the filename
+			errors_present = errors.any?{|op,tables| tables.has_key? :run_time or tables.any?{|table,col_sets| !table.blank?}}
+			errored_objects = collect_errored_objects found_in:errors, from:json_objects, key:key, synonyms:synonyms if errors_present
+
+			individual_errors = errors_present ? (query_per_object errored_objects, key:key, synonyms:synonyms) : []
+			database_connection.close
+			
 			files = Dir.foreach(folder[:queued]).collect{|x| x}.keep_if{|y|y=~/\.json\.processing$/i}
-			errors_present = errors.any?{|op,h| h.any?{|table,a| a.count > 0 }}
 			files.each{|x| File.rename "#{folder[:queued]}/#{x}","#{errors_present ? folder[:errored] : folder[:completed]}/group_#{file_tag}_#{x.gsub /\.processing$/,''}"}
 
+			individual_errors += collect_run_time_errors found_in:errors
+			return individual_errors
+		end
+
+		def collect_run_time_errors found_in:{}, loop_limit:10
+			return [] if found_in.blank?
+			run_time_errors = []
+
+			while found_in.is_a? Hash and loop_limit > 0
+				loop_limit -= 1
+				found_in.each do |k,v|
+					if k == :run_time
+						run_time_errors << v
+					else 
+						run_time_errors += collect_run_time_errors found_in:v, loop_limit:loop_limit
+					end
+				end
+			end
+			return run_time_errors
+		end
+
+		def collect_errored_objects found_in:{}, from:[], key:{}, synonyms:{}
+			return [] if found_in.blank? or from.blank?
+
+			errored_objects = []
+
+			found_in.each do |operation, tables|
+				unless operation == :run_time
+					tables.each do |table, column_sets|
+						unless table == :run_time
+							column_sets.each do |column_set,error|
+								unless column_set == :run_time
+									if error.is_a? Exception and error.is_a? ActiveRecord::StatementInvalid
+										# collect objects by operation, table, and column set
+										operation_terms = synonyms[operation.to_sym]
+										errored_objects += from.select{|x| table.to_s == x[key[:table]].to_s and operation_terms.include? x[key[:operation]].to_sym and x[key[:object]].keys.sort == column_set.sort}
+									end
+								end
+							end
+						end
+					end
+				end
+			end
+
+			return errored_objects
+		end
+
+		def query_per_object objects, key:{}, synonyms:{}
+			# get all operations and tables in use
+			operations = objects.collect{|x| x[key[:operation]].to_sym}.to_set.to_a
+
+			# construct queries
+			errors = []
+			operations.each do |op|
+				if synonyms[:insert].include? op
+					errors += insert_by_table objects.select{|x| synonyms[:insert].include? x[key[:operation]].to_sym.downcase}, key:key
+				elsif synonyms[:update].include? op
+					errors += update_by_table objects.select{|x| synonyms[:update].include? x[key[:operation]].to_sym.downcase}, key:key
+				elsif synonyms[:save].include? op	# needs to intelligently determine if the order already exists, insert if not, update if so
+					errors += save_by_table objects.select{|x| :save == x[key[:operation]].to_sym.downcase}, key:key
+				elsif synonyms[:delete].include? op
+				elsif synonyms[:select].include? op
+				else
+				end
+			end
 			return errors
 		end
 
+		def update_by_table json_objects, key:{}
+			begin
+				tables = json_objects.collect{|x| x[key[:table]]}.to_set.to_a
+
+				errors = []
+				tables.each do |table|
+					hashes = json_objects.select{|o| o[key[:table]] == table}.collect{|x| x[key[:object]]}
+					errors += update hashes, into:table
+				end
+				return errors
+			rescue Exception => e
+				return ((defined? errors) ? (errors << IndividualError.new(e,operation:"update")) : [IndividualError.new(e,operation:"update")])
+			end
+		end
+
+		def sort_save_operations from:nil, for_table:nil, key:{}
+			return {} if from.blank? or for_table.blank?
+			table = for_table
+			hashes = from.select{|o| o[key[:table]] == table}.collect{|x| x[key[:object]]}
+			model = table.classify.constantize
+			pk = model.primary_key
+
+			# organize hashes based on whether they exist (based on their primary key(s)) in the table or not
+			if pk.is_a? Array
+				ids = hashes.reject{|x| pk.any?{|k| x[k].blank?}}.collect{|x| x.select{|k,v| pk.include? k}}	# only accept full sets of pk's
+				where_clauses = []
+				ids.each do |id|
+					equivalence_clauses = []
+					id.each do |k,v|
+						equivalence_clauses << "#{ActiveRecord::Base.connection.quote_column_name k} = #{ActiveRecord::Base.connection.quote(ActiveRecord::Base.connection.type_cast(v, model.column_types[k]))}"
+					end
+					where_clauses << "(#{equivalence_clauses.join ' and '})"
+				end
+				existing_id_sets = ActiveRecord::Base.connection.execute("SELECT #{pk.join ', '} FROM #{table} WHERE #{where_clauses.join ' OR '}").collect{|x| Hash[x.map.with_index{|x,i| [pk[i],x]}]}
+				insert_hashes = hashes.reject{|h| existing_id_sets.any?{|set| h == h.merge(set)}}
+				update_hashes = hashes.select{|h| existing_id_sets.any?{|set| h == h.merge(set)}}
+			else
+				ids = hashes.reject{|x| x[pk].blank?}.collect{|x| x[pk]}	# should not include null values
+				existing_ids = ActiveRecord::Base.connection.execute("SELECT #{pk} FROM #{table} WHERE #{pk} in ('#{ids.join "','"}')").collect{|x| x.first.to_s}
+				insert_hashes = hashes.reject{|x| existing_ids.include? x[pk].to_s}
+				update_hashes = hashes.select{|x| existing_ids.include? x[pk].to_s}
+			end
+
+			return {insert:insert_hashes,update:update_hashes}
+		end
+
+		def save_by_table json_objects, key:{}			
+			begin
+				tables = json_objects.collect{|x| x[key[:table]]}.to_set.to_a
+
+				errors = []
+				tables.each do |table|
+					# sort the hashes by operation type
+					sorted_hashes = sort_save_operations from:json_objects, for_table:table, key:key
+
+					# perform the appropriate operations
+					model = table.classify.constantize
+					errors += update sorted_hashes[:update], into:model unless sorted_hashes[:update].blank?
+					errors += insert sorted_hashes[:insert], into:model unless sorted_hashes[:insert].blank?
+				end	
+				return errors
+			rescue Exception => e
+				return ((defined? errors) ? (errors << IndividualError.new(e,operation:"save")) : [IndividualError.new(e,operation:"save")])
+			end
+		end
+
+		def insert_by_table json_objects, key:{}
+			begin
+				tables = json_objects.collect{|x| x[key[:table]]}.to_set.to_a
+
+				errors = []
+				tables.each do |table|
+					hashes = json_objects.select{|o| o[key[:table]] == table}.collect{|x| x[key[:object]]}
+					errors += insert hashes, into:table
+				end
+				return errors
+			rescue Exception => e
+				return ((defined? errors) ? (errors << IndividualError.new(e,operation:"insert")) : [IndividualError.new(e,operation:"insert")])
+			end
+		end
+
+		def sql_for_insert hash, into:nil
+			return nil if hash.blank? or into.blank?
+			model = into.is_a?(String) ? into.classify.constantize : into
+			id_column_name = model.primary_key
+			created_at = model.attribute_alias?("created_at") ? model.attribute_alias("created_at") : "created_at"
+			updated_at = model.attribute_alias?("updated_at") ? model.attribute_alias("updated_at") : "updated_at"
+			t = model.arel_table
+
+			h = hash.clone	# use a copy of hash, so it doesn't change the original data
+
+			# assemble an individual query
+			im = Arel::InsertManager.new(ActiveRecord::Base)
+			unless id_column_name.is_a? Array 	# don't modify the id fields if there are concatenated primary keys
+				h.delete id_column_name if model.columns.select{|x| x.name == id_column_name}.first.extra == 'auto_increment' or h[id_column_name].blank?
+			end
+			h = convert_to_db_format h, model:model, created_at:created_at, updated_at:updated_at
+			pairs = h.collect do |k,v|
+				[t[k.to_sym],v]
+			end
+			im.insert pairs
+			im.to_sql
+		end
+
+		def sql_for_update hash, into:nil
+			return nil if hash.blank? or into.blank?
+			model = into.is_a?(String) ? into.classify.constantize : into
+			id_column_name = model.primary_key
+			created_at = model.attribute_alias?("created_at") ? model.attribute_alias("created_at") : "created_at"
+			updated_at = model.attribute_alias?("updated_at") ? model.attribute_alias("updated_at") : "updated_at"
+			t = model.arel_table
+
+			h = hash.clone	# use a copy of hash, so it doesn't change the original data
+			h = convert_to_db_format h, model:model, created_at:created_at, updated_at:updated_at
+
+			# assemble an individual query
+			um = Arel::UpdateManager.new(ActiveRecord::Base)
+			um.where(t[id_column_name.to_sym].eq(h[id_column_name])) unless id_column_name.is_a? Array
+			id_column_name.each{|key| um.where t[key.to_sym].eq(h[key])} if id_column_name.is_a? Array
+			um.table(t)
+			id_column_name.each{|name| h.delete name} if id_column_name.is_a? Array 	# don't allow modification of the primary keys
+			h.delete id_column_name if id_column_name.is_a? String						# don't allow modification of the primary keys
+			pairs = h.collect do |k,v|
+				[t[k.to_sym],v]
+			end
+			um.set pairs
+			um.to_sql
+		end
+
+		def update hashes, into:nil
+			begin
+				return false if hashes.blank? or into.blank?
+				hashes = [hashes] unless hashes.is_a? Array
+
+				errors = []
+				# create an array of single insert queries
+				hashes.each do |hash|
+					sql = sql_for_insert hash, into:into
+	
+					begin
+						query sql
+					rescue Exception => e
+						puts e.message
+						errors << IndividualError.new(e,table:into,operation:"update",json_object:hash)
+					end
+				end
+				return errors
+			rescue Exception => e
+				return (defined? errors) ? (errors << IndividualError.new(e, table:into, operation:"update")) : [IndividualError.new( e, table:into, operation:"update")]
+			end
+		end
+
+		def insert hashes, into:nil
+			begin
+				return false if hashes.blank? or into.blank?
+				hashes = [hashes] unless hashes.is_a? Array
+
+				errors = []
+				# create an array of single insert queries
+				hashes.each do |hash|
+					sql = sql_for_insert hash, into:into
+	
+					begin
+						query sql
+					rescue Exception => e
+						puts e.message
+						errors << IndividualError.new(e,table:into,operation:"insert",json_object:hash)
+					end
+				end
+
+				# reparse the queries and execute them
+				return errors
+			rescue Exception => e
+				return (defined? errors) ? (errors << IndividualError.new(e, table:into, operation:"insert")) : [IndividualError.new( e, table:into, operation:"insert")]
+			end
+		end
+
 		def mass_validate objects
 			# TODO: write logic, should return only valid objects
 			return objects
@@ -113,12 +383,14 @@ module MassRecord
 				errors = {}
 				tables.each do |table|
 					hashes = json_objects.select{|o| o[key[:table]] == table}.collect{|x| x[key[:object]]}
-					errors[table.to_sym] = mass_update hashes, into:table
+
+					errors[table.to_sym] = {} unless errors[table.to_sym].is_a? Hash
+					errors[table.to_sym].merge! mass_update hashes, into:table
 				end
 				return errors
 			rescue Exception => e
-				return {method:e} unless defined? errors
-				errors[:method] = e if defined? errors
+				return {run_time:e} unless defined? errors
+				errors[:run_time] = e if defined? errors
 				return errors
 			end
 		end
@@ -129,40 +401,19 @@ module MassRecord
 
 				errors = {}
 				tables.each do |table|
-					hashes = json_objects.select{|o| o[key[:table]] == table}.collect{|x| x[key[:object]]}
-					model = table.classify.constantize
-					pk = model.primary_key
-
-					# organize hashes based on whether they exist (based on their primary key(s)) in the table or not
-					if pk.is_a? Array
-						ids = hashes.reject{|x| pk.any?{|k| x[k].blank?}}.collect{|x| x.select{|k,v| pk.include? k}}	# only accept full sets of pk's
-						where_clauses = []
-						ids.each do |id|
-							equivalence_clauses = []
-							id.each do |k,v|
-								equivalence_clauses << "#{ActiveRecord::Base.connection.quote_column_name k} = #{ActiveRecord::Base.connection.quote(ActiveRecord::Base.connection.type_cast(v, model.column_types[k]))}"
-							end
-							where_clauses << "(#{equivalence_clauses.join ' and '})"
-						end
-						existing_id_sets = ActiveRecord::Base.connection.execute("SELECT #{pk.join ', '} FROM #{table} WHERE #{where_clauses.join ' OR '}").collect{|x| Hash[x.map.with_index{|x,i| [pk[i],x]}]}
-						insert_hashes = hashes.reject{|h| existing_id_sets.any?{|set| h == h.merge(set)}}
-						update_hashes = hashes.select{|h| existing_id_sets.any?{|set| h == h.merge(set)}}
-					else
-						ids = hashes.reject{|x| x[pk].blank?}.collect{|x| x[pk]}	# should not include null values
-						existing_ids = ActiveRecord::Base.connection.execute("SELECT #{pk} FROM #{table} WHERE #{pk} in ('#{ids.join "','"}')").collect{|x| x.first.to_s}
-						insert_hashes = hashes.reject{|x| existing_ids.include? x[pk].to_s}
-						update_hashes = hashes.select{|x| existing_ids.include? x[pk].to_s}
-					end
+					# sort the hashes by operation type
+					sorted_hashes = sort_save_operations from:json_objects, for_table:table, key:key
 
 					# perform the appropriate operations
-					errors[table.to_sym] = []
-					errors[table.to_sym] += mass_update update_hashes, into:model unless update_hashes.blank?
-					errors[table.to_sym] += mass_insert insert_hashes, into:model unless insert_hashes.blank?
-				end	
+					model = table.classify.constantize
+					errors[table.to_sym] = {}
+					errors[table.to_sym].merge! mass_update sorted_hashes[:update], into:model unless sorted_hashes[:update].blank?
+					errors[table.to_sym].merge! mass_insert sorted_hashes[:insert], into:model unless sorted_hashes[:insert].blank?
+				end
 				return errors
 			rescue Exception => e
-				return {method:e} unless defined? errors
-				errors[:method] = e if defined? errors
+				return {run_time:e} unless defined? errors
+				errors[:run_time] = e if defined? errors
 				return errors
 			end
 		end
@@ -175,8 +426,8 @@ module MassRecord
 				id_column_name = model.primary_key
 				created_at = model.attribute_alias?("created_at") ? model.attribute_alias("created_at") : "created_at"
 				updated_at = model.attribute_alias?("updated_at") ? model.attribute_alias("updated_at") : "updated_at"
-				solitary_queries = []
-				t = model.arel_table
+				solitary_queries = []	# I think this can be deleted
+				t = model.arel_table	# I think this can be deleted
 
 				# organize by unique column sets
 				unique_column_sets = {}
@@ -187,9 +438,9 @@ module MassRecord
 					unique_column_sets[column_set] << hash
 				end
 
-				# assemble list of queries (1 for each unique set of columns)
+				# assemble and execute queries (1 for each unique set of columns)
 				queries = []
-
+				errors = {}
 				unique_column_sets.each do |column_set, hash_group|
 					if id_column_name.is_a? Array
 						ids = hash_group.collect{|hash| Hash[id_column_name.map.with_index{|column_name,i| [column_name,hash[column_name]] }]}
@@ -245,25 +496,21 @@ module MassRecord
 						set_columns << "#{column} = CASE #{values.join ' '} END" if id_column_name.is_a? Array
 					end
 
-					queries << "#{update} #{set_columns.join ', '} #{where}"
-				end
-				# [{"id"=>545, "header"=>"new system","details"=>"ya, it worked"},{"id"=>546, "header"=>"sweet system"},{"id"=>547, "header"=>"THAT system","details"=>"ya, it worked"}]
-				errors = []
-				# execute the queries
-				queries.each do |sql|
 					begin
-						query sql
+						query "#{update} #{set_columns.join ', '} #{where}"
 					rescue Exception => e
 						puts e.message
-						errors << e
+						errors[column_set] = e
 					end
-				end	
+				end
+
 				return errors		
 			rescue Exception => e
-				return (defined? errors) ? (errors << e) : [e]
+				return (defined? errors) ? (errors.merge!({run_time:e})) : {run_time:e}
 			end
 		end
 
+
 		def mass_insert_by_table json_objects, key:{}
 			begin		
 				tables = json_objects.collect{|x| x[key[:table]]}.to_set.to_a
@@ -271,12 +518,14 @@ module MassRecord
 				errors = {}
 				tables.each do |table|
 					hashes = json_objects.select{|o| o[key[:table]] == table}.collect{|x| x[key[:object]]}
-					errors[table.to_sym] = mass_insert hashes, into:table
+
+					errors[table.to_sym] = {} unless errors[table.to_sym].is_a? Hash
+					errors[table.to_sym].merge! mass_insert hashes, into:table
 				end
 				return errors
 			rescue Exception => e
-				return {method:e} unless defined? errors
-				errors[:method] = e if defined? errors
+				return {run_time:e} unless defined? errors
+				errors[:run_time] = e if defined? errors
 				return errors
 			end
 		end
@@ -287,47 +536,36 @@ module MassRecord
 
 				# create an array of single insert queries
 				model = into.is_a?(String) ? into.classify.constantize : into
-				id_column_name = model.primary_key
-				created_at = model.attribute_alias?("created_at") ? model.attribute_alias("created_at") : "created_at"
-				updated_at = model.attribute_alias?("updated_at") ? model.attribute_alias("updated_at") : "updated_at"
-				solitary_queries = []
-				t = model.arel_table
-
-				hashes.each do |h|
-					im = Arel::InsertManager.new(ActiveRecord::Base)
-					unless id_column_name.is_a? Array 	# don't modify the id fields if there are concatenated primary keys
-						h.delete id_column_name if model.columns.select{|x| x.name == id_column_name}.first.extra == 'auto_increment' or h[id_column_name].blank?
-					end
-					h = convert_to_db_format h, model:model, created_at:created_at, updated_at:updated_at
-					pairs = h.collect do |k,v|
-						[t[k.to_sym],v]
-					end
-					im.insert pairs
-					solitary_queries << im.to_sql
-				end
-
-				# group the queries by unique column lists
 				concentrated_queries = {}
 
-				solitary_queries.each do |q|
-					k = q.gsub /\s*VALUES.*$/,''
-					concentrated_queries[k] = [] unless concentrated_queries.has_key? k and concentrated_queries[k].is_a? Array
-					concentrated_queries[k] << q.gsub(/^.*VALUES\s*/,'')
+				hashes.each do |hash|
+					original_key_set = hash.keys.sort
+					sql = sql_for_insert hash, into:model
+
+					# group the queries by unique column lists
+					into_clause = sql.gsub /\s*VALUES.*$/,''
+					value_clause = sql.gsub(/^.*VALUES\s*/,'')
+					
+					concentrated_queries[original_key_set] = {} unless concentrated_queries[original_key_set].is_a? Hash
+					concentrated_queries[original_key_set][:into] = into_clause
+					concentrated_queries[original_key_set][:values] = [] unless concentrated_queries[original_key_set][:values].is_a? Array
+					concentrated_queries[original_key_set][:values] << value_clause
 				end
 
-				errors = []
+				errors = {}
+
 				# reparse the queries and execute them
-				concentrated_queries.each do |k,v|
+				concentrated_queries.each do |column_set,clauses|
 					begin
-						query "#{k} VALUES #{v.join(", ")}"				
+						query "#{clauses[:into]} VALUES #{clauses[:values].join(", ")}"				
 					rescue Exception => e
 						puts e.message
-						errors << e
+						errors[column_set] = e
 					end
 				end
 				return errors
 			rescue Exception => e
-				return (defined? errors) ? (errors << e) : [e]
+				return (defined? errors) ? (errors.merge!({run_time:e})) : {run_time:e}
 			end
 		end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mass_record
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Nathan Hanna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-20 00:00:00.000000000 Z
+date: 2014-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -38,7 +38,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Makes inserts, updates, deletes, and validations go faster than ActiveRecord
+description: A Ruby on Rails library to help with mass database operations like insert,
+  update, save, validations, etc (much faster than typical ActiveRecord Interactions
 email:
 - jnathanhdev@gmail.com
 executables: []
@@ -117,7 +118,8 @@ rubyforge_project:
 rubygems_version: 2.4.2
 signing_key: 
 specification_version: 4
-summary: Makes inserts, updates, deletes, and validations go faster than ActiveRecord...
+summary: A Ruby on Rails library to help with mass database operations like insert,
+  update, save, validations, etc (much faster than typical ActiveRecord Interactions...
 test_files:
 - test/dummy/app/assets/javascripts/application.js
 - test/dummy/app/assets/stylesheets/application.css