edgestitch 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5dc175dee8364f977b9ba83df8cc9945b1931c08020620d390d38d3aaeae8fad
+  data.tar.gz: 3bba36bddf299d60b90195027d3b8454ade141f29b852f9300324761f7d18e66
+SHA512:
+  metadata.gz: ff5f823716dc7ec8ffb0fa9be01ade5386fcf6ac123e539a16a7706d5b4557172eccdd344e71075ca2721a48a7b4c30f955e3cd6f1d9257c80d73ef94781cbd6
+  data.tar.gz: '050108e3c5dd92310aaf907df4b9cb7360422fcef56dfd1bcfb3b706d93b86501a3c415fb0cf669cb1601deb7c5e6d4c281438a11cc236b05f459658245b9f67'

data/.rubocop.yml

@@ -0,0 +1,2 @@
+require:
+  - rubocop-powerhome

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+rails_version = ENV.fetch("RAILS_VERSION", ">= 6.0.6")
+
+gem "rails", rails_version

data/Rakefile

@@ -0,0 +1,17 @@
+#!/usr/bin/env rake
+
+# frozen_string_literal: true
+
+require "bundler/setup"
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+RuboCop::RakeTask.new(:rubocop)
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+task default: %i[rubocop app:db:prepare spec]

data/doc/dependency_decisions.yml

@@ -0,0 +1,3 @@
+---
+- - :inherit_from
+  - https://raw.githubusercontent.com/powerhome/oss-guide/master/license_rules.yml

data/docs/CHANGELOG.md

@@ -0,0 +1,4 @@
+## [0.1.0] - 2022-12-27
+
+- First release of Edgestitch, extracted from NitroMysql.
+- Supports all rails >= 6.0 and all ruby >= 2.7

data/docs/README.md

@@ -0,0 +1,99 @@
+# Edgestitch
+
+Edgestitch allows engines to define partial structure-self.sql files to be stitched into a single structure.sql file by the umbrella application. This allows big teams to develop large [Cobra](https://cbra.info) [Applications](https://github.com/powerhome/cobra_commander) without much conflict happening in a single structure.sql file. Instead, each team will more likely update one component or two structure-self.sql files while other teams concerned with other areas of the application will be changing different files.
+
+## Installation
+
+### Umbrella App
+
+Add this line to your application's Gemfile:
+
+```ruby
+# Gemfile
+
+gem "edgestitch", require: false
+```
+
+And then execute:
+
+    $ bundle install
+
+Then require the railtie in the umbrella's `config/application.rb`:
+
+```ruby
+# config/application.rb
+
+require "edgestitch/railtie"
+```
+
+If your umbrella app also has migrations or even models, you'll have to also install the engine task to your `Rakefile`:
+
+```ruby
+# Rakefile
+
+Edgestitch.define_engine(::My::Application)
+```
+
+### Engines
+
+Each internal engine will also have a development dependency on `edgestitch`, and can install it the same way:
+
+```ruby
+# crazy.gemspec
+
+spec.add_development_dependency "edgestitch"
+```
+
+And then execute:
+
+    $ bundle install
+
+And install the helper tasks:
+
+```ruby
+Edgestitch.define_engine(::Crazy::Engine)
+```
+
+You'll also have to add the `railtie` to the dummy app (as they're dummy umbrella apps), in case the engine has external database dependencies.
+
+```ruby
+# spec/dummy/config/application.rb
+
+require "edgestitch/railtie"
+```
+
+## Usage
+
+Edgestitch will enhance the default rails tasks, so nothing special has to be done in order to use it. Once edgestitch is correctly installed things should Just Work™️ as explained in the rails manual, but it will be generating `structure-self.sql` along with `structure.sql` files. **Important**: It's recommended that `structure.sql` files are added to `.gitignore`.
+
+# How does it work
+
+Edgestitch works based on table and migrations ownership. Based on these ownerships, Edgestitch can export a `structure-self.sql` file defining the DDL owned by a specific engine.
+
+The stitching process then takes all loaded engines (assuming the dependency between engines is defined correctly) and assembles a structure.sql file.
+
+## Table and Migration Ownerships
+
+A model is owned by an engine when it inherits from the Engine's ApplicationModel, and thus the table is owned by that engine. A migration is owned by the engine if it is defined within its `db/migrate` directory.
+
+## Extra tables
+
+When an external dependency brings in extra tables (i.e. acts_as_taggable) that are not defined in any `structure-self.sql`. To be part of the ecosystem, the new tables should be owned by the engine adding them. That can be done by adding these tables to `<engine>/db/extra_tables`. It's a simple text file with a list of table names that do not inherit from `<Engine>::AplicationModel`, but are owned by that engine and should be included in its structure-self.sql.
+
+## External Gems
+
+An external gem can also define a `structure-self.sql` file to be adapted in this ecosystem. That can be done using the same approach specified in Installation / Engines.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/powerhome/power-tools.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/edgestitch.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path("lib", __dir__)
+
+require "edgestitch/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = "edgestitch"
+  spec.version     = Edgestitch::VERSION
+  spec.authors     = ["Carlos Palhares"]
+  spec.email       = ["chjunior@gmail.com"]
+
+  spec.description = spec.summary = "Edgestitch allows engines to define partial structure-self.sql files to be " \
+                                    "stitched into a single structure.sql file by the umbrella application."
+  spec.homepage = "https://github.com/powerhome/power-tools"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7"
+
+  spec.metadata["rubygems_mfa_required"] = "true"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/packages/edgestitch/docs/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.1"
+  spec.add_development_dependency "license_finder", ">= 7.0"
+  spec.add_development_dependency "mysql2", "0.5.3"
+  spec.add_development_dependency "pry-byebug", "3.9.0"
+  spec.add_development_dependency "rails", ">= 5.2.8.1"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec-rails", "~> 5.1.2"
+  spec.add_development_dependency "rubocop-powerhome", "0.5.0"
+  spec.add_development_dependency "simplecov", "0.15.1"
+  spec.add_development_dependency "yard", "0.9.21"
+end

