mass_insert 0.0.2 → 0.0.3

data/README.md

@@ -77,15 +77,15 @@ OR directly
 
 Some options that you can include are...
 
-1. `:table_name` : Default value is the table name to your model. This options rarely needs to change but you can do it if you pass a string with the table name. Example...
+`:table_name` : Default value is the table name to your model. This options rarely needs to change but you can do it if you pass a string with the table name. Example...
 
     options = {:table_name => "users"}
 
-2. `:primary_key` : Default value is `:id`. You can change the name of primary key column send it a symbol with the column name.
+`:primary_key` : Default value is `:id`. You can change the name of primary key column send it a symbol with the column name.
 
     options = {:primary_key => :post_id}
 
-3. `:primary_key_mode` : Default value is `:auto`. When is `:auto` MassInsert knows that the database will generate the value of the primary key column automatically. If you pass `:manual` as primary key mode you need to create your value hashes with the key and value of the primary key column.
+`:primary_key_mode` : Default value is `:auto`. When is `:auto` MassInsert knows that the database will generate the value of the primary key column automatically. If you pass `:manual` as primary key mode you need to create your value hashes with the key and value of the primary key column.
 
     options = {:primary_key_mode => :manual}
 

data/lib/mass_insert/adapters.rb

@@ -1,7 +1,6 @@
 module MassInsert
   module Adapters
     autoload :Adapter,            'mass_insert/adapters/adapter.rb'
-    autoload :AbstractQuery,      'mass_insert/adapters/abstract_query.rb'
     autoload :ColumnValue,        'mass_insert/adapters/column_value.rb'
     autoload :Helpers,            'mass_insert/adapters/helpers.rb'
     autoload :Mysql2Adapter,      'mass_insert/adapters/mysql2_adapter.rb'

data/lib/mass_insert/adapters/adapter.rb

@@ -4,7 +4,7 @@ module MassInsert
     # be executed. The methods here provides a functionality that be required
     # in all the adapters.
     class Adapter
-      include AbstractQuery
+      include Helpers::AbstractQuery
       include Helpers::Timestamp
       include Helpers::Sanitizer
 
@@ -27,12 +27,6 @@ module MassInsert
         options[:table_name]
       end
 
-      # Returns an array with the column names in the database table like
-      # a symbols.
-      def table_columns
-        class_name.column_names.map(&:to_sym)
-      end
-
       # Returns the array with the column names valid to be included into the
       # query string according to the options.
       def column_names

data/lib/mass_insert/adapters/column_value.rb

@@ -49,15 +49,17 @@ module MassInsert
 
       # Returns a single column string value with the correct format and
       # according to the database configuration, column type and presence.
+      # If the row hash does not include the value to this column return the
+      # default value according to database configuration.
       def build
-        self.send "column_value_#{column_type}".to_sym
+        column_value.nil? ? default_value : send(:"column_value_#{column_type}")
       end
 
       # Returns the correct value when the column value is string, text,
-      # date, time, datetime, timestamp. There are alias method to the
+      # date, time, datetime, timestamp. There are alias methods to the
       # other column types that need a similar query value.
       def column_value_string
-        column_value.nil? ? default_value : "'#{column_value}'"
+        "'#{column_value}'"
       end
       alias :column_value_text      :column_value_string
       alias :column_value_date      :column_value_string
@@ -66,40 +68,42 @@ module MassInsert
       alias :column_value_timestamp :column_value_string
       alias :column_value_binary    :column_value_string
 
-      # Returns the correct value to column value is integer. If the row
-      # hash does not include the value to this column return the default
-      # value according to database configuration.
+      # Returns the correct value to integer column. The column values is
+      # converted to integer to be sure that the value is correct to be
+      # persisted into the database and after it, it's converted to string.
       def column_value_integer
-        column_value.nil? ? default_value : column_value.to_i.to_s
+        column_value.to_i.to_s
       end
 
-      # Returns the correct value to column value is decimal. There is an
-      # alias method to float type. If the row hash does not include the
-      # value to this column return the default value according to database
-      # configuration.
+      # Returns the correct value to decimal column. There is an alias method
+      # to float type. The column values is converted to decimal to be sure
+      # that the value is correct to be persisted into the database and after
+      # it, it's converted to string.
       def column_value_decimal
-        column_value.nil? ? default_value : column_value.to_f.to_s
+        column_value.to_f.to_s
       end
       alias :column_value_float :column_value_decimal
 
-      # Returns the correct value to column value is boolean. If the row
-      # hash does not include the value to this column return the default
-      # value according to database configuration.
+      # Returns the correct value to boolean column. This column calls the
+      # correct method according to the database adapter to return the correct
+      # value to that database engine.
       def column_value_boolean
-        case adapter
-        when "mysql2", "postgresql", "sqlserver"
-          if column_value.nil?
-            default_value
-          else
-            column_value ? "true" : "false"
-          end
-        when "sqlite3"
-          if column_value.nil?
-            default_value
-          else
-            column_value ? "1" : "0"
-          end
-        end
+        self.send(:"#{adapter}_column_value_boolean")
+      end
+
+      # Returns the column value to boolean column like a string. If the
+      # column value exists returns a true string else false string. There
+      # are alias methods to the database engines that works similarity.
+      def mysql2_column_value_boolean
+        column_value ? "true" : "false"
+      end
+      alias :postgresql_column_value_boolean :mysql2_column_value_boolean
+      alias :sqlserver_column_value_boolean  :mysql2_column_value_boolean
+
+      # Returns the column value to boolean column like a string. If the
+      # column value exists returns a "1" else "0".
+      def sqlite3_column_value_boolean
+        column_value ? "1" : "0"
       end
 
     end

data/lib/mass_insert/adapters/helpers.rb

@@ -1,8 +1,9 @@
 module MassInsert
   module Adapters
     module Helpers
-      autoload :Timestamp,  'mass_insert/adapters/helpers/timestamp.rb'
-      autoload :Sanitizer,  'mass_insert/adapters/helpers/sanitizer.rb'
+      autoload :AbstractQuery, 'mass_insert/adapters/helpers/abstract_query.rb'
+      autoload :Timestamp,     'mass_insert/adapters/helpers/timestamp.rb'
+      autoload :Sanitizer,     'mass_insert/adapters/helpers/sanitizer.rb'
     end
   end
 end

data/lib/mass_insert/adapters/helpers/abstract_query.rb

@@ -0,0 +1,48 @@
+module MassInsert
+  module Adapters
+    module Helpers
+      module AbstractQuery
+
+        # Returns a begin string to a basic mysql query insertion. Include
+        # the class table_name and it's included in the string.
+        def begin_string
+          "INSERT INTO #{table_name} "
+        end
+
+        # Returns a string  with the column names to the class table name
+        # and divided by commas.
+        def string_columns
+          "(#{column_names.join(", ")}) "
+        end
+
+        # Returns the string with all the row values that will be included
+        # in the sql string.
+        def string_values
+          "VALUES (#{string_rows_values});"
+        end
+
+        # Gives the correct format to the values string to all rows. This
+        # functions calls a function that will generate a single string row
+        # and at the end all the strings are concatenated.
+        def string_rows_values
+          values.map{ |row| string_single_row_values(row) }.join("), (")
+        end
+
+        # Returns the row column values string to be added in query string
+        # according to the type column and values.
+        # Before that row is prepared with the correct values.
+        def string_single_row_values row
+          row.merge!(timestamp_values) if timestamp?
+          column_names.map{ |col| string_single_value(row, col) }.join(", ")
+        end
+
+        # Returns a single column string value with the correct format and
+        # according to the database configuration, column type and presence.
+        def string_single_value row, column
+          ColumnValue.new(row, column, options).build
+        end
+
+      end
+    end
+  end
+end

data/lib/mass_insert/adapters/helpers/sanitizer.rb

@@ -3,6 +3,12 @@ module MassInsert
     module Helpers
       module Sanitizer
 
+        # Returns an array with the column names in the database table like
+        # a symbols.
+        def table_columns
+          class_name.column_names.map(&:to_sym)
+        end
+
         # Update the array with the columns names according to the options
         # and prepare the columns array with only valid columns.
         def sanitized_columns

data/lib/mass_insert/adapters/mysql2_adapter.rb

@@ -5,7 +5,7 @@ module MassInsert
       # This method is overwrite because the timestamp format to this
       # database engine does not need precision in nanoseconds.
       def timestamp_format
-        @timestamp_format ||= "%Y-%m-%d %H:%M:%S"
+        "%Y-%m-%d %H:%M:%S"
       end
 
       # This functions calls the necessary functions to create a complete

data/lib/mass_insert/base.rb

@@ -1,7 +1,10 @@
 module MassInsert
   module Base
 
-    # This method do a mass database insertion. Example...
+    # = MassInsert
+    #
+    # This method does a mass database insertion just calling it from your
+    # ActiveRecord model. Example...
     #
     #   User.mass_insert(values)
     #
