static_db 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21a5a8909bd4d182d4045ce780e15d9d33c2a2e226148e76928ef76391b6c465
-  data.tar.gz: 901c8f63945110038f237f562150106d167c2eb6033ec17cf82e60eda97df89a
+  metadata.gz: 64c3b151a70d3b1f03bff857579e371b3799548a74980816aef917015bf610b1
+  data.tar.gz: f8b63e280ed3fae3191a7c1a57153741d678eb73bfa37a2319d56f43e0ff72c3
 SHA512:
-  metadata.gz: 6ff8c6ac84a7a469918dfe1781b4aa94fee65fb81a7bda3f858f11e5be4b7681da9913d7e502bcf8f25270f1f7bf60fdda5a95a8b93a9d861a1eb17bd0dbf8c4
-  data.tar.gz: befb42dbc227cac64482b9dfcd966c0f0f53754ccb3d71eff0893791c2fe3889f544c674d45a4c97c563026196e6ff2c9da28f2ceb1611bc72fb9afca79362b0
+  metadata.gz: 3e9325d80ee2538813a45d5cde76d3753e04a30bbecc6b38289677a150fb9e5226e0f60ac557c0b76288c05e8c922e570ffd7a3c90463cafcbbb3e7869e723c5
+  data.tar.gz: cde86cba01f3f3341a66b4469e9733186c0ed710158edcb9197c9885156949e2ca8653ab306f7db583b0257c0d1631f9946e96931d6ea7e02a27055cc32fba3d

data/CHANGELOG.md