data/lib/edgestitch/exporter.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Edgestitch
+  # @private
+  #
+  # This class is responsible for exporting an engine's owned tables and
+  # migrations to a SQL file.
+  #
+  class Exporter
+    # Exports an engine using a dump helper (@see Edgestitch::Mysql::Dump)
+    #
+    # @param engine [Class<Rails::Engine>] the engine to export
+    # @param dump [<#export_tables,#export_migrations>] the dump helper
+    #
+    def self.export(engine, dump)
+      new(engine).export(dump)
+    end
+
+    attr_reader :engine
+
+    def initialize(engine)
+      @engine = engine
+      @database_directory_path = engine.root.join("db")
+      @extra_tables_path = database_directory_path.join("extra_tables")
+      @structure_file_path = database_directory_path.join("structure-self.sql")
+    end
+
+    def export(dump, to: structure_file_path)
+      StringIO.open do |buffer|
+        buffer.puts dump.export_tables(tables)
+        buffer.puts
+        buffer.puts dump.export_migrations(migrations)
+        File.write to, "#{buffer.string.strip}\n"
+      end
+    end
+
+    def migrations
+      @migrations ||= begin
+        migrations_glob = database_directory_path.join("{migrate,migrate.archive}/*.rb")
+        Dir[migrations_glob]
+          .map { |filename| File.basename(filename).to_i }
+          .sort
+      end
+    end
+
+    def tables
+      component_tables + extra_tables
+    end
+
+  private
+
+    attr_reader :database_directory_path, :extra_tables_path, :structure_file_path
+
+    def extra_tables
+      @extra_tables ||= extra_tables_path.exist? ? extra_tables_path.readlines.map(&:strip) : []
+    end
+
+    def component_tables
+      @component_tables ||= models.each_with_object(Set.new) do |model, tables|
+        tables << model.table_name if model.table_exists?
+      end.sort
+    end
+
+    def models
+      @models ||= application_record&.descendants || []
+    end
+
+    def application_record
+      @application_record ||= engine.railtie_namespace&.const_get(:ApplicationRecord, false)
+    rescue LoadError, NameError
+      nil
+    end
+  end
+end