@@ -14,21 +17,52 @@ module MassInsert
     #     {:name   => "user name", :email  => "user email"}
     #   ]
     #
+    # == Options
+    #
+    # And MassInset gem allow you to send it some options as second param
+    # Example...
+    #
+    #   User.mass_insert(values, options)
+    #
+    # === table_name
+    #
+    # Default value is the table name to your model. This options rarely
+    # needs to change but you can do it if you pass a string with the table
+    # name. Example...
+    #
+    #   options = {:table_name => "users"}
+    #
+    # === primary_key
+    #
+    # Default value is :id. You can change the name of primary key column
+    # send it a symbol with the column name.
+    #
+    #   options = {:primary_key => :post_id}
+    #
+    # === primary_key_mode
+    #
+    # Default value is :auto. When is :auto MassInsert knows that database
+    # will generate the value of the primary key column automatically. If
+    # you pass :manual as primary key mode you need to create your value
+    # hashes with the key and value of the primary key column.
+    #
+    #   options = {:primary_key_mode => :manual}
+    #
     # When a class that inherit from ActiveRecord::Base calls this method
     # is going to extend the methods in ClassMethods module. This module
     # contains some methods that provides some necessary functionality.
     #
     # After extends the class with methods in ClassMethods module. The
     # options that were passed by params are sanitized in the method
-    # called mass_insert_options_sanitized to be passed by params to
-    # do ProcessControl instance. The values are passed too.
+    # called mass_insert_options to be passed by params to ProcessControl
+    # class. The record values are passed too.
     def mass_insert values, args = {}
       class_eval do
         extend ClassMethods
       end
 
       options = mass_insert_options(args)
-      @mass_insert_process = MassInsert::ProcessControl.new(values, options)
+      @mass_insert_process = ProcessControl.new(values, options)
       @mass_insert_process.start
     end
 
@@ -43,22 +77,17 @@ module MassInsert
       end
 
       private
-
-        def mass_insert_options args = {}
-          # prepare default options that come in the class that invokes the
-          # mass_insert function.
-          args[:class_name] ||= self
-          args[:table_name] ||= self.table_name
-
-          # prepare attributes options that were configured by the user and
-          # if the options weren't passed, they would be initialized with the
-          # default values.
-          args[:primary_key]      ||= :id
-          args[:primary_key_mode] ||= :auto
-
-          # Returns the arguments but sanitized and ready to be used. This
-          # args will be passed by params to ProcessControl class.
-          args
+        # Sanitizes the MassInset options that were passed by params.
+        # Prepares default options that come in the class that invokes the
+        # mass_insert function and attributes options that were configured
+        # and if the options weren't passed, they would be initialized with
+        # the default values.
+        def mass_insert_options options = {}
+          options[:class_name]        ||= self
+          options[:table_name]        ||= self.table_name
+          options[:primary_key]       ||= :id
+          options[:primary_key_mode]  ||= :auto
+          options
         end
 
     end

data/lib/mass_insert/query_builder.rb

@@ -12,7 +12,7 @@ module MassInsert
     # sql string ready to be executed and returns it to be execute in
     # the QueryExecution class.
     def build
-      adapter_instance_class.execute
+      adapter_class.new(values, options).execute
     end
 
     # Returns a string that contains the adapter type previosly
@@ -25,16 +25,16 @@ module MassInsert
     # instance will be called to generate the sql string. The values
     # and options are passed by params when the correct adapter class
     # is instanced.
-    def adapter_instance_class
+    def adapter_class
       case adapter
       when "mysql2"
-        Adapters::Mysql2Adapter.new(values, options)
+        Adapters::Mysql2Adapter
       when "postgresql"
-        Adapters::PostgreSQLAdapter.new(values, options)
+        Adapters::PostgreSQLAdapter
       when "sqlite3"
-        Adapters::SQLite3Adapter.new(values, options)
+        Adapters::SQLite3Adapter
       when "sqlserver"
-        Adapters::SQLServerAdapter.new(values, options)
+        Adapters::SQLServerAdapter
       end
     end
 

data/lib/mass_insert/version.rb

@@ -1,3 +1,3 @@
 module MassInsert
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/active_record_dummy/Gemfile

@@ -8,7 +8,7 @@ gem 'rails', '3.2.13'
 gem 'sqlite3'
 gem 'mysql2'
 gem 'pg'
-gem 'mass_insert', :git => 'git@github.com:alejandrogutierrez/mass_insert.git', :branch => 'master'
+gem 'mass_insert'
 
 # Gems used only for assets and not required
 # in production environments by default.

