activerecord_dumper 0.9.0

data/spec/activerecord_dumper/rake_tasks_spec.rb

@@ -0,0 +1,96 @@
+module ActiveRecordDumper
+  RSpec.describe RakeTasks do
+    before do
+      @serializer = instance_double(SerializationHelper::Base)
+      allow(SerializationHelper::Base).to receive(:new).and_return(@serializer)
+      allow(Rails).to receive(:root).and_return('/root')
+      allow(Time).to receive(:now).and_return(Time.parse('2007-08-09 12:34:56'))
+      stub_const('UserSpecifiedHelper', Class.new)
+      allow(UserSpecifiedHelper).to receive(:extension).and_return('ext')
+    end
+
+    describe '.data_dump_task' do
+      it 'dumps to a file' do
+        expect(SerializationHelper::Base).to receive(:new).once.with(Helper)
+        expect(@serializer).to receive(:dump).once.with('/root/db/data.yml')
+        RakeTasks.data_dump_task
+      end
+
+      it 'dumps to a file using a user-specified format class' do
+        stub_const('ENV', 'class' => 'UserSpecifiedHelper')
+        expect(SerializationHelper::Base).to receive(:new).once.with(UserSpecifiedHelper)
+        expect(@serializer).to receive(:dump).once.with('/root/db/data.ext')
+        RakeTasks.data_dump_task
+      end
+    end
+
+    describe '.data_dump_dir_task' do
+      it 'dumps to a directory' do
+        expect(SerializationHelper::Base).to receive(:new).once.with(Helper)
+        expect(@serializer).to receive(:dump_to_dir).once.with('/root/db/2007-08-09T123456')
+        RakeTasks.data_dump_dir_task
+      end
+
+      it 'dumps to a directory using a user-specified format class' do
+        stub_const('ENV', 'class' => 'UserSpecifiedHelper')
+        expect(SerializationHelper::Base).to(
+          receive(:new).once.with(UserSpecifiedHelper)
+        )
+        expect(@serializer).to(
+          receive(:dump_to_dir).once.with('/root/db/2007-08-09T123456')
+        )
+        RakeTasks.data_dump_dir_task
+      end
+
+      it 'dumps to a user-specified directory' do
+        stub_const('ENV', 'dir' => 'user_dir')
+        expect(SerializationHelper::Base).to receive(:new).once.with(Helper)
+        expect(@serializer).to(
+          receive(:dump_to_dir).once.with('/root/db/user_dir')
+        )
+        RakeTasks.data_dump_dir_task
+      end
+    end
+
+    describe '.data_load_task' do
+      it 'loads a file' do
+        expect(SerializationHelper::Base).to receive(:new).once.with(Helper)
+        expect(@serializer).to receive(:load).once.with('/root/db/data.yml')
+        RakeTasks.data_load_task
+      end
+
+      it 'loads a file using a user-specified format class' do
+        stub_const('ENV', 'class' => 'UserSpecifiedHelper')
+        expect(SerializationHelper::Base).to(
+          receive(:new).once.with(UserSpecifiedHelper)
+        )
+        expect(@serializer).to receive(:load).once.with('/root/db/data.ext')
+        RakeTasks.data_load_task
+      end
+    end
+
+    describe '.data_load_dir_task' do
+      it 'loads a directory' do
+        expect(SerializationHelper::Base).to receive(:new).once.with(Helper)
+        expect(@serializer).to receive(:load_from_dir).once.with('/root/db/base')
+        RakeTasks.data_load_dir_task
+      end
+
+      it 'loads a directory using a user-specified format class' do
+        stub_const('ENV', 'class' => 'UserSpecifiedHelper')
+        expect(SerializationHelper::Base).to(
+          receive(:new).once.with(UserSpecifiedHelper)
+        )
+        expect(@serializer).to receive(:load_from_dir).once.with('/root/db/base')
+        RakeTasks.data_load_dir_task
+      end
+
+      it 'loads a user-specified directory' do
+        stub_const('ENV', 'dir' => 'user_dir')
+        expect(SerializationHelper::Base).to receive(:new).once.with(Helper)
+        expect(@serializer).to receive(:load_from_dir).once.with('/root/db/user_dir')
+        RakeTasks.data_load_dir_task
+      end
+    end
+  end
+end

data/spec/activerecord_dumper/serialization_helper_base_spec.rb