@@ -12,6 +12,30 @@ This project adheres to [Break Versioning](https://www.taoensso.com/break-versio
 
 -
 
+## [0.2.0] - 2026-05-08
+
+### Breaking
+
+- Config option `fixture_path` was renamed to `static_db_path`.
+- The Rails boot sequence hooks are no longer active automatically. You need to opt-in via the config options `load` and `dump`.
+- The Rails boot sequence hooks no longer run for any `* build` command. They only run for `parklife build`.
+
+### Non-breaking
+
+- All config options now support Procs or any other object responding to `.call()`.
+  - The default Proc for config option `static_db_path` now gets evaluated correctly.
+- Internal code cleanup
+
+## [0.1.1] - 2026-05-03
+
+### Breaking
+
+-
+
+### Non-breaking
+
+- Remove unused dependency on `ostruct`
+
 ## [0.1.0] - 2026-05-03
 
 ### Breaking

data/README.md

@@ -3,11 +3,19 @@
 
 # static_db
 
-Dump DB contents to YAML and load them back again. Aimed at SQLite. Committable to git.
+Dump DB contents to YAML and load them back again.
 
-## Installation
+This gem provides:
+- Methods: `StaticDb::Load.new.perform` and `StaticDb::Dump.new.perform`
+- Rake tasks: `static:load` and `static:dump` (available automatically in Rails projects)
+- Hooks for the Rails boot sequence: off by default, but the main purpose of this gem. See configuration below.
+
+> ℹ️ The original main use case for this gem are static site generators built on top of Ruby on Rails.
+> However, the DB (de)serialization functionality is useful enough on its own, so the decision was made
+> to disable any behavior by default, which could result in data loss for regular Rails applications.
+> You can opt into the Rails boot sequence hooks via config.
 
-> ⚠️ This gem modifies the Rails startup sequence. Don't use this gem unless you want to build a static site generator. This gem also creates and drops the DB for you.
+## Installation
 
 Add it to your Rails project:
 
@@ -16,26 +24,36 @@ Add it to your Rails project:
 gem "static_db"
 ```
 
+This example initializer shows a flexible way how to opt into the Rails boot sequency hooks:
+
 ```ruby
 # config/initializer/static_db.rb
 StaticDb.configure do |config|
-  # `content/data` is the default. You only need this initializer,
-  # if you want a custom path.
-  config.fixture_path = Rails.root.join("content", "data")
+  config.static_db_path = Rails.root.join("content", "data")
+
+  # Selectively activate loading and dumping. Active by default. Set to any other value to disable.
+  config.load = ENV["STATIC_DB"].in? [ "load", nil, "on", "true", "1" ]
+  config.dump = ENV["STATIC_DB"].in? [ "dump", nil, "on", "true", "1" ]
 end
 ```
 
-## Usage
+Now, starting your Rails server will reset your DB and load YAML fixtures from `content/data`. Exiting the server with `Ctrl+C` will dump out your DB as YAML fixtures to that directory.
 
-> ⚠️ Only use on Rails projects with SQLite. Have a valid `db/schema.rb`.
+All config options support procs.
 
-Start your app with `bin/dev`. You will notice that a DB gets created for you. It will be empty.
+## Hook activation
 
-Create some records. Then, stop your server with Ctrl+C.
+The boot sequence hooks are active in the following scenarios:
+- When you run any server command: `bin/rails s`
+- When you run any console command: `bin/rails c`
+- When you run `parklife build`
 
-The DB contents will have been dumped to `content/data`.
+> ℹ️ If you already have your dev server running and want to start an additional console, avoid conflicts by using `STATIC_DB=0 bin/rails c` (with the example initializer from above).
 
-Restart your server with `bin/dev`. Your SQLite DB will be dropped and recreated with all previously stored data from `content/data`.
+The boot sequence hooks are inactive in all other cases, e.g.:
+- When you run tests: `bin/rails t` or `bin/rails test:system`
+- When you run migrations: `bin/rails db:migrate`
+- When you run any other rake tasks
 
 ## Contributing
 

data/Rakefile

@@ -7,7 +7,7 @@ begin
   require "rubocop/rake_task"
   RuboCop::RakeTask.new
 rescue LoadError
-  task(:rubocop) {}
+  task(:rubocop) { }
 end
 
 task default: %w[rubocop spec]

data/lib/static_db/dump.rb

@@ -1,21 +1,18 @@
 module StaticDb
   class Dump
+    attr_reader :models_to_be_saved
 
-    attr_reader :fixture_path, :models_to_be_saved
-
-    def initialize(fixture_path: StaticDb.config.fixture_path)
-      @fixture_path = Pathname.new(fixture_path)
+    def initialize(static_db_path: StaticDb.path)
+      @static_db_path = Pathname.new(static_db_path)
       @models_to_be_saved = models
     end
 
     def perform
-      exit 1 if $skip_active_fixtures_dump
+      exit 1 if $skip_static_db_dump
 
       validate_records!
-
-      puts green("Dumping fixtures ...")
-      dump_fixtures!
-      puts green("Done!")
+      reset_data_directory!
+      dump_data!
     end
 
     private
@@ -27,84 +24,76 @@ module StaticDb
 
       models_to_be_saved.each do |model|
         model.find_each do |record|
-          unless record.valid?
-            errors << { model: model.name, slug: record.slug, errors: record.errors.full_messages }
-          end
+          next if record.valid?
+
+          debug_data = { model: model.name, id: record.id, errors: record.errors.full_messages }
+          debug_data[:slug] = record.slug if record.respond_to?(:slug)
+
+          errors << debug_data
         end
       end
 
       if errors.any?
         puts red("Found #{errors.length} invalid records!")
         errors.each do |error|
-          puts "- #{error[:model]} #{error[:slug]}: #{error[:errors].join(", ")}"
+          puts "- #{error[:model]} #{error[:slug] || error[:id]}: #{error[:errors].join(", ")}"
         end
-        if ARGV.first == "build"
+
+        if StaticDb.parklife?
           puts red("Build failed!")
           exit 1
         else
-          puts red("Please fix the invalid records before creating a PR!")
+          puts red("PROCEEDING TO DUMP DATA DESPITE VALIDATION ERRORS!!!")
+          puts
+          puts red("Set `config.load = false` to preserve the invalid data in your DB when restarting. Then you can fix the validation errors and retry dumping.")
         end
       else
         puts green("Done!")
       end
     end
 
-    def dump_fixtures!
-      reset_data_directory!
-      models_to_be_saved.each { |model| format_and_write_yaml_file!(model) }
-    end
-
     def reset_data_directory!
-      FileUtils.rm_rf(fixture_path)
-      FileUtils.mkdir_p(fixture_path)
+      FileUtils.rm_rf(@static_db_path)
+      FileUtils.mkdir_p(@static_db_path)
     end
 
-    def format_and_write_yaml_file!(model)
-      instances = fetch_model_instances(model)
-      output = format_instances(model: model, instances: instances)
-      write_yaml_file!(model: model, data: output)
-    end
+    def dump_data!
+      puts green("Dumping data ...")
 
-    def fetch_model_instances(model)
-      model.unscoped.all.order('id ASC')
-    end
+      models_to_be_saved.each { |model| write_file!(path: file_path(model), data: data(model)) }
 
-    # TODO: check against old implementation!
-    def format_instances(model:, instances:)
-      output = {}
+      puts green("Done!")
+    end
 
-      instances.each do |instance|
-        attrs = {}
+    def write_file!(path:, data:)
+      File.open(path, "w") { |file| file << data.to_yaml }
+    end
 
-        model.columns.each do |column|
-          value = instance.read_attribute_before_type_cast(column.name)
-          attrs[column.name] = value unless value.nil?
-        end
+    def file_path(model)
+      File.join(@static_db_path, "#{model.table_name}.yml")
+    end
 
-        output["#{model}_#{instance.id}"] = attrs
+    def data(model)
+      model.unscoped.order(:id).to_h do |instance|
+        [ "#{model}_#{instance.id}", instance_data(instance, model.columns) ]
       end
-
-      output
     end
 
-    def write_yaml_file!(model:, data:)
-      File.open(yaml_file_path(model), 'w') { |file| file << data.to_yaml }
+    def instance_data(instance, columns)
+      columns.filter_map do |column|
+        value = instance.read_attribute_before_type_cast(column.name)
+        next if value.nil?
+
+        [ column.name, value ]
+      end.to_h
     end
 
     def models
       Rails.application.eager_load!
-      models = ActiveRecord::Base.descendants
-      models.select! { |model| model.table_exists? && model.any? }
-      models.delete(ActiveRecord::SchemaMigration)
-      models
-    end
-
-    def yaml_file_path(model)
-      File.join(fixture_path, generate_file_name(model) + '.yml')
-    end
 
-    def generate_file_name(model)
-      model.table_name
+      ActiveRecord::Base.descendants.select do |model|
+         model.table_exists? && model.any? && model != ActiveRecord::SchemaMigration
+      end
     end
 
     def green(text)
@@ -114,6 +103,5 @@ module StaticDb
     def red(text)
       "\e[31m#{text}\e[0m"
     end
-
   end
 end

data/lib/static_db/engine.rb

@@ -11,7 +11,21 @@ module StaticDb # :nodoc:
   # - regular initializers from `config/initializers/`
   include StaticDb::Configurable
 
-  config_accessor :fixture_path, instance_accessor: false, default: -> { Rails.root.join("content", "data") }
+  config_accessor :static_db_path, instance_accessor: false, default: -> { Rails.root.join("content", "data") }
+  config_accessor :load, instance_accessor: false, default: false
+  config_accessor :dump, instance_accessor: false, default: false
+
+  def self.unproc(value_or_proc)
+    value_or_proc.respond_to?(:call) ? value_or_proc.call : value_or_proc
+  end
+
+  def self.path = unproc(config.static_db_path)
+  def self.load? = unproc(config.load)
+  def self.dump? = unproc(config.dump)
+
+  def self.parklife?
+    File.basename($PROGRAM_NAME) == "parklife" && ARGV.first == "build"
+  end
 
   class Engine < ::Rails::Engine # :nodoc:
     isolate_namespace StaticDb
@@ -21,16 +35,15 @@ module StaticDb # :nodoc:
     end
 
     initializer "static_db.configure" do |app|
-      if defined?(Rails::Server) || defined?(Rails::Console) || ARGV.first == "build"
+      if defined?(Rails::Server) || defined?(Rails::Console) || StaticDb.parklife?
         Rails.application.config.after_initialize do
-          StaticDb::Load.new.perform
+          StaticDb::Load.new.perform if StaticDb.load?
         end
 
         at_exit do
-          StaticDb::Dump.new.perform
+          StaticDb::Dump.new.perform if StaticDb.dump?
         end
       end
     end
-
   end
 end

data/lib/static_db/load.rb

@@ -1,32 +1,38 @@
 module StaticDb
   class Load
-
-    attr_reader :fixture_path
-
-    def initialize(fixture_path: StaticDb.config.fixture_path)
-      @fixture_path = Pathname.new(fixture_path)
+    def initialize(static_db_path: StaticDb.path)
+      @static_db_path = Pathname.new(static_db_path)
     end
 
     def perform
-      puts green("Loading fixtures ...")
-      system("bin/rails", "db:drop", "db:create", "db:schema:load")
-      load_fixtures!
-      puts green("Done!")
+      reset_database!
+      load_data!
     rescue => e
-      puts red("Failed to load fixtures: #{e.message}")
-      puts red("Exiting and skipping active_fixtures:dump!")
-      $skip_active_fixtures_dump = true
+      puts red("Failed to load data: #{e.message}")
+      puts red("Exiting and skipping StaticDb::Dump.")
+      $skip_static_db_dump = true
       exit 1
     end
 
     private
 
-    def load_fixtures!
-      base_names = Dir.glob(File.join(fixture_path, "*.yml")).map do |file|
+    def reset_database!
+      puts green("Resetting database ...")
+
+      system("bin/rails", "db:drop", "db:create", "db:schema:load")
+
+      puts green("Done!")
+    end
+
+    def load_data!
+      puts green("Loading data ...")
+
+      base_names = Dir.glob(File.join(@static_db_path, "*.yml")).map do |file|
         File.basename(file, ".*")
       end
+      ActiveRecord::FixtureSet.create_fixtures(@static_db_path, base_names)
 
-      ActiveRecord::FixtureSet.create_fixtures(fixture_path, base_names)
+      puts green("Done!")
     end
 
     def green(text)
@@ -36,6 +42,5 @@ module StaticDb
     def red(text)
       "\e[31m#{text}\e[0m"
     end
-
   end
 end

data/lib/static_db/tasks/static.rake

@@ -1,19 +1,19 @@
 namespace :static do
-  desc "Create fixtures from database; accepts optional path argument"
-  task :dump, [:path] => :environment do |t, args|
-    if args[:path].blank?
-      StaticDb::Dump.new.perform
+  desc "Reset database and load YAML fixtures"
+  task :load, [ :static_db_path ] => :environment do |t, args|
+    if args[:static_db_path].blank?
+      StaticDb::Load.new.perform
     else
-      StaticDb::Dump.new(fixture_path: Rails.root.join(args[:path])).perform
+      StaticDb::Load.new(static_db_path: Rails.root.join(args[:static_db_path])).perform
     end
   end
 
-  desc "Create database from fixtures; accepts optional path argument"
-  task :load, [:path] => :environment do |t, args|
-    if args[:path].blank?
-      StaticDb::Load.new.perform
+  desc "Dump database to YAML fixtures"
+  task :dump, [ :static_db_path ] => :environment do |t, args|
+    if args[:static_db_path].blank?
+      StaticDb::Dump.new.perform
     else
-      StaticDb::Load.new(fixture_path: Rails.root.join(args[:path])).perform
+      StaticDb::Dump.new(static_db_path: Rails.root.join(args[:static_db_path])).perform
     end
   end
 end

data/lib/static_db/version.rb

@@ -1,3 +1,3 @@
 module StaticDb # :nodoc:
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: static_db
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Klaus Weidinger
@@ -23,20 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.2'
-- !ruby/object:Gem::Dependency
-  name: ostruct
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.6'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.6'
 description: Dump DB contents to YAML and load them back again. Aimed at SQLite. Committable
   to git.
 email: