tormenta20 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 775c13dccef6b13bcd76ea3efc8e2cf8b4c5221faf4fb73dffce3ce9b265a101
-  data.tar.gz: 88618dbc1c4c5d1e6c6e9127e39b1c2726423bf79b0c8229452dc5c767273d0f
+  metadata.gz: 8bda7c785ab5b22dd5d1652986dc37b62f7b3fa59b2d4690185740c3c4aac33d
+  data.tar.gz: feb865c7dee191eb5dcff058b2a0b9071a3415c3fa5579706f603c58402dcc68
 SHA512:
-  metadata.gz: 759238af753ee81ef3619f372a7938c6a8a656988d63dca357bf997fdbe2dea6df45a2a1dbda5fc5374a4e49f52cb07c71f30d1ce33435e86a88332da4aa8f39
-  data.tar.gz: d3ead8b84ef084bdd77c6399d1b92fcafb8773cacd0b6a965bab9437356657246121ff880af605172baf6f2e129956a235ea8fc9566b6b21e37bcd01557ce91e
+  metadata.gz: f6e33daca420c543a2d87d9b1f1ecc0d9497780f9e59db41f3ec15a8f60a439e0eb43b032eeead981c67c4c928d64ec3f624b076ffac27e7aac9c1210baec91d
+  data.tar.gz: 3f4b898a1332a1d6c2e34cab772ceb124fc8b7ae31e420683c7b7960cc34ab8ac62df5c6d8270b8df6a426611cb087bf314b34311f8b9f63df4e03d046cf1e8d

data/db/seeds.rb

@@ -372,6 +372,7 @@ end
 
 # Run seeds if this file is executed directly
 if __FILE__ == $PROGRAM_NAME
-  Tormenta20::Database.setup(mode: :build)
+  ENV["TORMENTA20_DB_MODE"] = "create_on_build"
+  Tormenta20::Database.setup
   Tormenta20::Seeds.import_all
 end

data/exe/tormenta20

@@ -0,0 +1,377 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "fileutils"
+
+# CLI for managing the Tormenta20 database
+module Tormenta20CLI
+  class << self
+    def run(args)
+      options = parse_options(args)
+      command = args.shift || "help"
+
+      case command
+      when "build"
+        build_database(options)
+      when "seed"
+        seed_data(options)
+      when "reset"
+        reset_database(options)
+      when "info"
+        show_info(options)
+      when "export"
+        export_json(options)
+      when "import"
+        import_json(options)
+      when "help", "--help", "-h"
+        show_help
+      else
+        puts "Unknown command: #{command}"
+        show_help
+        exit 1
+      end
+    end
+
+    private
+
+    def parse_options(args)
+      options = {}
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: tormenta20 <command> [options]"
+
+        opts.on("-p", "--path PATH", "Database path") do |path|
+          options[:path] = path
+        end
+
+        opts.on("-t", "--tables TABLES", "Comma-separated tables to seed") do |tables|
+          options[:tables] = tables.split(",").map(&:strip)
+        end
+
+        opts.on("-j", "--json PATH", "JSON file or directory path") do |path|
+          options[:json_path] = path
+        end
+
+        opts.on("-o", "--output PATH", "Output path for export") do |path|
+          options[:output] = path
+        end
+
+        opts.on("-v", "--verbose", "Verbose output") do
+          options[:verbose] = true
+        end
+
+        opts.on("-f", "--force", "Force overwrite") do
+          options[:force] = true
+        end
+      end.parse!(args)
+
+      options
+    end
+
+    def setup_env(options)
+      if options[:path]
+        ENV["TORMENTA20_DB_MODE"] = "path"
+        ENV["TORMENTA20_DB_PATH"] = File.expand_path(options[:path])
+      else
+        ENV["TORMENTA20_DB_MODE"] = "create_on_build"
+      end
+
+      require "tormenta20"
+    end
+
+    def build_database(options)
+      puts "Building database..."
+
+      if options[:path]
+        path = File.expand_path(options[:path])
+        FileUtils.rm_f(path) if options[:force] && File.exist?(path)
+
+        if File.exist?(path) && !options[:force]
+          puts "Database already exists at #{path}"
+          puts "Use --force to overwrite"
+          exit 1
+        end
+
+        ENV["TORMENTA20_DB_MODE"] = "path"
+        ENV["TORMENTA20_DB_PATH"] = path
+      else
+        ENV["TORMENTA20_DB_MODE"] = "create_on_build"
+      end
+
+      require "tormenta20"
+
+      # Force rebuild
+      Tormenta20::Database.disconnect if Tormenta20::Database.connected?
+      FileUtils.rm_f(Tormenta20::Database.db_path) if options[:force]
+
+      Tormenta20::Database.send(:ensure_database_exists)
+      Tormenta20::Database.send(:connect_to_database)
+
+      puts "Database built at: #{Tormenta20::Database.db_path}"
+      show_summary
+    end
+
+    def seed_data(options)
+      setup_env(options)
+
+      tables = options[:tables] || all_tables
+
+      puts "Seeding tables: #{tables.join(", ")}"
+
+      tables.each do |table|
+        seed_table(table, options)
+      end
+
+      show_summary
+    end
+
+    def reset_database(options)
+      setup_env(options)
+
+      puts "Resetting database..."
+      Tormenta20::Database.reset
+      puts "Database reset complete."
+      show_summary
+    end
+
+    def show_info(options)
+      setup_env(options)
+
+      puts "Tormenta20 Database Info"
+      puts "=" * 40
+      puts "Mode: #{Tormenta20::Database.mode}"
+      puts "Path: #{Tormenta20::Database.db_path}"
+      puts "Connected: #{Tormenta20::Database.connected?}"
+      puts ""
+      show_summary
+    end
+
+    def export_json(options)
+      setup_env(options)
+
+      output_dir = options[:output] || "./export"
+      tables = options[:tables] || all_tables
+
+      FileUtils.mkdir_p(output_dir)
+
+      tables.each do |table|
+        export_table(table, output_dir, options)
+      end
+
+      puts "Exported to: #{output_dir}"
+    end
+
+    def import_json(options)
+      setup_env(options)
+
+      json_path = options[:json_path]
+      unless json_path
+        puts "Error: --json PATH is required"
+        exit 1
+      end
+
+      if File.directory?(json_path)
+        import_directory(json_path, options)
+      elsif File.file?(json_path)
+        import_file(json_path, options)
+      else
+        puts "Error: Path not found: #{json_path}"
+        exit 1
+      end
+    end
+
+    def show_help
+      puts <<~HELP
+        Tormenta20 Database CLI
+
+        Usage: tormenta20 <command> [options]
+
+        Commands:
+          build     Build/rebuild the database from JSON files
+          seed      Seed specific tables
+          reset     Reset the database (delete and rebuild)
+          info      Show database information
+          export    Export data to JSON files
+          import    Import JSON file(s) into the database
+          help      Show this help
+
+        Options:
+          -p, --path PATH       Custom database path
+          -t, --tables TABLES   Comma-separated tables (origens,classes,magias,...)
+          -j, --json PATH       JSON file or directory to import
+          -o, --output PATH     Output directory for export
+          -v, --verbose         Verbose output
+          -f, --force           Force overwrite existing files
+
+        Tables:
+          origens, poderes, divindades, classes, magias,
+          armas, armaduras, escudos, itens,
+          materiais_especiais, melhorias, regras
+
+        Examples:
+          tormenta20 build                          # Build with default path
+          tormenta20 build -p ./my.db -f            # Build at custom path
+          tormenta20 seed -t magias,classes         # Seed only specific tables
+          tormenta20 import -j ./custom_spell.json  # Import a JSON file
+          tormenta20 export -o ./backup             # Export all to JSON
+          tormenta20 info                           # Show database info
+      HELP
+    end
+
+    def all_tables
+      %w[origens poderes divindades classes magias armas armaduras escudos itens materiais_especiais melhorias regras]
+    end
+
+    def seed_table(table, options)
+      print "  Seeding #{table}..."
+
+      case table
+      when "origens"
+        Tormenta20::Seeder.send(:seed_origens)
+      when "poderes"
+        Tormenta20::Seeder.send(:seed_poderes_habilidades_unicas)
+        Tormenta20::Seeder.send(:seed_poderes_concedidos)
+        Tormenta20::Seeder.send(:seed_poderes_tormenta)
+      when "divindades"
+        Tormenta20::Seeder.send(:seed_divindades)
+      when "classes"
+        Tormenta20::Seeder.send(:seed_classes)
+      when "magias"
+        Tormenta20::Seeder.send(:seed_magias)
+      when "armas"
+        Tormenta20::Seeder.send(:seed_armas)
+      when "armaduras"
+        Tormenta20::Seeder.send(:seed_armaduras)
+      when "escudos"
+        Tormenta20::Seeder.send(:seed_escudos)
+      when "itens"
+        Tormenta20::Seeder.send(:seed_itens)
+      when "materiais_especiais"
+        Tormenta20::Seeder.send(:seed_materiais_especiais)
+      when "melhorias"
+        Tormenta20::Seeder.send(:seed_melhorias)
+      when "regras"
+        Tormenta20::Seeder.send(:seed_regras)
+      else
+        puts " unknown table"
+        return
+      end
+
+      puts " done"
+    end
+
+    def export_table(table, output_dir, options)
+      model = table_to_model(table)
+      return unless model
+
+      table_dir = File.join(output_dir, table)
+      FileUtils.mkdir_p(table_dir)
+
+      count = 0
+      model.find_each do |record|
+        file_path = File.join(table_dir, "#{record.id}.json")
+        File.write(file_path, JSON.pretty_generate(record.to_h))
+        count += 1
+      end
+
+      puts "  Exported #{count} #{table}" if options[:verbose]
+    end
+
+    def import_directory(dir_path, options)
+      Dir.glob(File.join(dir_path, "**/*.json")).each do |file|
+        import_file(file, options)
+      end
+    end
+
+    def import_file(file_path, options)
+      data = JSON.parse(File.read(file_path), symbolize_names: true)
+
+      # Try to determine the table from the file path or data
+      table = detect_table(file_path, data)
+      model = table_to_model(table)
+
+      unless model
+        puts "  Skipping #{file_path}: unknown table"
+        return
+      end
+
+      record = model.find_or_initialize_by(id: data[:id])
+      data.each do |key, value|
+        record.send("#{key}=", value) if record.respond_to?("#{key}=")
+      end
+      record.save!
+
+      puts "  Imported #{data[:id]} into #{table}" if options[:verbose]
+    rescue StandardError => e
+      puts "  Error importing #{file_path}: #{e.message}"
+    end
+
+    def detect_table(file_path, data)
+      # Try to detect from path
+      path_parts = file_path.split("/")
+      possible_tables = all_tables
+
+      path_parts.each do |part|
+        return part if possible_tables.include?(part)
+      end
+
+      # Try to detect from data structure
+      return "magias" if data[:circle] && data[:school]
+      return "classes" if data[:hit_points] && data[:abilities]
+      return "divindades" if data[:energy] && data[:granted_powers]
+      return "origens" if data[:benefits] && data[:unique_power]
+      return "armas" if data[:damage] && data[:critical]
+      return "armaduras" if data[:defense_bonus] && data[:category]
+      return "escudos" if data[:defense_bonus] && !data[:category]
+
+      nil
+    end
+
+    def table_to_model(table)
+      case table
+      when "origens" then Tormenta20::Models::Origem
+      when "poderes" then Tormenta20::Models::Poder
+      when "divindades" then Tormenta20::Models::Divindade
+      when "classes" then Tormenta20::Models::Classe
+      when "magias" then Tormenta20::Models::Magia
+      when "armas" then Tormenta20::Models::Arma
+      when "armaduras" then Tormenta20::Models::Armadura
+      when "escudos" then Tormenta20::Models::Escudo
+      when "itens" then Tormenta20::Models::Item
+      when "materiais_especiais" then Tormenta20::Models::MaterialEspecial
+      when "melhorias" then Tormenta20::Models::Melhoria
+      when "regras" then Tormenta20::Models::Regra
+      end
+    end
+
+    def show_summary
+      puts ""
+      puts "Database Summary:"
+      puts "-" * 40
+
+      {
+        "Origens" => Tormenta20::Models::Origem,
+        "Poderes" => Tormenta20::Models::Poder,
+        "Divindades" => Tormenta20::Models::Divindade,
+        "Classes" => Tormenta20::Models::Classe,
+        "Magias" => Tormenta20::Models::Magia,
+        "Armas" => Tormenta20::Models::Arma,
+        "Armaduras" => Tormenta20::Models::Armadura,
+        "Escudos" => Tormenta20::Models::Escudo,
+        "Itens" => Tormenta20::Models::Item,
+        "Materiais Especiais" => Tormenta20::Models::MaterialEspecial,
+        "Melhorias" => Tormenta20::Models::Melhoria,
+        "Regras" => Tormenta20::Models::Regra
+      }.each do |name, model|
+        printf "  %-20s %d\n", "#{name}:", model.count
+      rescue StandardError
+        printf "  %-20s %s\n", "#{name}:", "N/A"
+      end
+
+      puts "-" * 40
+    end
+  end
+end
+
+Tormenta20CLI.run(ARGV)

data/src/ruby/tormenta20/database.rb

@@ -7,89 +7,52 @@ require "fileutils"
 module Tormenta20
   # Database connection and setup management for Tormenta20.
   #
-  # This module handles all database operations including connection management,
-  # schema creation, and data seeding.
+  # Configuration via environment variables:
+  # - TORMENTA20_DB_MODE: "built_in" (default), "create_on_build", or "path"
+  # - TORMENTA20_DB_PATH: Custom path (required when mode is "path")
   #
-  # @example Setup with default options
-  #   Tormenta20::Database.setup
+  # @example Using built-in database (default)
+  #   # No configuration needed, uses pre-built database from gem
+  #   require 'tormenta20'
   #
-  # @example Setup with custom database path
-  #   Tormenta20::Database.setup(db_path: "/custom/path/tormenta20.sqlite3")
+  # @example Creating database on build
+  #   # Set before requiring the gem:
+  #   # TORMENTA20_DB_MODE=create_on_build
+  #
+  # @example Using custom path
+  #   # TORMENTA20_DB_MODE=path
+  #   # TORMENTA20_DB_PATH=/my/custom/path.sqlite3
   module Database
+    # Valid database modes
+    MODES = %w[built_in create_on_build path].freeze
+
     class << self
-      # @!attribute [rw] mode
-      #   @return [Symbol] Current database mode (:builtin, :build, or :lazy)
-      attr_accessor :mode
+      # @return [String] Current database mode
+      def mode
+        @mode ||= ENV.fetch("TORMENTA20_DB_MODE", "built_in")
+      end
 
