postgres-copy 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ada774ac0dab27f58b81246ede246219546bd6f
-  data.tar.gz: 7a7c83893ebe10c82501611fb72850b2d345946c
+  metadata.gz: 4b5212784e1c11d62f3996812f369a8702bff96b
+  data.tar.gz: 7bedcee0f0de6847cb8b35c0cedcc5b6ba3c801a
 SHA512:
-  metadata.gz: 4ce6dc87b7bd78813b40cc6c566c1d2a760a4d8dee7e4cf0dca707d826b9982010dfe32cc851b9c18f4329d16a16cba614feb3b6f49beb561e0cfdb8cb5a4a70
-  data.tar.gz: 62e04ba3a0368057d4c53ab8b5f0b730e994c26c54454d21cedd996525309667a2844b84ded5dc12a0dac5cd80b415b5605bcc1e8d22b71ab42ecdf7f1ab1ab3
+  metadata.gz: 5a7ce457d28c10521ab7ba677eb71f20d29e640783f77499f40a8a192c532b4520a567deda0bb37155f5d135780cbed1fb13a4445b3eddac1ea8626a004df888
+  data.tar.gz: 1c0c02a36b775e637aff34802e6890dd74e1e191b72a2e8e07f28c58a3ce69b3e78f70c75281b4ae80035cab09a060da8ad6562750b5ef2f8381d520d6bc8ca5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    postgres-copy (0.7.0)
+    postgres-copy (0.8.0)
       activerecord (~> 4.0)
       pg
       rails (~> 4.0)
@@ -45,7 +45,7 @@ GEM
     mail (2.5.4)
       mime-types (~> 1.16)
       treetop (~> 1.4.8)
-    mime-types (1.23)
+    mime-types (1.25)
     minitest (4.7.5)
     multi_json (1.7.9)
     pg (0.16.0)
@@ -91,7 +91,7 @@ GEM
     thread_safe (0.1.2)
       atomic
     tilt (1.4.1)
-    treetop (1.4.14)
+    treetop (1.4.15)
       polyglot
       polyglot (>= 0.3.1)
     tzinfo (0.3.37)

data/README.md

@@ -18,22 +18,34 @@ Run the bundle command
 
     bundle
 
+## IMPORTANT note about recent versions
+
+* Rails 4 users should use the version 0.7 and onward, while if you use Rails 3.2 stick with the 0.6 versions.
+* Since version 0.8 all methods lost the prefix pg_ and they should be included in models thourgh acts_as_copy_target.
+
 ## Usage
 
-The gem will add two aditiontal class methods to ActiveRecord::Base:
+To enable the copy commands in an ActiveRecord model called User you should use:
+```ruby
+class User < ActiveRecord::Base
+  acts_as_copy_target
+end
+```
+
+This will add the aditiontal class methods to your model:
 
-* pg_copy_to 
-* pg_copy_to_string
-* pg_copy_from
+* copy_to 
+* copy_to_string
+* copy_from
 
-### Using pg_copy_to and pg_copy_to_string
+### Using copy_to and copy_to_string
 
 You can go to the rails console and try some cool things first.
 The first and most basic use case, let's copy the enteire content of a database table to a CSV file on the database server disk.
 Assuming we have a users table and a User AR model:
 
 ```ruby
-User.pg_copy_to '/tmp/users.csv'
+User.copy_to '/tmp/users.csv'
 ```
 
 This will execute in the database the command:
@@ -48,24 +60,24 @@ In this case you can pass a block and retrieve the generated lines and then writ
 
 ```ruby
 File.open('/tmp/users.csv', 'w') do |f|
-  User.pg_copy_to do |line|
+  User.copy_to do |line|
     f.write line
   end
 end
 ```
 
-Or, if you have enough memory, you can read all table contents to a string using .pg_copy_to_string
+Or, if you have enough memory, you can read all table contents to a string using .copy_to_string
 
 ```ruby
-puts User.pg_copy_to_string
+puts User.copy_to_string
 ```
 