@@ -0,0 +1,54 @@
+module ActiveRecordDumper
+  module SerializationHelper
+    RSpec.describe Base do
+      def prestub_active_record
+      end
+
+      before do
+        @io = StringIO.new
+        allow(ActiveRecord::Base).to receive(:connection).and_return(double('connection'))
+        allow(ActiveRecord::Base.connection).to receive(:tables).and_return([ 'mytable', 'schema_info', 'schema_migrations' ])
+      end
+
+      def stub_helper!
+        @helper = double("MyHelper")
+        @dumper = double("MyDumper");
+        @loader = double("MyLoader");
+        allow(@helper).to receive(:dumper).and_return(@dumper)
+        allow(@helper).to receive(:loader).and_return(@loader)
+        allow(@helper).to receive(:extension).and_return("yml")
+        allow(@dumper).to receive(:tables).and_return([ActiveRecord::Base.connection.tables[0]])
+        allow(@dumper).to receive(:before_table).and_return(nil)
+        allow(@dumper).to receive(:after_table).and_return(nil)
+      end
+
+      context "for multi-file dumps" do
+        before do
+          expect(File).to receive(:open).once.with("dir_name/mytable.yml", "w").and_yield(@io)
+          expect(Dir).to receive(:mkdir).once.with("dir_name")
+          stub_helper!
+          expect(@dumper).to receive(:dump_table).once.with(@io, "mytable")
+        end
+
+        it "creates the number of files that there are tables" do
+           Base.new(@helper).dump_to_dir "dir_name"
+        end
+
+      end
+
+      context "for multi-file loads" do
+        before do
+          stub_helper!
+          expect(@loader).to receive(:load).once.with(@io, true)
+          expect(File).to receive(:new).once.with("dir_name/mytable.yml", "r").and_return(@io)
+          allow(Dir).to receive(:entries).and_return(["mytable.yml"])
+        end
+
+        it "inserts into the number of tables that there are files" do
+          Base.new(@helper).load_from_dir "dir_name"
+        end
+      end
+
+    end
+  end
+end

data/spec/activerecord_dumper/serialization_helper_dump_spec.rb

@@ -0,0 +1,100 @@
+module ActiveRecordDumper
+  module SerializationHelper
+    RSpec.describe Dump do
+
+      before do
+        allow(ActiveRecord::Base).to receive(:connection).and_return(double('connection').as_null_object)
+        allow(ActiveRecord::Base.connection).to receive(:tables).and_return([ 'mytable', 'schema_info', 'schema_migrations' ])
+        allow(ActiveRecord::Base.connection).to receive(:columns).with('mytable').and_return([ double('a', :name => 'a', :type => :string), double('b', :name => 'b', :type => :string) ])
+        allow(ActiveRecord::Base.connection).to receive(:select_one).and_return({"count"=>"2"})
+        allow(ActiveRecord::Base.connection).to receive(:select_all).and_return([ { 'a' => 1, 'b' => 2 }, { 'a' => 3, 'b' => 4 } ])
+        allow(Utils).to receive(:quote_table).with('mytable').and_return('mytable')
+      end
+
+      before(:each) do
+        allow(File).to receive(:open).with('dump.yml', 'w').and_yield(StringIO.new)
+        @io = StringIO.new
+      end
+
+      it "returns a list of column names" do
+        expect(Dump.table_column_names('mytable')).to eq([ 'a', 'b' ])
+      end
+
+      it "returns the total number of records in a table" do
+        expect(Dump.table_record_count('mytable')).to eq(2)
+      end
+
+      describe ".each_table_page" do
+        before do
+          allow(Dump).to receive(:sort_keys)
+        end
+
+        it "returns all records from the database and returns them when there is only 1 page" do
+          Dump.each_table_page('mytable') do |records|
+            expect(records).to eq([ { 'a' => 1, 'b' => 2 }, { 'a' => 3, 'b' => 4 } ])
+          end
+        end
+
+        it "paginates records from the database and returns them" do
+          allow(ActiveRecord::Base.connection).to receive(:select_all).and_return([ { 'a' => 1, 'b' => 2 } ], [ { 'a' => 3, 'b' => 4 } ])
+
+          records = [ ]
+          Dump.each_table_page('mytable', 1) do |page|
+            expect(page.size).to eq(1)
+            records.concat(page)
+          end
+
+          expect(records).to eq([ { 'a' => 1, 'b' => 2 }, { 'a' => 3, 'b' => 4 } ])
+        end
+      end
+
+      it "dumps a table's contents to yaml" do
+        expect(Dump).to receive(:dump_table_columns)
+        expect(Dump).to receive(:dump_table_records)
+        Dump.dump_table(@io, 'mytable')
+      end
+
+      it "does not dump a table's contents when the record count is zero" do
+        allow(Dump).to receive(:table_record_count).with('mytable').and_return(0)
+        expect(Dump).not_to receive(:dump_table_columns)
+        expect(Dump).not_to receive(:dump_table_records)
+        Dump.dump_table(@io, 'mytable')
+      end
+
+      describe ".tables" do
+        it "returns a list of tables without the rails schema table" do
+          expect(Dump.tables).to eq(['mytable'])
+        end
+
+        it "returns the list of tables in a consistent (sorted) order" do
+          allow(ActiveRecord::Base.connection).to receive(:tables).and_return(%w(z y x))
+          expect(Dump.tables).to eq(%w(x y z))
+        end
+      end
+
+      describe ".sort_keys" do
+        before do
+          allow(Utils).to receive(:quote_column) { |column| column }
+        end
+
+        it "returns the first column as sort key" do
+          expect(Dump.sort_keys('mytable')).to eq(['a'])
+        end
+
+        it "returns the combined ids as sort key if the table looks like a HABTM" do
+          allow(ActiveRecord::Base.connection).to receive(:columns).with('mytable').and_return([
+            double('a_id', :name => 'a_id', :type => :string),
+            double('b_id', :name => 'b_id', :type => :string)
+          ])
+
+          expect(Dump.sort_keys('mytable')).to eq(['a_id', 'b_id'])
+        end
+
+        it "quotes the column name" do
+          allow(Utils).to receive(:quote_column).with('a').and_return('`a`')
+          expect(Dump.sort_keys('mytable')).to eq(['`a`'])
+        end
+      end
+    end
+  end
+end

data/spec/activerecord_dumper/serialization_helper_load_spec.rb

@@ -0,0 +1,73 @@
+module ActiveRecordDumper
+  module SerializationHelper
+    RSpec.describe Load do
+
+      before do
+        allow(Utils).to receive(:quote_table).with('mytable').and_return('mytable')
+
+        allow(ActiveRecord::Base).to receive(:connection).and_return(double('connection').as_null_object)
+        allow(ActiveRecord::Base.connection).to receive(:transaction).and_yield
+        @io = StringIO.new
+      end
+
+      it "truncates the table" do
+        allow(ActiveRecord::Base.connection).to receive(:execute).with("TRUNCATE mytable").and_return(true)
+        expect(ActiveRecord::Base.connection).not_to receive(:execute).with("DELETE FROM mytable")
+        Load.truncate_table('mytable')
+      end
+
+      it "deletes the table if truncate throws an exception" do
+        expect(ActiveRecord::Base.connection).to receive(:execute).with("TRUNCATE mytable").and_raise()
+        expect(ActiveRecord::Base.connection).to receive(:execute).with("DELETE FROM mytable").and_return(true)
+        Load.truncate_table('mytable')
+      end
+
+      it "calls reset pk sequence if the connection adapter is postgres" do
+        expect(ActiveRecord::Base.connection).to receive(:respond_to?).with(:reset_pk_sequence!).and_return(true)
+        expect(ActiveRecord::Base.connection).to receive(:reset_pk_sequence!).with('mytable')
+        Load.reset_pk_sequence!('mytable')
+      end
+
+      it "does not call reset pk sequence for other adapters" do
+        expect(ActiveRecord::Base.connection).to receive(:respond_to?).with(:reset_pk_sequence!).and_return(false)
+        expect(ActiveRecord::Base.connection).not_to receive(:reset_pk_sequence!)
+        Load.reset_pk_sequence!('mytable')
+      end
+
+      it "inserts records into a table" do
+        allow(ActiveRecord::Base.connection).to receive(:quote_column_name).with('a').and_return('a')
+        allow(ActiveRecord::Base.connection).to receive(:quote_column_name).with('b').and_return('b')
+        allow(ActiveRecord::Base.connection).to receive(:quote).with(1).and_return("'1'")
+        allow(ActiveRecord::Base.connection).to receive(:quote).with(2).and_return("'2'")
+        allow(ActiveRecord::Base.connection).to receive(:quote).with(3).and_return("'3'")
+        allow(ActiveRecord::Base.connection).to receive(:quote).with(4).and_return("'4'")
+        expect(ActiveRecord::Base.connection).to receive(:execute).with("INSERT INTO mytable (a,b) VALUES ('1','2')")
+        expect(ActiveRecord::Base.connection).to receive(:execute).with("INSERT INTO mytable (a,b) VALUES ('3','4')")
+
+        Load.load_records('mytable', ['a', 'b'], [[1, 2], [3, 4]])
+      end
+
+      it "quotes column names that correspond to sql keywords" do
+        allow(ActiveRecord::Base.connection).to receive(:quote_column_name).with('a').and_return('a')
+        allow(ActiveRecord::Base.connection).to receive(:quote_column_name).with('count').and_return('"count"')
+        allow(ActiveRecord::Base.connection).to receive(:quote).with(1).and_return("'1'")
+        allow(ActiveRecord::Base.connection).to receive(:quote).with(2).and_return("'2'")
+        allow(ActiveRecord::Base.connection).to receive(:quote).with(3).and_return("'3'")
+        allow(ActiveRecord::Base.connection).to receive(:quote).with(4).and_return("'4'")
+        expect(ActiveRecord::Base.connection).to receive(:execute).with("INSERT INTO mytable (a,\"count\") VALUES ('1','2')")
+        expect(ActiveRecord::Base.connection).to receive(:execute).with("INSERT INTO mytable (a,\"count\") VALUES ('3','4')")
+
+        Load.load_records('mytable', ['a', 'count'], [[1, 2], [3, 4]])
+      end
+
+      it "truncates the table and then loads the records into the table" do
+        expect(Load).to receive(:truncate_table).with('mytable')
+        expect(Load).to receive(:load_records).with('mytable', ['a', 'b'], [[1, 2], [3, 4]])
+        expect(Load).to receive(:reset_pk_sequence!).with('mytable')
+
+        Load.load_table('mytable', { 'columns' => [ 'a', 'b' ], 'records' => [[1, 2], [3, 4]] })
+      end
+
+    end
+  end
+end

data/spec/activerecord_dumper/serialization_helper_utils_spec.rb

@@ -0,0 +1,60 @@
+module ActiveRecordDumper
+  module SerializationHelper
+    RSpec.describe Utils do
+
+      before do
+        allow(ActiveRecord::Base).to receive(:connection).and_return(double('connection').as_null_object)
+      end
+
+      it "returns an array of hash values using an array of ordered keys" do
+        expect(Utils.unhash({ 'a' => 1, 'b' => 2 }, [ 'b', 'a' ])).to eq([ 2, 1 ])
+      end
+
+      it "unhashes each hash to an array using an array of ordered keys" do
+        expect(Utils.unhash_records([ { 'a' => 1, 'b' => 2 }, { 'a' => 3, 'b' => 4 } ], [ 'b', 'a' ])).to eq([ [ 2, 1 ], [ 4, 3 ] ])
+      end
+
+      it "returns true if it is a boolean type" do
+        expect(Utils.is_boolean(true)).to be true
+        expect(Utils.is_boolean('true')).to be false
+      end
+
+      it "returns an array of boolean columns" do
+        allow(ActiveRecord::Base.connection).to receive(:columns).with('mytable').and_return([ double('a',:name => 'a',:type => :string), double('b', :name => 'b',:type => :boolean) ])
+        expect(Utils.boolean_columns('mytable')).to eq(['b'])
+      end
+
+      it "quotes the table name" do
+        expect(ActiveRecord::Base.connection).to receive(:quote_table_name).with('values').and_return('`values`')
+        expect(Utils.quote_table('values')).to eq('`values`')
+      end
+
+      it "converts ruby booleans to true and false" do
+        expect(Utils.convert_boolean(true)).to be true
+        expect(Utils.convert_boolean(false)).to be false
+      end
+
+      it "converts ruby strings t and f to true and false" do
+        expect(Utils.convert_boolean('t')).to be true
+        expect(Utils.convert_boolean('f')).to be false
+      end
+
+      it "converts ruby strings 1 and 0 to true and false" do
+        expect(Utils.convert_boolean('1')).to be true
+        expect(Utils.convert_boolean('0')).to be false
+      end
+
+      it "converts ruby integers 1 and 0 to true and false" do
+        expect(Utils.convert_boolean(1)).to be true
+        expect(Utils.convert_boolean(0)).to be false
+      end
+
+      describe ".quote_column" do
+        it "quotes the column name" do
+          allow(ActiveRecord::Base.connection).to receive(:quote_column_name).with('id').and_return('`id`')
+          expect(Utils.quote_column('id')).to eq('`id`')
+        end
+      end
+    end
+  end
+end

data/spec/activerecord_dumper/utils_spec.rb

@@ -0,0 +1,23 @@
+module ActiveRecordDumper
+  RSpec.describe Utils do
+
+    it "turns an array with one record into a yaml chunk" do
+      expect(Utils.chunk_records([%w[a b]])).to eq(<<EOYAML
+  - - a
+    - b
+EOYAML
+      )
+    end
+
+    it "turns an array with two records into a yaml chunk" do
+      expect(Utils.chunk_records([%w[a b], %w[c d]])).to eq(<<EOYAML
+  - - a
+    - b
+  - - c
+    - d
+EOYAML
+      )
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+require 'simplecov-lcov'
+
+SimpleCov::Formatter::LcovFormatter.config.report_with_single_file = true
+SimpleCov.formatter = SimpleCov::Formatter::LcovFormatter
+SimpleCov.start
+
+require 'logger'
+require 'activerecord_dumper'
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    # expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    # mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  #config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