-      # @!attribute [rw] db_path
-      #   @return [String] Path to the SQLite database file
-      attr_accessor :db_path
+      # @return [String] Path to the SQLite database file
+      def db_path
+        @db_path ||= resolve_db_path
+      end
 
       # Initialize and configure the database connection.
       #
-      # @param mode [Symbol] Database initialization mode:
-      #   - `:builtin` - Use pre-built database (connects immediately)
-      #   - `:build` - Build database on load (creates if missing, then connects)
-      #   - `:lazy` - Build database on first use (default)
-      # @param db_path [String, nil] Custom path to SQLite database file.
-      #   If nil, uses the default path.
       # @return [void]
-      # @raise [ArgumentError] If an invalid mode is provided
-      #
-      # @example Default lazy setup
-      #   Database.setup
-      #
-      # @example Immediate connection with builtin database
-      #   Database.setup(mode: :builtin)
-      def setup(mode: :lazy, db_path: nil)
-        @mode = mode
-        @db_path = db_path || default_db_path
+      def setup
+        validate_mode!
         @setup_done = true
 
-        case mode
-        when :builtin
-          connect_to_database
-        when :build
-          ensure_database_exists
-          connect_to_database
-        when :lazy
-          # Connection will be established on first use via ensure_connected
-          nil
-        else
-          raise ArgumentError, "Invalid mode: #{mode}. Use :builtin, :build, or :lazy"
-        end
+        ensure_database_exists if mode == "create_on_build"
+        connect_to_database
       end
 
       # Ensure database is connected, setting up if needed.
       #