-Another insteresting feature of pg_copy_to is that it uses the scoped relation, it means that you can use ARel 
+Another insteresting feature of copy_to is that it uses the scoped relation, it means that you can use ARel 
 operations to generate different CSV files according to your needs.
 Assuming we want to generate a file only with the names of users 1, 2 and 3:
 
 ```ruby
-User.select("name").where(:id => [1,2,3]).pg_copy_to "/tmp/users.csv"
+User.select("name").where(:id => [1,2,3]).copy_to "/tmp/users.csv"
 ```
 
 Which will generate the following SQL command:
@@ -77,7 +89,7 @@ COPY (SELECT name FROM "users" WHERE "users"."id" IN (1, 2, 3)) TO '/tmp/users.c
 The COPY command also supports exporting the data in binary format.
 
 ```ruby
-User.select("name").where(:id => [1,2,3]).pg_copy_to "/tmp/users.dat", :format => :binary
+User.select("name").where(:id => [1,2,3]).copy_to "/tmp/users.dat", :format => :binary
 ```
 
 Which will generate the following SQL command:
@@ -89,34 +101,34 @@ COPY (SELECT name FROM "users" WHERE "users"."id" IN (1, 2, 3)) TO '/tmp/users.d
 The copy_to_string method also supports this
 
 ```ruby
-puts User.pg_copy_to_string(:format => :binary)
+puts User.copy_to_string(:format => :binary)
 ```
 
 
 
-### Using pg_copy_from
+### Using copy_from
 
-Now, if you want to copy data from a CSV file into the database, you can use the pg_copy_from method.
+Now, if you want to copy data from a CSV file into the database, you can use the copy_from method.
 It will allow you to copy data from an arbritary IO object or from a file in the database server (when you pass the path as string).
 Let's first copy from a file in the database server, assuming again that we have a users table and
 that we are in the Rails console:
 
 ```ruby
-User.pg_copy_from "/tmp/users.csv"
+User.copy_from "/tmp/users.csv"
 ```
 
 This command will use the headers in the CSV file as fields of the target table, so beware to always have a header in the files you want to import.
 If the column names in the CSV header do not match the field names of the target table, you can pass a map in the options parameter.
 
 ```ruby
-User.pg_copy_from "/tmp/users.csv", :map => {'name' => 'first_name'}
+User.copy_from "/tmp/users.csv", :map => {'name' => 'first_name'}
 ```
 
 In the above example the header name in the CSV file will be mapped to the field called first_name in the users table.
 You can also manipulate and modify the values of the file being imported before they enter into the database using a block:
 
 ```ruby
-User.pg_copy_from "/tmp/users.csv" do |row|
+User.copy_from "/tmp/users.csv" do |row|
   row[0] = "fixed string"
 end
 ```
@@ -128,7 +140,7 @@ For each iteration of the block row receives an array with the same order as the
 To copy a binary formatted data file or IO object you can specify the format as binary
 
 ```ruby
-User.pg_copy_from "/tmp/users.dat", :format => :binary
+User.copy_from "/tmp/users.dat", :format => :binary
 ```
 
 NOTE: Columns must line up with the table unless you specify how they map to table columns.
@@ -136,7 +148,7 @@ NOTE: Columns must line up with the table unless you specify how they map to tab
 To specify how the columns will map to the table you can specify the :columns option
 
 ```ruby
-User.pg_copy_from "/tmp/users.dat", :format => :binary, :columns => [:id, :name]
+User.copy_from "/tmp/users.dat", :format => :binary, :columns => [:id, :name]
 ```
 
 Which will generate the following SQL command:

data/lib/postgres-copy.rb

@@ -1,16 +1,10 @@
 require 'rubygems'
-require 'active_record'
-require 'postgres-copy/active_record'
-require 'rails'
+require 'active_support'
 
-class PostgresCopy < Rails::Railtie
+ActiveSupport.on_load :active_record do
+  require "postgres-copy/acts_as_copy_target"
+end
 
-  initializer 'postgres-copy' do
-    ActiveSupport.on_load :active_record do
-      require "postgres-copy/active_record"
-    end
-    ActiveSupport.on_load :action_controller do
-      require "postgres-copy/csv_responder"
-    end
-  end
+ActiveSupport.on_load :action_controller do
+  require "postgres-copy/csv_responder"
 end

data/lib/postgres-copy/acts_as_copy_target.rb

