seed_dump_citus 1.0.2

data/lib/seed_dump_citus/environment.rb

@@ -0,0 +1,139 @@
+class SeedDumpCitus
+  module Environment
+
+    def dump_using_environment(env = {})
+      Rails.application.eager_load!
+
+      models = retrieve_models(env) - retrieve_models_exclude(env)
+
+      limit = retrieve_limit_value(env)
+      append = retrieve_append_value(env)
+      models.each do |model|
+        model = model.limit(limit) if limit.present?
+
+        SeedDumpCitus.dump(model,
+                           append: append,
+                           batch_size: retrieve_batch_size_value(env),
+                           exclude: retrieve_exclude_value(env),
+                           file: retrieve_file_value(env),
+                           import: retrieve_import_value(env))
+
+        append = true # Always append for every model after the first
+                      # (append for the first model is determined by
+                      # the APPEND environment variable).
+      end
+    end
+
+    private
+    # Internal: Array of Strings corresponding to Active Record model class names
+    # that should be excluded from the dump.
+    ACTIVE_RECORD_INTERNAL_MODELS = ['ActiveRecord::SchemaMigration',
+                                     'ActiveRecord::InternalMetadata']
+
+    # Internal: Retrieves an Array of Active Record model class constants to be
+    # dumped.
+    #
+    # If a "MODEL" or "MODELS" environment variable is specified, there will be
+    # an attempt to parse the environment variable String by splitting it on
+    # commmas and then converting it to constant.
+    #
+    # Model classes that do not have corresponding database tables or database
+    # records will be filtered out, as will model classes internal to Active
+    # Record.
+    #
+    # env - Hash of environment variables from which to parse Active Record
+    #       model classes. The Hash is not optional but the "MODEL" and "MODELS"
+    #       keys are optional.
+    #
+    # Returns the Array of Active Record model classes to be dumped.
+    def retrieve_models(env)
+      # Parse either the "MODEL" environment variable or the "MODELS"
+      # environment variable, with "MODEL" taking precedence.
+      models_env = env['MODEL'] || env['MODELS']
+
+      # If there was a use models environment variable, split it and
+      # convert the given model string (e.g. "User") to an actual
+      # model constant (e.g. User).
+      #
+      # If a models environment variable was not given, use descendants of
+      # ActiveRecord::Base as the target set of models. This should be all
+      # model classes in the project.
+      models = if models_env
+                 models_env.split(',')
+                           .collect {|x| x.strip.underscore.singularize.camelize.constantize }
+               else
+                 ActiveRecord::Base.descendants
+               end
+
+
+      # Filter the set of models to exclude:
+      #   - The ActiveRecord::SchemaMigration model which is internal to Rails
+      #     and should not be part of the dumped data.
+      #   - Models that don't have a corresponding table in the database.
+      #   - Models whose corresponding database tables are empty.
+      filtered_models = models.select do |model|
+                          !ACTIVE_RECORD_INTERNAL_MODELS.include?(model.to_s) && \
+                          model.table_exists? && \
+                          model.exists?
+                        end
+    end
+
+    # Internal: Returns a Boolean indicating whether the value for the "APPEND"
+    # key in the given Hash is equal to the String "true" (ignoring case),
+    # false if no value exists.
+    def retrieve_append_value(env)
+      parse_boolean_value(env['APPEND'])
+    end
+
+    # Internal: Returns a Boolean indicating whether the value for the "IMPORT"
+    # key in the given Hash is equal to the String "true" (ignoring case),
+    # false if  no value exists.
+    def retrieve_import_value(env)
+      parse_boolean_value(env['IMPORT'])
+    end
+
+    # Internal: Retrieves an Array of Class constants parsed from the value for
+    # the "MODELS_EXCLUDE" key in the given Hash, and an empty Array if such
+    # key exists.
+    def retrieve_models_exclude(env)
+      env['MODELS_EXCLUDE'].to_s
+                           .split(',')
+                           .collect { |x| x.strip.underscore.singularize.camelize.constantize }
+    end
+
+    # Internal: Retrieves an Integer from the value for the "LIMIT" key in the
+    # given Hash, and nil if no such key exists.
+    def retrieve_limit_value(env)
+      retrieve_integer_value('LIMIT', env)
+    end
+
+    # Internal: Retrieves an Array of Symbols from the value for the "EXCLUDE"
+    # key from the given Hash, and nil if no such key exists.
+    def retrieve_exclude_value(env)
+      env['EXCLUDE'] ? env['EXCLUDE'].split(',').map {|e| e.strip.to_sym} : nil
+    end
+
+    # Internal: Retrieves the value for the "FILE" key from the given Hash, and
+    # 'db/seeds.rb' if no such key exists.
+    def retrieve_file_value(env)
+      env['FILE'] || 'db/seeds.rb'
+    end
+
+    # Internal: Retrieves an Integer from the value for the "BATCH_SIZE" key in
+    # the given Hash, and nil if no such key exists.
+    def retrieve_batch_size_value(env)
+      retrieve_integer_value('BATCH_SIZE', env)
+    end
+
+    # Internal: Retrieves an Integer from the value for the given key in
+    # the given Hash, and nil if no such key exists.
+    def retrieve_integer_value(key, hash)
+      hash[key] ? hash[key].to_i : nil
+    end
+
+    # Internal: Parses a Boolean from the given value.
+    def parse_boolean_value(value)
+      value.to_s.downcase == 'true'
+    end
+  end
+end