-      # This method is called automatically when models are accessed.
-      # It handles lazy initialization of the database connection.
-      #
       # @return [void]
       def ensure_connected
         setup unless @setup_done
-        connect_to_database unless connected?
-      end
-
-      # Establish connection to the SQLite database.
-      #
-      # Creates the database if it doesn't exist (in lazy mode) and
-      # establishes an ActiveRecord connection.
-      #
-      # @return [void]
-      def connect_to_database
-        return if connected?
-
-        ensure_database_exists if mode == :lazy
-
-        ActiveRecord::Base.establish_connection(
-          adapter: "sqlite3",
-          database: db_path,
-          pool: 5,
-          timeout: 5000
-        )
-
-        @connected = true
       end
 
       # Check if database connection is active.
@@ -101,62 +64,12 @@ module Tormenta20
         false
       end
 
-      # Ensure database file and schema exist.
-      #
-      # Creates the database directory, file, and runs the schema
-      # if the database doesn't exist.
-      #
-      # @return [void]
-      def ensure_database_exists
-        db_dir = File.dirname(db_path)
-        FileUtils.mkdir_p(db_dir) unless Dir.exist?(db_dir)
-
-        needs_seed = !File.exist?(db_path)
-
-        return unless needs_seed
-
-        # Create empty database
-        SQLite3::Database.new(db_path).close
-
-        # Run schema if available
-        run_schema if schema_exists?
-
-        # Seed data after schema creation
-        seed_database
-      end
-
-      # Seed database with data from JSON files.
-      #
-      # @return [void]
-      def seed_database
-        return if Seeder.seeded?
-
-        Seeder.seed_all(verbose: false)
-      end
-
-      # Run pending database migrations.
-      #
-      # @return [void]
-      def migrate
-        connect_to_database
-        ActiveRecord::MigrationContext.new(migrations_path, ActiveRecord::SchemaMigration).migrate
-      end
-
-      # Rollback database migrations.
+      # Disconnect from the database.
       #
-      # @param steps [Integer] Number of migrations to rollback
       # @return [void]
-      def rollback(steps: 1)
-        connect_to_database
-        ActiveRecord::MigrationContext.new(migrations_path, ActiveRecord::SchemaMigration).rollback(steps)
-      end
-
-      # Get current database migration version.
-      #
-      # @return [Integer] Current migration version number
-      def version
-        connect_to_database
-        ActiveRecord::Base.connection.migration_context.current_version
+      def disconnect
+        ActiveRecord::Base.remove_connection if connected?
+        @connected = false
       end
 
       # Reset database by dropping and recreating it.
@@ -170,14 +83,6 @@ module Tormenta20
         connect_to_database
       end
 
-      # Disconnect from the database.
-      #
-      # @return [void]
-      def disconnect
-        ActiveRecord::Base.remove_connection if connected?
-        @connected = false
-      end
-
       # Get the default database file path.
       #
       # @return [String] Absolute path to the default database file