@@ -0,0 +1,103 @@
+module PostgresCopy
+  module ActsAsCopyTarget
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    module CopyMethods
+      # Copy data to a file passed as a string (the file path) or to lines that are passed to a block
+      def copy_to path = nil, options = {}
+        options = {:delimiter => ",", :format => :csv, :header => true}.merge(options)
+        options_string = if options[:format] == :binary
+                           "BINARY"
+                         else
+                           "DELIMITER '#{options[:delimiter]}' CSV #{options[:header] ? 'HEADER' : ''}"
+                         end
+
+        if path
+          raise "You have to choose between exporting to a file or receiving the lines inside a block" if block_given?
+          connection.execute "COPY (#{self.all.to_sql}) TO #{sanitize(path)} WITH #{options_string}"
+        else
+          connection.execute "COPY (#{self.all.to_sql}) TO STDOUT WITH #{options_string}"
+          while line = connection.raw_connection.get_copy_data do
+            yield(line) if block_given?
+          end
+        end
+        return self
+      end
+
+      # Copy all data to a single string
+      def copy_to_string options = {}
+        data = ''
+        self.copy_to(nil, options){|l| data << l }
+        if options[:format] == :binary
+          data.force_encoding("ASCII-8BIT")
+        end
+        data
+      end
+
+      # Copy data from a CSV that can be passed as a string (the file path) or as an IO object.
+      # * You can change the default delimiter passing delimiter: '' in the options hash
+      # * You can map fields from the file to different fields in the table using a map in the options hash
+      # * For further details on usage take a look at the README.md
+      def copy_from path_or_io, options = {}
+        options = {:delimiter => ",", :format => :csv, :header => true}.merge(options)
+        options_string = if options[:format] == :binary
+                           "BINARY"
+                         else
+                           "DELIMITER '#{options[:delimiter]}' CSV"
+                         end
+        io = path_or_io.instance_of?(String) ? File.open(path_or_io, 'r') : path_or_io
+
+        if options[:format] == :binary
+          columns_list = options[:columns] || []
+        elsif options[:header]
+          line = io.gets
+          columns_list = options[:columns] || line.strip.split(options[:delimiter])
+        else
+          columns_list = options[:columns]
+        end
+
+        table = if options[:table]
+                  connection.quote_table_name(options[:table])
+                else
+                  quoted_table_name
+                end
+
+        columns_list = columns_list.map{|c| options[:map][c.to_s] } if options[:map]
+        columns_string = columns_list.size > 0 ? "(\"#{columns_list.join('","')}\")" : ""
+        connection.execute %{COPY #{table} #{columns_string} FROM STDIN #{options_string}}
+        if options[:format] == :binary
+          bytes = 0
+          begin
+            while line = io.readpartial(10240)
+              connection.raw_connection.put_copy_data line
+              bytes += line.bytesize
+            end
+          rescue EOFError
+          end
+        else
+          while line = io.gets do
+            next if line.strip.size == 0
+            if block_given?
+              row = line.strip.split(options[:delimiter])
+              yield(row)
+              line = row.join(options[:delimiter]) + "\n"
+            end
+            connection.raw_connection.put_copy_data line
+          end
+        end
+        connection.raw_connection.put_copy_end
+      end
+    end
+
+    module ClassMethods
+      def acts_as_copy_target
+        extend PostgresCopy::ActsAsCopyTarget::CopyMethods
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, PostgresCopy::ActsAsCopyTarget

data/lib/postgres-copy/csv_responder.rb

@@ -2,7 +2,7 @@ module Responders
   module CsvResponder
     def to_csv
       controller.response_body = Enumerator.new do |y|
-        controller.send(:end_of_association_chain).pg_copy_to do |line|
+        controller.send(:end_of_association_chain).copy_to do |line|
           y << line
         end
       end

data/postgres-copy.gemspec

@@ -5,7 +5,7 @@ $:.unshift lib unless $:.include?(lib)
 
 Gem::Specification.new do |s|
   s.name = "postgres-copy"
-  s.version = "0.7.0"
+  s.version = "0.8.0"
 
   s.platform    = Gem::Platform::RUBY
   s.required_ruby_version     = ">= 1.9.3"

data/spec/{pg_copy_from_binary_spec.rb → copy_from_binary_spec.rb}

@@ -9,12 +9,12 @@ describe "COPY FROM BINARY" do
   end
 
   it "should import from file if path is passed without field_map" do
-    TestModel.pg_copy_from File.expand_path('spec/fixtures/2_col_binary_data.dat'), :format => :binary, columns: [:id, :data]
+    TestModel.copy_from File.expand_path('spec/fixtures/2_col_binary_data.dat'), :format => :binary, columns: [:id, :data]
     TestModel.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'text'}]
   end
 
   it "should import from file if columns are not specified" do
