seed_dumpling 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 34ece3f93f37d8317c2a9d7ea58dfcd05eb4c041c5bb39a8a0e835b15eb9d9ec
+  data.tar.gz: 8ebb42ccb0329c74629bc8b3bc536da1430a360a97b9b598ea8b8425c794018f
+SHA512:
+  metadata.gz: b968a70bcb038cd358d14f467cd98961c5dcad03d2452470d45ed9e878c8732dc3334b2cdfdffae4e0ea9057c32522162e75eb8b89eb5d55312ff15338600eee
+  data.tar.gz: 4573204701121d23e60047e80464b6b4674932e32e020184ee6ecba3998dc940fa8cd5ccb97e408f506757268f8f499d49c054c6f4a94f7b185e3574e706e5fb

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Mikael Henriksson
+
+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,127 @@
+Seed Dump
+========
+
+Seed Dump is a Rails 7+ 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.
+
+Installation
+------------
+
+Add it to your Gemfile with:
+```ruby
+gem 'seed_dumpling'
+```
+Or install it by hand:
+```sh
+gem install seed_dumpling
+```
+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 SeedDumpling.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> SeedDumpling.dump(User, file: 'db/seeds.rb')
+```
+
+Append the dump to a file:
+```ruby
+irb(main):003:0> SeedDumpling.dump(User, file: 'db/seeds.rb', append: true)
+```
+
+Exclude `name` and `age` from the dump:
+```ruby
+irb(main):004:0> SeedDumpling.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 SeedDumpling.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. `SeedDumpling.dump(User.limit(5))`).
+
+`conditions`: Dump only specific records. In the console just pass in an ActiveRecord::Relation with the appropriate conditions (e.g. `SeedDumpling.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/lib/seed_dumpling/dump_methods/enumeration.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class SeedDumpling
+  module DumpMethods
+    #
+    # Helpermethods for enumerating active records
+    #
+    module Enumeration
+      def active_record_enumeration(records, options) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        # Ensure records are ordered by primary key if not already ordered
+        unless records.respond_to?(:arel) && records.arel.orders.present?
+          records = 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)
+
+        # Iterate over each batch
+        (1..num_of_batches).each do |batch_number|
+          last_batch = (batch_number == num_of_batches)
+          current_batch_size = last_batch ? last_batch_size : batch_size
+
+          # Fetch and process records for the current batch
+          record_strings = records
+            .offset((batch_number - 1) * batch_size)
+            .limit(current_batch_size)
+            .map { |record| dump_record(record, options) }
+
+          yield record_strings, last_batch
+        end
+      end
+
+      def enumerable_enumeration(records, options)
+        _, batch_size = batch_params_from(records, options)
+        record_strings = []
+
+        records.each_with_index do |record, index|
+          record_strings << dump_record(record, options)
+          last_batch = (index == records.size - 1)
+
+          if record_strings.size == batch_size || last_batch
+            yield record_strings, last_batch
+            record_strings = []
+          end
+        end
+      end
+
+      def batch_params_from(records, options)
+        batch_size = batch_size_from(options)
+        total_count = records.count
+
+        num_of_batches = (total_count.to_f / batch_size).ceil
+        remainder = total_count % batch_size
+        last_batch_size = remainder.zero? ? batch_size : remainder
+
+        [num_of_batches, batch_size, last_batch_size]
+      end
+
+      def batch_size_from(options)
+        options[:batch_size]&.to_i || 1000
+      end
+    end
+  end
+end

data/lib/seed_dumpling/dump_methods.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "action_text"
+require "active_storage"
+
+class SeedDumpling
+  # Provides methods for dumping database records into Ruby code that can be used
+  # as seeds. Handles various data types and supports both create and import formats.
+  module DumpMethods # rubocop:disable Metrics/ModuleLength
+    extend ActiveSupport::Concern
+
+    include Enumeration
+
+    class_methods do
+      def dump(...)
+        new.dump(...)
+      end
+    end
+
+    def dump(records, options = {})
+      return nil if records.none?
+
+      io = prepare_io(options)
+      write_records(records, io, options)
+    ensure
+      io&.close
+    end
+
+    private
+
+    def dump_record(record, options) # rubocop:disable Metrics/AbcSize
+      attributes = filter_attributes(record.attributes, options[:exclude])
+
+      # Make sure we include attachments and rich text in the final output
+      attributes["avatar"] = record.avatar if record.respond_to?(:avatar) && defined?(ActiveStorage::Attached::One)
+
+      attributes["photos"] = record.photos if record.respond_to?(:photos) && defined?(ActiveStorage::Attached::Many)
+
+      attributes["content"] = record.content if record.respond_to?(:content) && record.content.is_a?(ActionText::RichText)
+
+      formatted_attributes = format_attributes(attributes, options[:import])
+      wrap_attributes(formatted_attributes, options[:import])
+    end
+
+    def filter_attributes(attributes, exclude)
+      attributes.select do |key, _|
+        (key.is_a?(String) || key.is_a?(Symbol)) && exclude.exclude?(key.to_sym)
+      end
+    end
+
+    def format_attributes(attributes, import_format)
+      attributes.map do |attribute, value|
+        import_format ? value_to_s(value) : "#{attribute}: #{value_to_s(value)}"
+      end.join(", ")
+    end
+
+    def wrap_attributes(attribute_string, import_format)
+      open_char, close_char = import_format ? ["[", "]"] : ["{", "}"]
+      "#{open_char}#{attribute_string}#{close_char}"
+    end
+
+    def value_to_s(value) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+      formatted_value = case value
+                        when BigDecimal, IPAddr, ->(v) { rgeo_instance?(v) }
+                          value.to_s
+                        when Date, Time, DateTime
+                          value.to_fs(:db)
+                        when Range
+                          range_to_string(value)
+                        when ->(v) { defined?(ActiveStorage::Attached::One) && v.is_a?(ActiveStorage::Attached::One) }
+                          handle_active_storage_one(value)
+                        when ->(v) { defined?(ActiveStorage::Attached::Many) && v.is_a?(ActiveStorage::Attached::Many) }
+                          handle_active_storage_many(value)
+                        when ->(v) { defined?(ActionText::RichText) && v.is_a?(ActionText::RichText) }
+                          handle_rich_text(value)
+                        else
+                          value
+      end
+      formatted_value.inspect
+    end
+
+    def range_to_string(range)
+      from = infinite_value?(range.begin) ? "" : range.begin
+      to   = infinite_value?(range.end) ? "" : range.end
+      exclude_end = range.exclude_end? ? ")" : "]"
+      "[#{from},#{to}#{exclude_end}"
+    end
+
+    def rgeo_instance?(value)
+      value.class.ancestors.any? { |ancestor| ancestor.to_s == "RGeo::Feature::Instance" }
+    end
+
+    def infinite_value?(value)
+      value.respond_to?(:infinite?) && value.infinite?
+    end
+
+    def prepare_io(options)
+      if options[:file].present?
+        mode = options[:append] ? "a+" : "w+"
+        File.open(options[:file], mode)
+      else
+        StringIO.new
+      end
+    end
+
+    def write_records(records, io, options) # rubocop:disable Metrics/MethodLength
+      options[:exclude] ||= %i[id created_at updated_at]
+
+      method_call = build_method_call(records, options)
+      io.write(method_call)
+      io.write("[\n  ")
+
+      enumeration_method = select_enumeration_method(records)
+      send(enumeration_method, records, options) do |record_strings, last_batch|
+        io.write(record_strings.join(",\n  "))
+        io.write(",\n  ") unless last_batch
+      end
+
+      io.write("\n]#{format_import_options(options)})\n")
+
+      return if options[:file].present?
+
+      io.rewind
+      io.read
+    end
+
+    def build_method_call(records, options)
+      method = options[:import] ? "import" : "create!"
+      model_name = determine_model(records)
+      if options[:import]
+        attributes_list = attribute_names(records, options).map { _1.to_sym.inspect }.join(", ")
+        "#{model_name}.#{method}([#{attributes_list}], "
+      else
+        "#{model_name}.#{method}("
+      end
+    end
+
+    def format_import_options(options)
+      return "" unless options[:import].is_a?(Hash)
+
+      options_string = options[:import].map { |key, value| "#{key}: #{value}" }.join(", ")
+      ", #{options_string}"
+    end
+
+    def attribute_names(records, options)
+      attributes = records.respond_to?(:attribute_names) ? records.attribute_names : records.first.attribute_names
+      attributes.reject { |name| options[:exclude].include?(name.to_sym) }
+    end
+
+    def determine_model(records)
+      if records.is_a?(Class)
+        records
+      elsif records.respond_to?(:model)
+        records.model
+      else
+        records.first.class
+      end
+    end
+
+    def select_enumeration_method(records)
+      if records.is_a?(ActiveRecord::Relation) || records.is_a?(Class)
+        :active_record_enumeration
+      else
+        :enumerable_enumeration
+      end
+    end
+
+    def handle_active_storage_one(attachment)
+      return nil unless attachment.attached?
+
+      copy_attachment_to_seeds_dir(attachment)
+
+      {
+        io: "File.open(Rails.root.join('db/seeds/files', '#{attachment.filename}'))",
+        filename: attachment.filename.to_s,
+        content_type: attachment.blob.content_type,
+      }
+    end
+
+    def handle_active_storage_many(attachments)
+      return [] unless attachments.attached?
+
+      attachments.map do |attachment|
+        copy_attachment_to_seeds_dir(attachment)
+
+        {
+          io: "File.open(Rails.root.join('db/seeds/files', '#{attachment.filename}'))",
+          filename: attachment.filename.to_s,
+          content_type: attachment.blob.content_type,
+        }
+      end
+    end
+
+    def copy_attachment_to_seeds_dir(attachment) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      return unless attachment&.blob
+
+      seeds_dir = Rails.root.join("db/seeds/files")
+      FileUtils.mkdir_p(seeds_dir)
+
+      target_path = seeds_dir.join(attachment.filename.to_s)
+
+      # Skip if file already exists
+      return if File.exist?(target_path)
+
+      begin
+        # Try to get direct file path first
+        source_path = attachment.blob.service.path_for(attachment.blob.key)
+        if source_path && File.exist?(source_path)
+          FileUtils.cp(source_path, target_path)
+        else
+          # Fallback to downloading for cloud storage
+          File.open(target_path, "wb") do |file|
+            attachment.download { |chunk| file.write(chunk) }
+          end
+        end
+      rescue StandardError => e
+        Rails.logger.error "Failed to copy attachment #{attachment.filename}: #{e.message}"
+        raise e
+      end
+    end
+
+    def handle_rich_text(rich_text)
+      rich_text.body&.to_html
+    end
+  end
+end

data/lib/seed_dumpling/environment.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+class SeedDumpling
+  # Provides functionality for dumping database records to seed files using
+  # environment variables to configure the dump process. Supports model filtering,
+  # batch processing, and various output options.
+  module Environment
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def dump_using_environment(...)
+        new.dump_using_environment(...)
+      end
+    end
+
+    def dump_using_environment(env = {}) # rubocop:disable Metrics/MethodLength
+      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?
+
+        SeedDumpling.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"].freeze
+
+    # 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) # rubocop:disable Metrics/AbcSize
+      # 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.
+      models.select do |model|
+        ACTIVE_RECORD_INTERNAL_MODELS.exclude?(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"]&.split(",")&.map { |e| e.strip.to_sym }
+    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]&.to_i
+    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_dumpling/railtie.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class SeedDumpling
+  # Rails integration for SeedDupling
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/seed_dumpling.rake"
+    end
+  end
+end

data/lib/seed_dumpling/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class SeedDumpling
+  VERSION = "1.0.0"
+end

data/lib/seed_dumpling.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require "seed_dumpling/dump_methods/enumeration"
+require "seed_dumpling/dump_methods"
+require "seed_dumpling/environment"
+
+# Tool for extracting database records into a format suitable for
+# Rails' db/seeds.rb. Supports various data types and configurable output formats.
+class SeedDumpling
+  include Environment
+  include DumpMethods
+
+  require "seed_dumpling/railtie" if defined?(Rails)
+end

data/lib/tasks/seed_dumpling.rake

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+namespace :db do
+  namespace :seed do
+    desc "Dump records from the database into db/seeds.rb"
+    task dump: :environment do
+      SeedDumpling.dump_using_environment(ENV)
+    end
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: seed_dumpling
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mikael Henriksson
+bindir: bin
+cert_chain: []
+date: 2025-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord-import
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+description: Dump (parts) of your database to db/seedspec.rb to get a headstart creating
+  a meaningful seedspec.rb file.
+email: mikael@mhenrixon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/seed_dumpling.rb
+- lib/seed_dumpling/dump_methods.rb
+- lib/seed_dumpling/dump_methods/enumeration.rb
+- lib/seed_dumpling/environment.rb
+- lib/seed_dumpling/railtie.rb
+- lib/seed_dumpling/version.rb
+- lib/tasks/seed_dumpling.rake
+homepage: https://github.com/mhenrixon/dumpling
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/mhenrixon/dumpling
+  source_code_uri: https://github.com/mhenrixon/dumpling
+  changelog_uri: https://github.com/mhenrixon/dumpling/blob/up/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Seed Dumper for Rails
+test_files: []