data/spec/active_record_dummy/config/database.yml

@@ -12,7 +12,7 @@ mysql2:
   adapter: mysql2
   database: mysql2_test
   user: root
-  password: D3s4rr0ll0
+  password: D3s4rr0ll0$.
   pool: 5
   timeout: 5000
   encoding: utf8

data/spec/mass_insert/adapters/adapter_spec.rb

@@ -3,113 +3,91 @@ require "./lib/mass_insert"
 require "./spec/dummy_models/test"
 
 describe MassInsert::Adapters::Adapter do
-  before :each do
-    @adapter = MassInsert::Adapters::Adapter.new([], {})
-  end
-
-  subject{ @adapter }
+  let!(:subject){ MassInsert::Adapters::Adapter.new([], {}) }
 
   describe "instance methods" do
     describe "#initialize" do
-
-      before :each do
-        @values  = [{:name => "name"}]
-        @options = {:option_one => 10}
-        @adapter = MassInsert::Adapters::Adapter.new(@values, @options)
-      end
+      let(:adapter){MassInsert::Adapters::Adapter.new("values", "options")}
 
       it "should initialize the values" do
-        @adapter.values.should eq(@values)
+        expect(adapter.values).to eq("values")
       end
 
       it "should initialize the options" do
-        @adapter.options.should eq(@options)
+        expect(adapter.options).to eq("options")
       end
     end
 
     describe "#class_name" do
       it "should respond to class name method" do
-        subject.respond_to?(:class_name).should be_true
+        expect(subject).to respond_to(:class_name)
       end
 
       it "should returns the class_name in options" do
         subject.options = {:class_name => Test}
-        subject.class_name.should eq(Test)
+        expect(subject.class_name).to eq(Test)
       end
     end
 
     describe "#table_name" do
       it "should respond to table_name method" do
-        subject.respond_to?(:table_name).should be_true
+        expect(subject).to respond_to(:table_name)
       end
 
       it "should returns the table_name in options" do
         subject.options = {:table_name => "users"}
-        subject.table_name.should eq("users")
+        expect(subject.table_name).to eq("users")
       end
     end
 
-    describe "#table_columns" do
-      it "should respond to table_columns method" do
-        subject.respond_to?(:table_columns).should be_true
-      end
-
-      it "should returns the table_columns in ActiveRecord class" do
-        subject.options = {:class_name => Test}
-        columns = [:id, :name, :email]
-        subject.table_columns.should eq(columns)
+    describe "#column_names" do
+      before :each do
+        subject.options.merge!({
+          :class_name       => Test,
+          :primary_key      => :id,
+          :primary_key_mode => :auto
+        })
       end
-    end
 
-    describe "#column_names" do
       it "should respond to column_names method" do
-        subject.respond_to?(:column_names).should be_true
+        expect(subject).to respond_to(:column_names)
       end
 
       context "when primary_key is auto" do
         it "should return an array without primary key column" do
-          subject.options.merge!({
-            :class_name       => Test,
-            :primary_key      => :id,
-            :primary_key_mode => :auto
-          })
           column_names = [:name, :email]
-          subject.column_names.should eq(column_names)
+          expect(subject.column_names).to eq(column_names)
         end
       end
 
       context "when primary key is manual" do
         it "should return an array with primary key column" do
-          subject.options.merge!({
-            :class_name       => Test,
-            :primary_key      => :id,
-            :primary_key_mode => :manual
-          })
+          subject.options.merge!({:primary_key_mode => :manual})
           column_names = [:id, :name, :email]
-          subject.column_names.should eq(column_names)
+          expect(subject.column_names).to eq(column_names)
         end
       end
     end
 
     describe "#primary_key" do
       it "should respond to primary_key method" do
-        subject.respond_to?(:primary_key).should be_true
+        expect(subject).to respond_to(:primary_key)
       end
 
       it "should returns the primary_key in options" do
         subject.options = {:primary_key => :user_id}
-        subject.primary_key.should eq(:user_id)
+        expect(subject.primary_key).to eq(:user_id)
       end
     end
 
     describe "#primary_key_mode" do
       it "should respond to primary_key_mode method" do
-        subject.respond_to?(:primary_key_mode).should be_true
+        expect(subject).to respond_to(:primary_key_mode)
       end
 
       it "should returns the primary_key_mode in options" do
         subject.options = {:primary_key_mode => :auto}
-        subject.primary_key_mode.should eq(:auto)
+        expect(subject.primary_key_mode).to eq(:auto)
       end
     end