-    TestModel.pg_copy_from File.expand_path('spec/fixtures/2_col_binary_data.dat'), :format => :binary
+    TestModel.copy_from File.expand_path('spec/fixtures/2_col_binary_data.dat'), :format => :binary
     TestModel.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'text'}]
   end
 

data/spec/{pg_copy_from_spec.rb → copy_from_spec.rb}

@@ -9,34 +9,34 @@ describe "COPY FROM" do
   end
 
   it "should import from file if path is passed without field_map" do
-    TestModel.pg_copy_from File.expand_path('spec/fixtures/comma_with_header.csv')
+    TestModel.copy_from File.expand_path('spec/fixtures/comma_with_header.csv')
     TestModel.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'test data 1'}]
   end
 
   it "should import from IO without field_map" do
-    TestModel.pg_copy_from File.open(File.expand_path('spec/fixtures/comma_with_header.csv'), 'r')
+    TestModel.copy_from File.open(File.expand_path('spec/fixtures/comma_with_header.csv'), 'r')
     TestModel.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'test data 1'}]
   end
 
   it "should import with custom delimiter from path" do
-    TestModel.pg_copy_from File.expand_path('spec/fixtures/semicolon_with_header.csv'), :delimiter => ';'
+    TestModel.copy_from File.expand_path('spec/fixtures/semicolon_with_header.csv'), :delimiter => ';'
     TestModel.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'test data 1'}]
   end
 
   it "should import with custom delimiter from IO" do
-    TestModel.pg_copy_from File.open(File.expand_path('spec/fixtures/semicolon_with_header.csv'), 'r'), :delimiter => ';'
+    TestModel.copy_from File.open(File.expand_path('spec/fixtures/semicolon_with_header.csv'), 'r'), :delimiter => ';'
     TestModel.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'test data 1'}]
   end
 
   it "should import and allow changes in block" do
-    TestModel.pg_copy_from(File.open(File.expand_path('spec/fixtures/comma_with_header.csv'), 'r')) do |row|
+    TestModel.copy_from(File.open(File.expand_path('spec/fixtures/comma_with_header.csv'), 'r')) do |row|
       row[1] = 'changed this data'
     end
     TestModel.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'changed this data'}]
   end
 
   it "should import 2 lines and allow changes in block" do
-    TestModel.pg_copy_from(File.open(File.expand_path('spec/fixtures/tab_with_two_lines.csv'), 'r'), :delimiter => "\t") do |row|
+    TestModel.copy_from(File.open(File.expand_path('spec/fixtures/tab_with_two_lines.csv'), 'r'), :delimiter => "\t") do |row|
       row[1] = 'changed this data'
     end
     TestModel.order(:id).first.attributes.should == {'id' => 1, 'data' => 'changed this data'}
@@ -44,50 +44,50 @@ describe "COPY FROM" do
   end
 
   it "should be able to copy from using custom set of columns" do
-    TestModel.pg_copy_from(File.open(File.expand_path('spec/fixtures/tab_only_data.csv'), 'r'), :delimiter => "\t", :columns => ["data"])
+    TestModel.copy_from(File.open(File.expand_path('spec/fixtures/tab_only_data.csv'), 'r'), :delimiter => "\t", :columns => ["data"])
     TestModel.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'test data 1'}]
   end
 
   it "default set of columns should be all table columns minus [id, created_at, updated_at]" do
-    ExtraField.pg_copy_from(File.open(File.expand_path('spec/fixtures/comma_with_header.csv'), 'r'))
+    ExtraField.copy_from(File.open(File.expand_path('spec/fixtures/comma_with_header.csv'), 'r'))
     ExtraField.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'test data 1', 'created_at' => nil, 'updated_at' => nil}]
   end
 
   it "should not expect a header when :header is false" do
-    TestModel.pg_copy_from(File.open(File.expand_path('spec/fixtures/comma_without_header.csv'), 'r'), :header => false, :columns => [:id,:data])
+    TestModel.copy_from(File.open(File.expand_path('spec/fixtures/comma_without_header.csv'), 'r'), :header => false, :columns => [:id,:data])
     TestModel.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'test data 1'}]
   end
 
   it "should use the table name given by :table" do
-    ActiveRecord::Base.pg_copy_from(File.open(File.expand_path('spec/fixtures/comma_without_header.csv'), 'r'), :header => false, :columns => [:id,:data], :table => "test_models")
+    ExtraField.copy_from(File.open(File.expand_path('spec/fixtures/comma_without_header.csv'), 'r'), :header => false, :columns => [:id,:data], :table => "test_models")
     TestModel.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'test data 1'}]
   end
 
   it "should be able to map the header in the file to diferent column names" do
-    TestModel.pg_copy_from(File.open(File.expand_path('spec/fixtures/tab_with_different_header.csv'), 'r'), :delimiter => "\t", :map => {'cod' => 'id', 'info' => 'data'})
+    TestModel.copy_from(File.open(File.expand_path('spec/fixtures/tab_with_different_header.csv'), 'r'), :delimiter => "\t", :map => {'cod' => 'id', 'info' => 'data'})
     TestModel.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'test data 1'}]
   end
 
   it "should be able to map the header in the file to diferent column names with custom delimiter" do
-    TestModel.pg_copy_from(File.open(File.expand_path('spec/fixtures/semicolon_with_different_header.csv'), 'r'), :delimiter => ';', :map => {'cod' => 'id', 'info' => 'data'})
+    TestModel.copy_from(File.open(File.expand_path('spec/fixtures/semicolon_with_different_header.csv'), 'r'), :delimiter => ';', :map => {'cod' => 'id', 'info' => 'data'})
     TestModel.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'test data 1'}]
   end
 
   it "should ignore empty lines" do
-    TestModel.pg_copy_from(File.open(File.expand_path('spec/fixtures/tab_with_extra_line.csv'), 'r'), :delimiter => "\t")
+    TestModel.copy_from(File.open(File.expand_path('spec/fixtures/tab_with_extra_line.csv'), 'r'), :delimiter => "\t")
     TestModel.order(:id).map{|r| r.attributes}.should == [{'id' => 1, 'data' => 'test data 1'}]
   end
 
   #we should implement this later
   #it "should raise error in malformed files" do
     #lambda do
-      #TestModel.pg_copy_from(File.open(File.expand_path('spec/fixtures/tab_with_error.csv'), 'r'))
+      #TestModel.copy_from(File.open(File.expand_path('spec/fixtures/tab_with_error.csv'), 'r'))
     #end.should raise_error
     #TestModel.order(:id).map{|r| r.attributes}.should == []
   #end
 
   it "should copy from even when table fields need identifier quoting" do
-    ReservedWordModel.pg_copy_from File.expand_path('spec/fixtures/reserved_words.csv'), :delimiter => "\t"
+    ReservedWordModel.copy_from File.expand_path('spec/fixtures/reserved_words.csv'), :delimiter => "\t"
     ReservedWordModel.order(:id).map{|r| r.attributes}.should == [{"group"=>"group name", "id"=>1, "select"=>"test select"}]
   end
 end

data/spec/{pg_copy_to_binary_spec.rb → copy_to_binary_spec.rb}

@@ -11,18 +11,18 @@ describe "COPY TO BINARY" do
 
   describe "should allow binary output to string" do
     context "with only binary option" do
-      subject{ TestModel.pg_copy_to_string(:format => :binary) }
+      subject{ TestModel.copy_to_string(:format => :binary) }
       it{ should == File.open('spec/fixtures/2_col_binary_data.dat', 'r:ASCII-8BIT').read }
     end
     context "with custom select" do
-      subject{ TestModel.select("id, data").pg_copy_to_string(:format => :binary) }
+      subject{ TestModel.select("id, data").copy_to_string(:format => :binary) }
       it{ should == File.open('spec/fixtures/2_col_binary_data.dat', 'r:ASCII-8BIT').read }
     end
   end
 
   describe "should allow binary output to file" do
     it "should copy to disk if block is not given and a path is passed" do