@@ -192,31 +97,62 @@ module Tormenta20
         File.expand_path("../../../db/schema.sql", __dir__)
       end
 
-      # Get the migrations directory path.
-      #
-      # @return [String] Absolute path to the migrations directory
-      def migrations_path
-        File.expand_path("../../../db/migrate", __dir__)
+      private
+
+      def resolve_db_path
+        case mode
+        when "path"
+          ENV.fetch("TORMENTA20_DB_PATH") do
+            raise ArgumentError, "TORMENTA20_DB_PATH is required when TORMENTA20_DB_MODE=path"
+          end
+        else
+          default_db_path
+        end
       end
 
-      private
+      def validate_mode!
+        return if MODES.include?(mode)
+
+        raise ArgumentError, "Invalid TORMENTA20_DB_MODE: #{mode}. Valid: #{MODES.join(", ")}"
+      end
+
+      def connect_to_database
+        return if connected?
+
+        ActiveRecord::Base.establish_connection(
+          adapter: "sqlite3",
+          database: db_path,
+          pool: 5,
+          timeout: 5000
+        )
+
+        @connected = true
+      end
+
+      def ensure_database_exists
+        db_dir = File.dirname(db_path)
+        FileUtils.mkdir_p(db_dir) unless Dir.exist?(db_dir)
+
+        return if File.exist?(db_path)
+
+        SQLite3::Database.new(db_path).close
+        run_schema if schema_exists?
+        seed_database
+      end
+
+      def seed_database
+        return if Seeder.seeded?
+
+        Seeder.seed_all(verbose: false)
+      end
 
-      # Check if schema file exists.
-      #
-      # @return [Boolean] true if schema.sql exists
-      # @api private
       def schema_exists?
         File.exist?(schema_path)
       end
 
-      # Run schema SQL file to create database tables.
-      #
-      # @return [void]
-      # @api private
       def run_schema
         connect_to_database
         sql = File.read(schema_path)
-        # Use execute_batch to handle multi-statement SQL including triggers
         ActiveRecord::Base.connection.raw_connection.execute_batch(sql)
       end
     end

data/src/ruby/tormenta20/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tormenta20
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/src/ruby/tormenta20.rb

@@ -33,20 +33,16 @@ module Tormenta20
   class << self
     # Configure and setup the database connection.
     #
-    # @param mode [Symbol] Database mode:
-    #   - `:builtin` - Use pre-built database (default)
-    #   - `:build` - Build database on load
-    #   - `:lazy` - Build database on first use
-    # @param db_path [String, nil] Custom path to SQLite database file
+    # Configuration is done via environment variables:
+    # - TORMENTA20_DB_MODE: "built_in" (default), "create_on_build", or "path"
+    # - TORMENTA20_DB_PATH: Custom path (required when mode is "path")
+    #
     # @return [void]
     #
-    # @example Use default builtin database
+    # @example Default usage (built-in database)
     #   Tormenta20.setup
-    #
-    # @example Use custom database path
-    #   Tormenta20.setup(db_path: "/path/to/custom.sqlite3")
-    def setup(mode: :builtin, db_path: nil)
-      Database.setup(mode: mode, db_path: db_path)
+    def setup
+      Database.setup
     end
 
     # @!group Query Interface

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tormenta20
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - LuanGB
@@ -55,7 +55,8 @@ description: A Ruby, Node and Python library with data about the Brazilian TTRPG
   Tormenta20
 email:
 - luan.goncbs@gmail.com
-executables: []
+executables:
+- tormenta20
 extensions: []
 extra_rdoc_files: []
 files:
@@ -82,6 +83,7 @@ files:
 - docs/poderes.md
 - docs/regras.md
 - examples/database_usage.rb
+- exe/tormenta20
 - files.txt
 - package-lock.json
 - package.json