data/spec/tasks/activerecord_dumper_tasks_spec.rb

@@ -0,0 +1,66 @@
+require 'rake'
+
+RSpec.describe 'Rake tasks' do
+  before do
+    Rake::Application.new.rake_require('tasks/activerecord_dumper_tasks')
+    Rake::Task.define_task(:environment)
+  end
+
+  subject { Rake::Task[self.class.description] }
+
+  describe 'db:dump' do
+    it 'depends on db:schema:dump and db:data:dump' do
+      expect(subject.prerequisites).to eq(['db:schema:dump', 'db:data:dump'])
+    end
+  end
+
+  describe 'db:load' do
+    it 'depends on db:schema:load and db:data:load' do
+      expect(subject.prerequisites).to eq(['db:schema:load', 'db:data:load'])
+    end
+  end
+
+  describe 'db:data:dump' do
+    it 'loads the environment' do
+      expect(subject.prerequisites).to eq(['environment'])
+    end
+
+    it 'invokes the correct task' do
+      expect(ActiveRecordDumper::RakeTasks).to receive(:data_dump_task).once.with(no_args)
+      subject.invoke
+    end
+  end
+
+  describe 'db:data:dump_dir' do
+    it 'loads the environment' do
+      expect(subject.prerequisites).to eq(['environment'])
+    end
+
+    it 'invokes the correct task' do
+      expect(ActiveRecordDumper::RakeTasks).to receive(:data_dump_dir_task).once.with(no_args)
+      subject.invoke
+    end
+  end
+
+  describe 'db:data:load' do
+    it 'loads the environment' do
+      expect(subject.prerequisites).to eq(['environment'])
+    end
+
+    it 'invokes the correct task' do
+      expect(ActiveRecordDumper::RakeTasks).to receive(:data_load_task).once.with(no_args)
+      subject.invoke
+    end
+  end
+
+  describe 'db:data:load_dir' do
+    it 'loads the environment' do
+      expect(subject.prerequisites).to eq(['environment'])
+    end
+
+    it 'invokes the correct task' do
+      expect(ActiveRecordDumper::RakeTasks).to receive(:data_load_dir_task).once.with(no_args)
+      subject.invoke
+    end
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: activerecord_dumper
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Adam Wiggins
+- Orion Henry
+- Serge Tkatchouk
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.22
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.22
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: |
+  ActiveRecordDumper is a fork of YamlDb gem without any explicit Rails dependencies.
+  This way it can be used by any AR-enabled app (e.g. Sinatra) without pulling whole Rails in.
+  YamlDB/ActiveRecordDumper is a database-independent format for dumping and restoring data.
+  It complements the database-independent schema format found in db/schema.rb.
+  The data is saved into db/data.yml. This can be used as a replacement for mysqldump or pg_dump,
+  but it only supports features found in ActiveRecord-based (Rails, etc.) apps.
+  Users, permissions, schemas, triggers, and other advanced database features are not supported by design.
+  Any database that has an ActiveRecord adapter should work.
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/activerecord_dumper.rb
+- lib/activerecord_dumper/csv_db.rb
+- lib/activerecord_dumper/rake_tasks.rb
+- lib/activerecord_dumper/serialization_helper.rb
+- lib/activerecord_dumper/version.rb
+- lib/tasks/activerecord_dumper_tasks.rake
+- spec/activerecord_dumper/dump_spec.rb
+- spec/activerecord_dumper/integration_spec.rb
+- spec/activerecord_dumper/load_spec.rb
+- spec/activerecord_dumper/rake_tasks_spec.rb
+- spec/activerecord_dumper/serialization_helper_base_spec.rb
+- spec/activerecord_dumper/serialization_helper_dump_spec.rb
+- spec/activerecord_dumper/serialization_helper_load_spec.rb
+- spec/activerecord_dumper/serialization_helper_utils_spec.rb
+- spec/activerecord_dumper/utils_spec.rb
+- spec/spec_helper.rb
+- spec/tasks/activerecord_dumper_tasks_spec.rb
+homepage: https://github.com/spijet/activerecord_dumper
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.5
+specification_version: 4
+summary: activerecord_dumper allows you to dump/restore any ActiveRecord database
+  to/from a YAML file.
+test_files: []