-      TestModel.pg_copy_to '/tmp/export.dat', :format => :binary
+      TestModel.copy_to '/tmp/export.dat', :format => :binary
       str = File.open('/tmp/export.dat', 'r:ASCII-8BIT').read
 
       str.should == File.open('spec/fixtures/2_col_binary_data.dat', 'r:ASCII-8BIT').read

data/spec/{pg_copy_to_spec.rb → copy_to_spec.rb}

@@ -9,29 +9,29 @@ describe "COPY TO" do
     TestModel.create :data => 'test data 1'
   end
 
-  describe ".pg_copy_to_string" do
+  describe ".copy_to_string" do
     context "with no options" do
-      subject{ TestModel.pg_copy_to_string }
+      subject{ TestModel.copy_to_string }
       it{ should == File.open('spec/fixtures/comma_with_header.csv', 'r').read }
     end
 
     context "with tab as delimiter" do
-      subject{ TestModel.pg_copy_to_string :delimiter => "\t" }
+      subject{ TestModel.copy_to_string :delimiter => "\t" }
       it{ should == File.open('spec/fixtures/tab_with_header.csv', 'r').read }
     end
   end
 
-  describe ".pg_copy_to" do
+  describe ".copy_to" do
     it "should copy and pass data to block if block is given and no path is passed" do
       File.open('spec/fixtures/comma_with_header.csv', 'r') do |f|
-        TestModel.pg_copy_to do |row|
+        TestModel.copy_to do |row|
           row.should == f.readline
         end
       end
     end
 
     it "should copy to disk if block is not given and a path is passed" do
-      TestModel.pg_copy_to '/tmp/export.csv'
+      TestModel.copy_to '/tmp/export.csv'
       File.open('spec/fixtures/comma_with_header.csv', 'r') do |fixture|
         File.open('/tmp/export.csv', 'r') do |result|
           result.read.should == fixture.read
@@ -41,7 +41,7 @@ describe "COPY TO" do
 
     it "should raise exception if I pass a path and a block simultaneously" do
       lambda do
-        TestModel.pg_copy_to('/tmp/bogus_path') do |row|
+        TestModel.copy_to('/tmp/bogus_path') do |row|
         end
       end.should raise_error
     end

data/spec/fixtures/extra_field.rb

@@ -1,5 +1,6 @@
 require 'postgres-copy'
 
 class ExtraField < ActiveRecord::Base
+  acts_as_copy_target
 end
 

data/spec/fixtures/reserved_word_model.rb

@@ -1,5 +1,6 @@
 require 'postgres-copy'
 
 class ReservedWordModel < ActiveRecord::Base
+  acts_as_copy_target
 end
 

data/spec/fixtures/test_model.rb

@@ -1,4 +1,5 @@
 require 'postgres-copy'
 
 class TestModel < ActiveRecord::Base
+  acts_as_copy_target
 end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'active_record'
 require 'fixtures/test_model'
 require 'fixtures/extra_field'
 require 'fixtures/reserved_word_model'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: postgres-copy
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Diogo Biazus
@@ -126,9 +126,13 @@ files:
 - Rakefile
 - VERSION
 - lib/postgres-copy.rb
-- lib/postgres-copy/active_record.rb
+- lib/postgres-copy/acts_as_copy_target.rb
 - lib/postgres-copy/csv_responder.rb
 - postgres-copy.gemspec
+- spec/copy_from_binary_spec.rb
+- spec/copy_from_spec.rb
+- spec/copy_to_binary_spec.rb
+- spec/copy_to_spec.rb
 - spec/fixtures/2_col_binary_data.dat
 - spec/fixtures/comma_with_header.csv
 - spec/fixtures/comma_without_header.csv
@@ -144,10 +148,6 @@ files:
 - spec/fixtures/tab_with_header.csv
 - spec/fixtures/tab_with_two_lines.csv
 - spec/fixtures/test_model.rb