data/lib/seed_dump_citus/railtie.rb

@@ -0,0 +1,9 @@
+class SeedDumpCitus
+  class Railtie < Rails::Railtie
+
+    rake_tasks do
+      load "tasks/seed_dump_citus.rake"
+    end
+
+  end
+end

data/lib/tasks/seed_dump_citus.rake

@@ -0,0 +1,11 @@
+namespace :db do
+  namespace :seed  do
+    namespace :citus do
+      desc "Dump records from the database into db/seeds.rb"
+      task :dump => :environment do
+
+        SeedDumpCitus.dump_using_environment(ENV)
+      end
+    end
+  end
+end

data/seed_dump_citus.gemspec

@@ -0,0 +1,74 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: seed_dump_citus 3.3.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "seed_dump_citus".freeze
+  s.version = "1.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Rob Halff".freeze, "Ryan Oblak".freeze]
+  s.date = "2018-05-08"
+  s.description = "Dump (parts) of your database to db/seeds.rb to get a headstart creating a meaningful seeds.rb file".freeze
+  s.email = "rroblak@gmail.com".freeze
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".rspec",
+    "Gemfile",
+    "MIT-LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/seed_dump_citus.rb",
+    "lib/seed_dump_citus/dump_methods.rb",
+    "lib/seed_dump_citus/dump_methods/enumeration.rb",
+    "lib/seed_dump_citus/environment.rb",
+    "lib/seed_dump_citus/railtie.rb",
+    "lib/tasks/seed_dump_citus.rake",
+    "seed_dump_citus.gemspec",
+    "spec/dump_methods_spec.rb",
+    "spec/environment_spec.rb",
+    "spec/factories/another_samples.rb",
+    "spec/factories/samples.rb",
+    "spec/factories/yet_another_samples.rb",
+    "spec/helpers.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "https://github.com/rroblak/seed_dump_citus".freeze
+  s.licenses = ["MIT".freeze]
+  s.rubygems_version = "2.7.6".freeze
+  s.summary = "{Seed Dumper for Rails}".freeze
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>.freeze, [">= 4"])
+      s.add_runtime_dependency(%q<activerecord>.freeze, [">= 4"])
+      s.add_development_dependency(%q<byebug>.freeze, ["~> 2.0"])
+      s.add_development_dependency(%q<factory_bot>.freeze, ["~> 4.8.2"])
+      s.add_development_dependency(%q<activerecord-import>.freeze, ["~> 0.4"])
+      s.add_development_dependency(%q<jeweler>.freeze, ["~> 2.0"])
+    else
+      s.add_dependency(%q<activesupport>.freeze, [">= 4"])
+      s.add_dependency(%q<activerecord>.freeze, [">= 4"])
+      s.add_dependency(%q<byebug>.freeze, ["~> 2.0"])
+      s.add_dependency(%q<factory_bot>.freeze, ["~> 4.8.2"])
+      s.add_dependency(%q<activerecord-import>.freeze, ["~> 0.4"])
+      s.add_dependency(%q<jeweler>.freeze, ["~> 2.0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>.freeze, [">= 4"])
+    s.add_dependency(%q<activerecord>.freeze, [">= 4"])
+    s.add_dependency(%q<byebug>.freeze, ["~> 2.0"])
+    s.add_dependency(%q<factory_bot>.freeze, ["~> 4.8.2"])
+    s.add_dependency(%q<activerecord-import>.freeze, ["~> 0.4"])
+    s.add_dependency(%q<jeweler>.freeze, ["~> 2.0"])
+  end
+end
+

data/spec/dump_methods_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+describe SeedDumpCitus do
+
+  def expected_output(include_id = false, id_offset = 0)
+      output = "Sample.create!([\n  "
+
+      data = []
+      ((1 + id_offset)..(3 + id_offset)).each do |i|
+        data << "{#{include_id ? "id: #{i}, " : ''}string: \"string\", text: \"text\", integer: 42, float: 3.14, decimal: \"2.72\", datetime: \"1776-07-04 19:14:00\", time: \"2000-01-01 03:15:00\", date: \"1863-11-19\", binary: \"binary\", boolean: false}"
+      end
+
+      output + data.join(",\n  ") + "\n])\n"
+  end
+
+  describe '.dump' do
+    before do
+      Rails.application.eager_load!
+
+      create_db
+
+      FactoryBot.create_list(:sample, 3)
+    end
+
+    context 'without file option' do
+      it 'should return the dump of the models passed in' do
+        SeedDumpCitus.dump(Sample).should eq(expected_output)
+      end
+    end
+
+    context 'with file option' do
+      before do
+        @filename = Tempfile.new(File.join(Dir.tmpdir, 'foo'), nil)
+      end
+
+      after do
+        File.unlink(@filename)
+      end
+
+      it 'should dump the models to the specified file' do
+        SeedDumpCitus.dump(Sample, file: @filename)
+
+        File.open(@filename) { |file| file.read.should eq(expected_output) }
+      end
+
+      context 'with append option' do
+        it 'should append to the file rather than overwriting it' do
+          SeedDumpCitus.dump(Sample, file: @filename)
+          SeedDumpCitus.dump(Sample, file: @filename, append: true)
+
+          File.open(@filename) { |file| file.read.should eq(expected_output + expected_output) }
+        end
+      end
+    end
+
+    context 'ActiveRecord relation' do
+      it 'should return nil if the count is 0' do
+        SeedDumpCitus.dump(EmptyModel).should be(nil)
+      end
+
+      context 'with an order parameter' do
+        it 'should dump the models in the specified order' do
+          Sample.delete_all
+          samples = 3.times {|i| FactoryBot.create(:sample, integer: i) }
+
+          SeedDumpCitus.dump(Sample.order('integer DESC')).should eq("Sample.create!([\n  {string: \"string\", text: \"text\", integer: 2, float: 3.14, decimal: \"2.72\", datetime: \"1776-07-04 19:14:00\", time: \"2000-01-01 03:15:00\", date: \"1863-11-19\", binary: \"binary\", boolean: false},\n  {string: \"string\", text: \"text\", integer: 1, float: 3.14, decimal: \"2.72\", datetime: \"1776-07-04 19:14:00\", time: \"2000-01-01 03:15:00\", date: \"1863-11-19\", binary: \"binary\", boolean: false},\n  {string: \"string\", text: \"text\", integer: 0, float: 3.14, decimal: \"2.72\", datetime: \"1776-07-04 19:14:00\", time: \"2000-01-01 03:15:00\", date: \"1863-11-19\", binary: \"binary\", boolean: false}\n])\n")
+        end
+      end
+
+      context 'without an order parameter' do
+        it 'should dump the models sorted by primary key ascending' do
+          SeedDumpCitus.dump(Sample).should eq(expected_output)
+        end
+      end
+
+      context 'with a limit parameter' do
+        it 'should dump the number of models specified by the limit when the limit is smaller than the batch size' do
+          expected_output = "Sample.create!([\n  {string: \"string\", text: \"text\", integer: 42, float: 3.14, decimal: \"2.72\", datetime: \"1776-07-04 19:14:00\", time: \"2000-01-01 03:15:00\", date: \"1863-11-19\", binary: \"binary\", boolean: false}\n])\n"
+
+          SeedDumpCitus.dump(Sample.limit(1)).should eq(expected_output)
+        end
+
+        it 'should dump the number of models specified by the limit when the limit is larger than the batch size but not a multiple of the batch size' do
+          Sample.delete_all
+          4.times { FactoryBot.create(:sample) }
+
+          SeedDumpCitus.dump(Sample.limit(3), batch_size: 2).should eq(expected_output(false, 3))
+        end
+      end
+    end
+
+    context 'with a batch_size parameter' do
+      it 'should not raise an exception' do
+        SeedDumpCitus.dump(Sample, batch_size: 100)
+      end
+
+      it 'should not cause records to not be dumped' do
+        SeedDumpCitus.dump(Sample, batch_size: 2).should eq(expected_output)
+
+        SeedDumpCitus.dump(Sample, batch_size: 1).should eq(expected_output)
+      end
+    end
+
+    context 'Array' do
+      it 'should return the dump of the models passed in' do
+        SeedDumpCitus.dump(Sample.all.to_a, batch_size: 2).should eq(expected_output)
+      end
+
+      it 'should return nil if the array is empty' do
+        SeedDumpCitus.dump([]).should be(nil)
+      end
+    end
+
+    context 'with an exclude parameter' do
+      it 'should exclude the specified attributes from the dump' do
+        expected_output = "Sample.create!([\n  {text: \"text\", integer: 42, decimal: \"2.72\", time: \"2000-01-01 03:15:00\", date: \"1863-11-19\", binary: \"binary\", boolean: false},\n  {text: \"text\", integer: 42, decimal: \"2.72\", time: \"2000-01-01 03:15:00\", date: \"1863-11-19\", binary: \"binary\", boolean: false},\n  {text: \"text\", integer: 42, decimal: \"2.72\", time: \"2000-01-01 03:15:00\", date: \"1863-11-19\", binary: \"binary\", boolean: false}\n])\n"
+
+        SeedDumpCitus.dump(Sample, exclude: [:id, :created_at, :updated_at, :string, :float, :datetime]).should eq(expected_output)
+      end
+    end
+
+    context 'Range' do
+      it 'should dump a class with ranges' do
+        expected_output = "RangeSample.create!([\n  {range_with_end_included: \"[1,3]\", range_with_end_excluded: \"[1,3)\", positive_infinite_range: \"[1,]\", negative_infinite_range: \"[,1]\", infinite_range: \"[,]\"}\n])\n"
+
+        SeedDumpCitus.dump([RangeSample.new]).should eq(expected_output)
+      end
+    end
+
+    context 'activerecord-import' do
+      it 'should dump in the activerecord-import format when import is true' do
+        SeedDumpCitus.dump(Sample, import: true, exclude: []).should eq <<-RUBY
+Sample.import([:id, :string, :text, :integer, :float, :decimal, :datetime, :time, :date, :binary, :boolean, :created_at, :updated_at], [
+  [1, "string", "text", 42, 3.14, "2.72", "1776-07-04 19:14:00", "2000-01-01 03:15:00", "1863-11-19", "binary", false, "1969-07-20 20:18:00", "1989-11-10 04:20:00"],
+  [2, "string", "text", 42, 3.14, "2.72", "1776-07-04 19:14:00", "2000-01-01 03:15:00", "1863-11-19", "binary", false, "1969-07-20 20:18:00", "1989-11-10 04:20:00"],
+  [3, "string", "text", 42, 3.14, "2.72", "1776-07-04 19:14:00", "2000-01-01 03:15:00", "1863-11-19", "binary", false, "1969-07-20 20:18:00", "1989-11-10 04:20:00"]
+])
+RUBY
+      end
+
+      it 'should omit excluded columns if they are specified' do
+        SeedDumpCitus.dump(Sample, import: true, exclude: [:id, :created_at, :updated_at]).should eq <<-RUBY
+Sample.import([:string, :text, :integer, :float, :decimal, :datetime, :time, :date, :binary, :boolean], [
+  ["string", "text", 42, 3.14, "2.72", "1776-07-04 19:14:00", "2000-01-01 03:15:00", "1863-11-19", "binary", false],
+  ["string", "text", 42, 3.14, "2.72", "1776-07-04 19:14:00", "2000-01-01 03:15:00", "1863-11-19", "binary", false],
+  ["string", "text", 42, 3.14, "2.72", "1776-07-04 19:14:00", "2000-01-01 03:15:00", "1863-11-19", "binary", false]
+])
+RUBY
+      end
+
+      context 'should add the params to the output if they are specified' do
+        it 'should dump in the activerecord-import format when import is true' do
+          SeedDumpCitus.dump(Sample, import: {validate: false }, exclude: []).should eq <<-RUBY
+Sample.import([:id, :string, :text, :integer, :float, :decimal, :datetime, :time, :date, :binary, :boolean, :created_at, :updated_at], [
+  [1, "string", "text", 42, 3.14, "2.72", "1776-07-04 19:14:00", "2000-01-01 03:15:00", "1863-11-19", "binary", false, "1969-07-20 20:18:00", "1989-11-10 04:20:00"],
+  [2, "string", "text", 42, 3.14, "2.72", "1776-07-04 19:14:00", "2000-01-01 03:15:00", "1863-11-19", "binary", false, "1969-07-20 20:18:00", "1989-11-10 04:20:00"],
+  [3, "string", "text", 42, 3.14, "2.72", "1776-07-04 19:14:00", "2000-01-01 03:15:00", "1863-11-19", "binary", false, "1969-07-20 20:18:00", "1989-11-10 04:20:00"]
+], validate: false)
+          RUBY
+        end
+      end
+    end
+  end
+end
+
+class RangeSample
+  def attributes
+    {
+      "range_with_end_included" => (1..3),
+      "range_with_end_excluded" => (1...3),
+      "positive_infinite_range" => (1..Float::INFINITY),
+      "negative_infinite_range" => (-Float::INFINITY..1),
+      "infinite_range" => (-Float::INFINITY..Float::INFINITY)
+    }
+  end
+end

data/spec/environment_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe SeedDumpCitus do
+  describe '.dump_using_environment' do
+    before(:all) do
+      create_db
+    end
+
+    before(:each) do
+      Rails.application.eager_load!
+
+      FactoryBot.create(:sample)
+    end
+
+    describe 'APPEND' do
+      it "should specify append as true if the APPEND env var is 'true'" do
+        SeedDumpCitus.should_receive(:dump).with(anything, include(append: true))
+
+        SeedDumpCitus.dump_using_environment('APPEND' => 'true')
+      end
+
+      it "should specify append as true if the APPEND env var is 'TRUE'" do
+        SeedDumpCitus.should_receive(:dump).with(anything, include(append: true))
+
+        SeedDumpCitus.dump_using_environment('APPEND' => 'TRUE')
+      end
+
+      it "should specify append as false the first time if the APPEND env var is not 'true' (and true after that)" do
+        FactoryBot.create(:another_sample)
+
+        SeedDumpCitus.should_receive(:dump).with(anything, include(append: false)).ordered
+        SeedDumpCitus.should_receive(:dump).with(anything, include(append: true)).ordered
+
+        SeedDumpCitus.dump_using_environment('APPEND' => 'false')
+      end
+    end
+
+    describe 'BATCH_SIZE' do
+      it 'should pass along the specified batch size' do
+        SeedDumpCitus.should_receive(:dump).with(anything, include(batch_size: 17))
+
+        SeedDumpCitus.dump_using_environment('BATCH_SIZE' => '17')
+      end
+
+      it 'should pass along a nil batch size if BATCH_SIZE is not specified' do
+        SeedDumpCitus.should_receive(:dump).with(anything, include(batch_size: nil))
+
+        SeedDumpCitus.dump_using_environment
+      end
+    end
+
+    describe 'EXCLUDE' do
+      it 'should pass along any attributes to be excluded' do
+        SeedDumpCitus.should_receive(:dump).with(anything, include(exclude: [:baggins, :saggins]))
+
+        SeedDumpCitus.dump_using_environment('EXCLUDE' => 'baggins,saggins')
+      end
+    end
+
+    describe 'FILE' do
+      it 'should pass the FILE parameter to the dump method correctly' do
+        SeedDumpCitus.should_receive(:dump).with(anything, include(file: 'blargle'))
+
+        SeedDumpCitus.dump_using_environment('FILE' => 'blargle')
+      end
+
+      it 'should pass db/seeds.rb as the file parameter if no FILE is specified' do
+        SeedDumpCitus.should_receive(:dump).with(anything, include(file: 'db/seeds.rb'))
+
+        SeedDumpCitus.dump_using_environment
+      end
+    end
+
+    describe 'LIMIT' do
+      it 'should apply the specified limit to the records' do
+        relation_double = double('ActiveRecord relation double')
+        Sample.should_receive(:limit).with(5).and_return(relation_double)
+
+        SeedDumpCitus.should_receive(:dump).with(relation_double, anything)
+        SeedDumpCitus.stub(:dump)
+
+        SeedDumpCitus.dump_using_environment('LIMIT' => '5')
+      end
+    end
+
+    ['', 'S'].each do |model_suffix|
+      model_env = 'MODEL' + model_suffix
+
+      describe model_env do
+        context "if #{model_env} is not specified" do
+          it "should dump all non-empty models" do
+            FactoryBot.create(:another_sample)
+
+            [Sample, AnotherSample].each do |model|
+              SeedDumpCitus.should_receive(:dump).with(model, anything)
+            end
+
+            SeedDumpCitus.dump_using_environment
+          end
+        end
+
+        context "if #{model_env} is specified" do
+          it "should dump only the specified model" do
+            FactoryBot.create(:another_sample)
+
+            SeedDumpCitus.should_receive(:dump).with(Sample, anything)
+
+            SeedDumpCitus.dump_using_environment(model_env => 'Sample')
+          end
+
+          it "should not dump empty models" do
+            SeedDumpCitus.should_not_receive(:dump).with(EmptyModel, anything)
+
+            SeedDumpCitus.dump_using_environment(model_env => 'EmptyModel, Sample')
+          end
+        end
+      end
+    end
+
+    describe "MODELS_EXCLUDE" do
+      it "should dump all non-empty models except the specified models" do
+        FactoryBot.create(:another_sample)
+
+        SeedDumpCitus.should_receive(:dump).with(Sample, anything)
+
+        SeedDumpCitus.dump_using_environment('MODELS_EXCLUDE' => 'AnotherSample')
+      end
+    end
+
+    it 'should run ok without ActiveRecord::SchemaMigration being set (needed for Rails Engines)' do
+      schema_migration = ActiveRecord::SchemaMigration
+
+      ActiveRecord.send(:remove_const, :SchemaMigration)
+
+      SeedDumpCitus.stub(:dump)
+
+      begin
+        SeedDumpCitus.dump_using_environment
+      ensure
+        ActiveRecord.const_set(:SchemaMigration, schema_migration)
+      end
+    end
+   end
+ end