data/lib/edgestitch/mysql/dump.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "open3"
+
+require_relative "./structure_constraint_order_munger"
+
+module Edgestitch
+  module Mysql
+    # @private
+    #
+    # Wrapper for the mysqldump tool to dump specific tables and migration data
+    #
+    class Dump
+      # Sanitizes a DDL code with some opinionated preferences:
+      # * Constraints starting with `_fk` will start with `fk`
+      # * Clear empty lines (with empty spaces even)
+      # * Reorder constraints (@see Edgestitch::Mysql::StructureConstraintOrderMunger)
+      #
+      # @param sql [String] the DDL code to sanitize
+      # @return String the same DDL sanitized
+      def self.sanitize_sql(sql)
+        comment_instructions_regex = %r{^/\*![0-9]{5}\s+[^;]+;\s*$}
+
+        cleanups = sql.gsub(/\s+AUTO_INCREMENT=\d+/, "")
+                      .gsub(/CONSTRAINT `_+fk_/, "CONSTRAINT `fk_")
+                      .gsub(comment_instructions_regex, "")
+                      .gsub(/\n\s*\n\s*\n/, "\n\n")
+                      .strip
+        ::Edgestitch::Mysql::StructureConstraintOrderMunger.munge(cleanups)
+      end
+
+      #
+      # @param config [ActiveRecord::DatabaseConfigurations::DatabaseConfig] rails database configuration
+      def initialize(config)
+        hash = config.respond_to?(:configuration_hash) ? config.configuration_hash : config.config
+        @database = hash["database"] || hash[:database]
+        @config = {
+          "-h" => hash["host"] || hash[:host],
+          "-u" => hash["username"] || hash[:username],
+          "-p" => hash["password"] || hash[:password],
+          "--port=" => hash["port"] || hash[:port],
+        }
+      end
+
+      # Exports DDL for the given tables in a mysql compatible way
+      #
+      # @param tables [Array<String>] table names
+      # @return String the DDL for the given tables
+      def export_tables(tables)
+        return if tables.empty?
+
+        self.class.sanitize_sql(
+          execute("--compact", "--skip-lock-tables", "--single-transaction", "--no-data",
+                  "--column-statistics=0", *tables)
+        )
+      end
+
+      # Exports INSERT statements for the given migration names.
+      #
+      # The INSERT statements are in groups of 50 migrations per multi-insert statement.
+      #
+      # Notice: this does not export the creation of the schema_migrations table.
+      #
+      # @param migrations [Array<Integer,String>] migration ids/timestamps
+      # @return String the INSERT statements.
+      def export_migrations(migrations)
+        migrations.in_groups_of(50, false).map do |versions|
+          execute(
+            "--compact", "--skip-lock-tables", "--single-transaction",
+            "--no-create-info", "--column-statistics=0",
+            "schema_migrations",
+            "-w", "version IN (#{versions.join(',')})"
+          )
+        end.join.gsub(/VALUES /, "VALUES\n").gsub(/,/, ",\n")
+      end
+
+    private
+
+      def execute(*args)
+        stdout, stderr, status = Open3.capture3("mysqldump", *connection_args, @database, *args)
+        raise stderr unless status.success?
+
+        stdout
+      end
+
+      def connection_args
+        @config.compact.map do |arg, value|
+          "#{arg}#{value}"
+        end
+      end
+    end
+  end
+end

data/lib/edgestitch/mysql/structure_constraint_order_munger.rb

@@ -0,0 +1,59 @@
+# rubocop:disable all
+
+module Edgestitch
+  module Mysql
+    # @private
+    class StructureConstraintOrderMunger
+      class << self
+        def munge(sql)
+          start_idx = end_idx = nil
+          lines = sql.split("\n")
+          lines.each_with_index do |line, idx|
+            if line =~ /^\s*CONSTRAINT\b/
+              start_idx = idx if start_idx.nil?
+            elsif start_idx
+              end_idx = idx - 1
+              unless end_idx == start_idx
+                lines[start_idx..end_idx] = order_and_commafy(lines[start_idx..end_idx])
+              end
+              start_idx = end_idx = nil
+            end
+          end
+          lines.join("\n")
+        end
+
+      private
+
+        def ends_with_comma(s)
+          s.rstrip.end_with?(",")
+        end
+
+        def decommafy(s)
+          return s unless ends_with_comma(s.rstrip)
+          "#{s.rstrip[0..-2]}\n"
+        end
+
+        def commafy(s)
+          return s if ends_with_comma(s.rstrip)
+          "#{s.rstrip},\n"
+        end
+
+        def order_and_commafy(lines)
+          last_line_should_have_comma = ends_with_comma(lines[-1])
+          lines.sort!
+          # First lines.length-1 lines always need commas
+          lines[0..-2].each_with_index do |line, idx|
+            lines[idx] = commafy(line)
+          end
+          # Last line may or may not need comma
+          if last_line_should_have_comma
+            lines[-1] = commafy(lines[-1])
+          else
+            lines[-1] = decommafy(lines[-1])
+          end
+          lines
+        end
+      end
+    end
+  end
+end

data/lib/edgestitch/railtie.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "edgestitch"
+
+module Edgestitch
+  # Railtie to install the stitch task (db:stitch).
+  # require this railtie to automatically install the stitch task for the app,
+  # or define it manually adding `::Edgestitch.define_stitch` to your Rakefile.
+  class Railtie < ::Rails::Railtie
+    rake_tasks { ::Edgestitch::Tasks.define_stitch }
+  end
+end

data/lib/edgestitch/stitch.sql.erb

@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS `schema_migrations` (
+  `version` varchar(255) NOT NULL,
+  PRIMARY KEY (`version`),
+  UNIQUE KEY `unique_schema_migrations` (`version`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+<% each_file do |file| %>
+-- <%= file.realpath %>
+<%= file.read %>
+<% end %>

data/lib/edgestitch/stitcher.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Edgestitch
+  # @private
+  #
+  # Renders a structure.sql file based on all given engine's structure-self.sql
+  #
+  class Stitcher
+    def initialize(engines)
+      @engines = Set.new(engines)
+    end
+
+    def each_file(&block)
+      @engines.map { |engine| engine.root.join("db", "structure-self.sql") }
+              .filter(&:exist?)
+              .uniq.each(&block)
+    end
+
+    def self.to_file(file, *engines)
+      File.write(file, new(engines).render)
+    end
+  end
+end
+
+erb = ERB.new(File.read(File.join(__dir__, "stitch.sql.erb")))
+erb.def_method(Edgestitch::Stitcher, "render()")

data/lib/edgestitch/tasks.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "rake/tasklib"
+
+module Edgestitch
+  # @private
+  #
+  # Define rake tasks to deal with edgestitch structurefiles:
+  #
+  #   db:stitch: creates a structure.sql out of loaded engines and application
+  #              structure-self.sql
+  #   db:stitch:<engine_name>: creates a structure-self.sql containing only the
+  #                            engine's models and migrations
+  #
+  # In order to integrate well with rails, it also enhances tasks like db:structure:load,
+  # db:prepare and others.
+  #
+  module Tasks
+    class << self
+      include Rake::DSL
+
+      # Defines a task to stitch a structure.sql from loaded Engines.
+      # This task is responsible for gathering all loaded engines and the current
+      # application's structrure-self.sql and stitching them together into a
+      # structure.sql.
+      #
+      # Rails enhancements will happen before each of these tasks:
+      #
+      # - db:prepare
+      # - db:structure:load
+      # - db:schema:load
+      #
+      # @param namespace [String] namespace where the task will run [default: db:stitch]
+      # @return [Rake::Task]
+      def define_stitch(namespace = "db:stitch")
+        enhance(namespace, "db:prepare", "db:structure:load", "db:schema:load")
+        desc "Create structure.sql for an app based on all loaded engines' structure-self.sql"
+        task namespace => [:environment] do |_task, _args|
+          ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+            ::Edgestitch::Stitcher.to_file(filename(db_config), *::Rails::Engine.subclasses, Rails.application)
+          end
+        end
+      end
+
+      # Defines a task to generate the structure-self.sql file from an engine.
+      # This task is responsible for gathering all models owned by the engine and all
+      # migrations defined within the engine and generate a structure-self.sql.
+      #
+      # Rails enhancements will happen before each of these tasks:
+      #
+      # - db:structure:dump
+      # - db:schema:dump
+      # - app:db:structure:dump
+      # - app:db:schema:dump
+      #
+      # @param engine [Class<Rails::Engine>] target class of the task
+      # @param namespace [String] the namespace where the target will be generated [default: db:stitch]
+      # @param name [String] the name of the task within the given namespace [default: engine.engine_name]
+      # @return [Rake::Task]
+      def define_engine(engine, namespace: "db:stitch", name: engine.engine_name)
+        enhance("#{namespace}:#{name}", "db:structure:dump", "app:db:structure:dump", "db:schema:dump",
+                "app:db:schema:dump")
+
+        desc "Create structure-self.sql for an engine"
+        task "#{namespace}:#{name}" => [:environment] do |_, _args|
+          Rails.application.eager_load!
+          engine&.eager_load!
+          ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db_config|
+            ::Edgestitch::Exporter.export(engine, ::Edgestitch::Mysql::Dump.new(db_config))
+          end
+        end
+      end
+
+    private
+
+      def enhance(with, *tasks)
+        tasks.filter { |task| Rake::Task.task_defined?(task) }
+             .each { |task| Rake::Task[task].enhance([with]) }
+      end
+
+      def filename(db_config)
+        if ::ActiveRecord::Tasks::DatabaseTasks.respond_to?(:schema_dump_path)
+          ::ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(db_config, :sql)
+        else
+          name = db_config.respond_to?(:name) ? db_config.name : db_config.spec_name
+          ::ActiveRecord::Tasks::DatabaseTasks.dump_filename(name, :sql)
+        end
+      end
+    end
+  end
+end

data/lib/edgestitch/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Edgestitch
+  VERSION = "0.1.0"
+end

data/lib/edgestitch.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "edgestitch/exporter"
+require "edgestitch/stitcher"
+require "edgestitch/tasks"
+require "edgestitch/version"
+
+require "edgestitch/mysql/dump"
+
+# Facade module to access public Edgestitch functions
+#
+module Edgestitch
+module_function
+
+  # Define a db:stitch task
+  # @see Edgestitch::Tasks
+  def define_stitch(...)
+    ::Edgestitch::Tasks.define_stitch(...)
+  end
+
+  # Define a db:stitch:<engine_name> task
+  # @see Edgestitch::Tasks
+  def define_engine(...)
+    ::Edgestitch::Tasks.define_engine(...)
+  end
+end

data/mkdocs.yml

@@ -0,0 +1,6 @@
+site_name: Edgestitch
+nav:
+  - "Home": "README.md"
+  - "Changelog": "CHANGELOG.md"
+plugins:
+  - techdocs-core

metadata

@@ -0,0 +1,220 @@
+--- !ruby/object:Gem::Specification
+name: edgestitch
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Carlos Palhares
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-12-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: license_finder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.3
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.8.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.2
+- !ruby/object:Gem::Dependency
+  name: rubocop-powerhome
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.15.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.15.1
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.21
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.21
+description: Edgestitch allows engines to define partial structure-self.sql files
+  to be stitched into a single structure.sql file by the umbrella application.
+email:
+- chjunior@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- Gemfile
+- Rakefile
+- doc/dependency_decisions.yml
+- docs/CHANGELOG.md
+- docs/README.md
+- edgestitch.gemspec
+- lib/edgestitch.rb
+- lib/edgestitch/exporter.rb
+- lib/edgestitch/mysql/dump.rb
+- lib/edgestitch/mysql/structure_constraint_order_munger.rb
+- lib/edgestitch/railtie.rb
+- lib/edgestitch/stitch.sql.erb
+- lib/edgestitch/stitcher.rb
+- lib/edgestitch/tasks.rb
+- lib/edgestitch/version.rb
+- mkdocs.yml
+homepage: https://github.com/powerhome/power-tools
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/powerhome/power-tools
+  source_code_uri: https://github.com/powerhome/power-tools
+  changelog_uri: https://github.com/powerhome/power-tools/blob/main/packages/edgestitch/docs/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key: 
+specification_version: 4
+summary: Edgestitch allows engines to define partial structure-self.sql files to be
+  stitched into a single structure.sql file by the umbrella application.
+test_files: []