-- spec/pg_copy_from_binary_spec.rb
-- spec/pg_copy_from_spec.rb
-- spec/pg_copy_to_binary_spec.rb
-- spec/pg_copy_to_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 homepage: http://github.com/diogob/postgres-copy
@@ -174,6 +174,10 @@ signing_key:
 specification_version: 4
 summary: Put COPY command functionality in ActiveRecord's model class
 test_files:
+- spec/copy_from_binary_spec.rb
+- spec/copy_from_spec.rb
+- spec/copy_to_binary_spec.rb
+- spec/copy_to_spec.rb
 - spec/fixtures/2_col_binary_data.dat
 - spec/fixtures/comma_with_header.csv
 - spec/fixtures/comma_without_header.csv
@@ -189,9 +193,5 @@ test_files:
 - spec/fixtures/tab_with_header.csv
 - spec/fixtures/tab_with_two_lines.csv
 - spec/fixtures/test_model.rb
-- spec/pg_copy_from_binary_spec.rb
-- spec/pg_copy_from_spec.rb
-- spec/pg_copy_to_binary_spec.rb
-- spec/pg_copy_to_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb

data/lib/postgres-copy/active_record.rb

@@ -1,88 +0,0 @@
-module ActiveRecord
-  class Base
-    # Copy data to a file passed as a string (the file path) or to lines that are passed to a block
-    def self.pg_copy_to path = nil, options = {}
-      options = {:delimiter => ",", :format => :csv, :header => true}.merge(options)
-      options_string = if options[:format] == :binary
-                        "BINARY"
-                       else
-                        "DELIMITER '#{options[:delimiter]}' CSV #{options[:header] ? 'HEADER' : ''}"
-                       end
-
-      if path
-        raise "You have to choose between exporting to a file or receiving the lines inside a block" if block_given?
-        connection.execute "COPY (#{self.all.to_sql}) TO #{sanitize(path)} WITH #{options_string}"
-      else
-        connection.execute "COPY (#{self.all.to_sql}) TO STDOUT WITH #{options_string}"
-        while line = connection.raw_connection.get_copy_data do
-          yield(line) if block_given?
-        end
-      end
-      return self
-    end
-
-    # Copy all data to a single string
-    def self.pg_copy_to_string options = {}
-      data = ''
-      self.pg_copy_to(nil, options){|l| data << l }
-      if options[:format] == :binary
-        data.force_encoding("ASCII-8BIT")
-      end
-      data
-    end
-
-    # Copy data from a CSV that can be passed as a string (the file path) or as an IO object.
-    # * You can change the default delimiter passing delimiter: '' in the options hash
-    # * You can map fields from the file to different fields in the table using a map in the options hash
-    # * For further details on usage take a look at the README.md
-    def self.pg_copy_from path_or_io, options = {}
-      options = {:delimiter => ",", :format => :csv, :header => true}.merge(options)
-      options_string = if options[:format] == :binary
-                        "BINARY"
-                       else
-                        "DELIMITER '#{options[:delimiter]}' CSV"
-                       end
-      io = path_or_io.instance_of?(String) ? File.open(path_or_io, 'r') : path_or_io
-
-      if options[:format] == :binary
-        columns_list = options[:columns] || []
-      elsif options[:header]
-        line = io.gets
-        columns_list = options[:columns] || line.strip.split(options[:delimiter])
-      else
-        columns_list = options[:columns]
-      end
-
-      table = if options[:table]
-        connection.quote_table_name(options[:table])
-      else
-        quoted_table_name
-      end
-
-      columns_list = columns_list.map{|c| options[:map][c.to_s] } if options[:map]
-      columns_string = columns_list.size > 0 ? "(\"#{columns_list.join('","')}\")" : ""
-      connection.execute %{COPY #{table} #{columns_string} FROM STDIN #{options_string}}
-      if options[:format] == :binary
-        bytes = 0
-        begin
-          while line = io.readpartial(10240)
-            connection.raw_connection.put_copy_data line
-            bytes += line.bytesize
-          end
-        rescue EOFError
-        end
-      else
-        while line = io.gets do
-          next if line.strip.size == 0
-          if block_given?
-            row = line.strip.split(options[:delimiter])
-            yield(row)
-            line = row.join(options[:delimiter]) + "\n"
-          end
-          connection.raw_connection.put_copy_data line
-        end
-      end
-      connection.raw_connection.put_copy_end
-    end
-  end
-end