seed_dump_citus 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 589295ccb53fca1a66f410a15a6fce7c179be89a0ab6ce311967bd6a130b12e0
+  data.tar.gz: 6649359765019a7faf1ee7f1655565841fd011a8b98ad3714f2d23dd4ff2afed
+SHA512:
+  metadata.gz: 3598300d5a6b4f61465ba26708ffc4ce24ac7088a32ff1c329ba3c15f292c80f9f01c80a3545d01b938affe83b826605cf36b40dd3b24a97511c2e0df4f1dda8
+  data.tar.gz: be3d6452a2ea1f69cbda6cd48f51d349d3f155d5787db34f4f7e7c6681abbf34d378372a76a762b45a496e051eaefd2fd26037976d34a8cc575674d626106ebe

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,20 @@
+source 'https://rubygems.org'
+
+gem 'activesupport', '>= 4'
+gem 'activerecord', '>= 4'
+
+group :development, :test do
+  gem 'byebug', '~> 2.0'
+  gem 'factory_bot', '~> 4.8.2'
+  gem 'activerecord-import', '~> 0.4'
+end
+
+group :development do
+  gem 'jeweler', '~> 2.0'
+end
+
+group :test do
+  gem 'rspec', '~> 3.7.0'
+  gem 'sqlite3', '~> 1.0'
+  gem 'database_cleaner', '~> 1.0'
+end

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Ryan Oblak
+
+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,131 @@
+Seed Dump
+========
+
+Seed Dump is a Rails 4 and 5 plugin that adds a rake task named `db:seed:dump`.
+
+It allows you to create seed data files from the existing data in your database.
+
+You can also use Seed Dump from the Rails console. See below for usage examples.
+
+Note: if you want to use Seed Dump with Rails 3 or earlier, use [version 0.5.3](http://rubygems.org/gems/seed_dump/versions/0.5.3).
+
+Installation
+------------
+
+Add it to your Gemfile with:
+```ruby
+gem 'seed_dump_citus'
+```
+Or install it by hand:
+```sh
+$ gem install seed_dump
+```
+Examples
+--------
+
+### Rake task
+
+Dump all data directly to `db/seeds.rb`:
+```sh
+  $ rake db:seed:dump
+```
+Result:
+```ruby
+Product.create!([
+  { category_id: 1, description: "Long Sleeve Shirt", name: "Long Sleeve Shirt" },
+  { category_id: 3, description: "Plain White Tee Shirt", name: "Plain T-Shirt" }
+])
+User.create!([
+  { password: "123456", username: "test_1" },
+  { password: "234567", username: "test_2" }
+])
+```
+
+Dump only data from the users table and dump a maximum of 1 record:
+```sh
+$ rake db:seed:dump MODELS=User LIMIT=1
+```
+
+Result:
+```ruby
+User.create!([
+  { password: "123456", username: "test_1" }
+])
+```
+
+Append to `db/seeds.rb` instead of overwriting it:
+```sh
+rake db:seed:dump APPEND=true
+```
+
+Use another output file instead of `db/seeds.rb`:
+```sh
+rake db:seed:dump FILE=db/seeds/users.rb
+```
+
+Exclude `name` and `age` from the dump:
+```sh
+rake db:seed:dump EXCLUDE=name,age
+```
+
+There are more options that can be set— see below for all of them.
+
+### Console
+
+Output a dump of all User records:
+```ruby
+irb(main):001:0> puts SeedDump.dump(User)
+User.create!([
+  { password: "123456", username: "test_1" },
+  { password: "234567", username: "test_2" }
+])
+```
+
+Write the dump to a file:
+```ruby
+irb(main):002:0> SeedDump.dump(User, file: 'db/seeds.rb')
+```
+
+Append the dump to a file:
+```ruby
+irb(main):003:0> SeedDump.dump(User, file: 'db/seeds.rb', append: true)
+```
+
+Exclude `name` and `age` from the dump:
+```ruby
+irb(main):004:0> SeedDump.dump(User, exclude: [:name, :age])
+```
+
+Options are specified as a Hash for the second argument.
+
+In the console, any relation of ActiveRecord rows can be dumped (not individual objects though)
+```ruby
+irb(main):001:0> puts SeedDump.dump(User.where(is_admin: false))
+User.create!([
+  { password: "123456", username: "test_1", is_admin: false },
+  { password: "234567", username: "test_2", is_admin: false }
+])
+```
+
+Options
+-------
+
+Options are common to both the Rake task and the console, except where noted.
+
+`append`: If set to `true`, append the data to the file instead of overwriting it. Default: `false`.
+
+`batch_size`: Controls the number of records that are written to file at a given time. Default: 1000. If you're running out of memory when dumping, try decreasing this. If things are dumping too slow, trying increasing this.
+
+`exclude`: Attributes to be excluded from the dump. Pass a comma-separated list to the Rake task (i.e. `name,age`) and an array on the console (i.e. `[:name, :age]`). Default: `[:id, :created_at, :updated_at]`.
+
+`file`: Write to the specified output file. The Rake task default is `db/seeds.rb`. The console returns the dump as a string by default.
+
+`import`: If `true`, output will be in the format needed by the [activerecord-import](https://github.com/zdennis/activerecord-import) gem, rather than the default format. Default: `false`.
+
+`limit`: Dump no more than this amount of data. Default: no limit. Rake task only. In the console just pass in an ActiveRecord::Relation with the appropriate limit (e.g. `SeedDump.dump(User.limit(5))`).
+
+`conditions`: Dump only specific records. In the console just pass in an ActiveRecord::Relation with the appropriate conditions (e.g. `SeedDump.dump(User.where(state: :active))`).
+
+`model[s]`: Restrict the dump to the specified comma-separated list of models. Default: all models. If you are using a Rails engine you can dump a specific model by passing "EngineName::ModelName". Rake task only. Example: `rake db:seed:dump MODELS="User, Position, Function"`
+
+`models_exclude`: Exclude the specified comma-separated list of models from the dump. Default: no models excluded. Rake task only. Example: `rake db:seed:dump MODELS_EXCLUDE="User"`

data/Rakefile

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "seed_dump_citus"
+    gem.summary = "{Seed Dumper for Rails}"
+    gem.description = %Q{Dump (parts) of your database to db/seeds.rb to get a headstart creating a meaningful seeds.rb file}
+    gem.email = 'rroblak@gmail.com'
+    gem.homepage = 'https://github.com/rroblak/seed_dump_citus'
+    gem.authors = ['Rob Halff', 'Ryan Oblak']
+    gem.license = 'MIT'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "seed_dump_citus #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+3.3.2

data/lib/seed_dump_citus.rb

@@ -0,0 +1,11 @@
+require 'ipaddr'
+require 'seed_dump_citus/dump_methods/enumeration'
+require 'seed_dump_citus/dump_methods'
+require 'seed_dump_citus/environment'
+
+class SeedDumpCitus
+  extend Environment
+  extend DumpMethods
+
+  require 'seed_dump_citus/railtie' if defined?(Rails)
+end

data/lib/seed_dump_citus/dump_methods.rb

@@ -0,0 +1,129 @@
+class SeedDumpCitus
+  module DumpMethods
+    include Enumeration
+
+    def dump(records, options = {})
+      return nil if records.count == 0
+
+      io = open_io(options)
+
+      write_records_to_io(records, io, options)
+
+      ensure
+        io.close if io.present?
+    end
+
+    private
+
+    def dump_record(record, options)
+      attribute_strings = []
+
+      # We select only string attribute names to avoid conflict
+      # with the composite_primary_keys gem (it returns composite
+      # primary key attribute names as hashes).
+      record.attributes.select {|key| key.is_a?(String) || key.is_a?(Symbol) }.each do |attribute, value|
+        attribute_strings << dump_attribute_new(attribute, value, options) unless options[:exclude].include?(attribute.to_sym)
+      end
+
+      open_character, close_character = options[:import] ? ['[', ']'] : ['{', '}']
+
+      "#{open_character}#{attribute_strings.join(", ")}#{close_character}"
+    end
+
+    def dump_attribute_new(attribute, value, options)
+      options[:import] ? value_to_s(value) : "#{attribute}: #{value_to_s(value)}"
+    end
+
+    def value_to_s(value)
+      value = case value
+              when BigDecimal, IPAddr
+                value.to_s
+              when Date, Time, DateTime
+                value.to_s(:db)
+              when Range
+                range_to_string(value)
+              when ->(v) { v.class.ancestors.map(&:to_s).include?('RGeo::Feature::Instance') }
+                value.to_s
+              else
+                value
+              end
+
+      value.inspect
+    end
+
+    def range_to_string(object)
+      from = object.begin.respond_to?(:infinite?) && object.begin.infinite? ? '' : object.begin
+      to   = object.end.respond_to?(:infinite?) && object.end.infinite? ? '' : object.end
+      "[#{from},#{to}#{object.exclude_end? ? ')' : ']'}"
+    end
+
+    def open_io(options)
+      if options[:file].present?
+        mode = options[:append] ? 'a+' : 'w+'
+
+        File.open(options[:file], mode)
+      else
+        StringIO.new('', 'w+')
+      end
+    end
+
+    def write_records_to_io(records, io, options)
+      options[:exclude] ||= [:id, :created_at, :updated_at]
+
+      method = options[:import] ? 'import' : 'create!'
+      io.write("#{model_for(records)}.#{method}(")
+      if options[:import]
+        io.write("[#{attribute_names(records, options).map {|name| name.to_sym.inspect}.join(', ')}], ")
+      end
+      io.write("[\n  ")
+
+      enumeration_method = if records.is_a?(ActiveRecord::Relation) || records.is_a?(Class)
+                             :active_record_enumeration
+                           else
+                             :enumerable_enumeration
+                           end
+
+      send(enumeration_method, records, io, options) do |record_strings, last_batch|
+        io.write(record_strings.join(",\n  "))
+
+        io.write(",\n  ") unless last_batch
+      end
+
+      io.write("\n]#{active_record_import_options(options)})\n")
+
+      if options[:file].present?
+        nil
+      else
+        io.rewind
+        io.read
+      end
+    end
+
+    def active_record_import_options(options)
+      return unless options[:import] && options[:import].is_a?(Hash)
+
+      ', ' + options[:import].map { |key, value| "#{key}: #{value}" }.join(', ')
+    end
+
+    def attribute_names(records, options)
+      attribute_names = if records.is_a?(ActiveRecord::Relation) || records.is_a?(Class)
+                          records.attribute_names
+                        else
+                          records[0].attribute_names
+                        end
+
+      attribute_names.select {|name| !options[:exclude].include?(name.to_sym)}
+    end
+
+    def model_for(records)
+      if records.is_a?(Class)
+        records
+      elsif records.respond_to?(:model)
+        records.model
+      else
+        records[0].class
+      end
+    end
+
+  end
+end

data/lib/seed_dump_citus/dump_methods/enumeration.rb

@@ -0,0 +1,78 @@
+class SeedDumpCitus
+  module DumpMethods
+    module Enumeration
+      def active_record_enumeration(records, io, options)
+        # If the records don't already have an order,
+        # order them by primary key ascending.
+        if !records.respond_to?(:arel) || records.arel.orders.blank?
+          records.order("#{records.quoted_table_name}.#{records.quoted_primary_key} ASC")
+        end
+
+        num_of_batches, batch_size, last_batch_size = batch_params_from(records, options)
+
+        # Loop through each batch
+        TransactionAccessor.acceptable_non_sharded_read do
+
+          (1..num_of_batches).each do |batch_number|
+
+            record_strings = []
+
+            last_batch = (batch_number == num_of_batches)
+
+            cur_batch_size = if last_batch
+                               last_batch_size
+                             else
+                               batch_size
+                             end
+
+            # Loop through the records of the current batch
+            records.offset((batch_number - 1) * batch_size).limit(cur_batch_size).each do |record|
+              record_strings << dump_record(record, options)
+            end
+
+            yield record_strings, last_batch
+          end
+        end
+      end
+
+      def enumerable_enumeration(records, io, options)
+        num_of_batches, batch_size = batch_params_from(records, options)
+
+        record_strings = []
+
+        batch_number = 1
+
+        records.each_with_index do |record, i|
+          record_strings << dump_record(record, options)
+
+          last_batch = (i == records.length - 1)
+
+          if (record_strings.length == batch_size) || last_batch
+            yield record_strings, last_batch
+
+            record_strings = []
+            batch_number += 1
+          end
+        end
+      end
+
+      def batch_params_from(records, options)
+        batch_size = batch_size_from(records, options)
+
+        count = records.count
+
+        remainder = count % batch_size
+
+        [((count.to_f / batch_size).ceil), batch_size, (remainder == 0 ? batch_size : remainder)]
+      end
+
+      def batch_size_from(records, options)
+        if options[:batch_size].present?
+          options[:batch_size].to_i
+        else
+          1000
+        end
+      end
+    end
+  end
+end