tormenta20 0.2.1 → 0.2.2

data/src/ruby/tormenta20/models/origem.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "json"
+
+module Tormenta20
+  module Models
+    # Model representing an Origem (Character Origin) in Tormenta20.
+    #
+    # Origins provide starting skills, items, and sometimes unique powers.
+    #
+    # @example Find origins with unique powers
+    #   Origem.with_unique_power
+    #
+    # @example Get origin skills
+    #   soldado = Origem.find("soldado")
+    #   soldado.skills  # => ["Fortitude", "Luta"]
+    #
+    # @!attribute [rw] id
+    #   @return [String] Unique identifier (e.g., "soldado")
+    # @!attribute [rw] name
+    #   @return [String] Origin name (e.g., "Soldado")
+    # @!attribute [rw] description
+    #   @return [String] Origin description
+    # @!attribute [rw] items
+    #   @return [Array] Starting items
+    # @!attribute [rw] benefits
+    #   @return [Hash] Benefits with "skills" and "powers" keys
+    # @!attribute [rw] unique_power
+    #   @return [Hash, nil] Unique power data or nil
+    class Origem < Base
+      self.table_name = "origens"
+
+      validates :id, presence: true, uniqueness: true
+      validates :name, presence: true
+
+      # @!method with_unique_power
+      #   Filter origins that have a unique power.
+      #   @return [ActiveRecord::Relation<Origem>]
+      scope :with_unique_power, -> { where.not(unique_power: nil) }
+
+      # Get trained skills from this origin.
+      #
+      # @return [Array<String>] List of skill names
+      def skills
+        benefits&.dig("skills") || []
+      end
+
+      # Get powers granted by this origin.
+      #
+      # @return [Array<String>] List of power names
+      def powers
+        benefits&.dig("powers") || []
+      end
+
+      # Convert origin to a hash representation.
+      #
+      # @return [Hash] Hash with all origin attributes
+      def to_h
+        {
+          id: id,
+          name: name,
+          description: description,
+          items: items,
+          benefits: benefits,
+          unique_power: unique_power
+        }.compact
+      end
+    end
+  end
+end

data/src/ruby/tormenta20/models/poder.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "json"
+
+module Tormenta20
+  module Models
+    # Model representing a Poder (Power/Ability) in Tormenta20.
+    #
+    # Powers can be unique origin abilities, deity-granted powers, Tormenta powers, etc.
+    #
+    # @example Find deity-granted powers
+    #   Poder.poderes_concedidos
+    #
+    # @example Find powers by type
+    #   Poder.by_type("poder_tormenta")
+    #
+    # @!attribute [rw] id
+    #   @return [String] Unique identifier
+    # @!attribute [rw] name
+    #   @return [String] Power name
+    # @!attribute [rw] type
+    #   @return [String] Power type (see TYPES constant)
+    # @!attribute [rw] description
+    #   @return [String] Power description
+    # @!attribute [rw] effects
+    #   @return [Array] Power effects
+    # @!attribute [rw] prerequisites
+    #   @return [Array] Prerequisites to acquire this power
+    # @!attribute [rw] origin_id
+    #   @return [String, nil] Associated origin ID (for unique origin powers)
+    # @!attribute [rw] deities
+    #   @return [Array<String>] Deities that grant this power
+    class Poder < Base
+      self.table_name = "poderes"
+      self.inheritance_column = nil
+
+      # Valid power types.
+      #
+      # @return [Array<String>] List of valid type values
+      TYPES = %w[
+        habilidade_unica_origem
+        poder_concedido
+        poder_tormenta
+        poder_classe
+        poder_geral
+        poder_combate
+        poder_destino
+        poder_magia
+      ].freeze
+
+      validates :id, presence: true, uniqueness: true
+      validates :name, presence: true
+      validates :type, presence: true, inclusion: { in: TYPES }
+
+      # @!group Scopes
+
+      # @!method habilidades_unicas
+      #   Filter unique origin abilities.
+      #   @return [ActiveRecord::Relation<Poder>]
+      scope :habilidades_unicas, -> { where(type: "habilidade_unica_origem") }
+
+      # @!method poderes_concedidos
+      #   Filter deity-granted powers.
+      #   @return [ActiveRecord::Relation<Poder>]
+      scope :poderes_concedidos, -> { where(type: "poder_concedido") }
+
+      # @!method poderes_tormenta
+      #   Filter Tormenta powers.
+      #   @return [ActiveRecord::Relation<Poder>]
+      scope :poderes_tormenta, -> { where(type: "poder_tormenta") }
+
+      # @!method poderes_classe
+      #   Filter class powers.
+      #   @return [ActiveRecord::Relation<Poder>]
+      scope :poderes_classe, -> { where(type: "poder_classe") }
+
+      # @!method poderes_gerais
+      #   Filter general powers.
+      #   @return [ActiveRecord::Relation<Poder>]
+      scope :poderes_gerais, -> { where(type: "poder_geral") }
+
+      # @!method by_type(type)
+      #   Filter powers by type.
+      #   @param type [String] Power type
+      #   @return [ActiveRecord::Relation<Poder>]
+      scope :by_type, ->(t) { where(type: t) }
+
+      # @!method by_origin(origin_id)
+      #   Filter powers by associated origin.
+      #   @param origin_id [String] Origin ID
+      #   @return [ActiveRecord::Relation<Poder>]
+      scope :by_origin, ->(origin_id) { where(origin_id: origin_id) }
+
+      # @!method by_deity(deity_id)
+      #   Filter powers granted by a specific deity.
+      #   @param deity_id [String] Deity ID
+      #   @return [ActiveRecord::Relation<Poder>]
+      scope :by_deity, ->(deity_id) { where("json_extract(deities, '$') LIKE ?", "%#{deity_id}%") }
+
+      # @!endgroup
+
+      # Convert power to a hash representation.
+      #
+      # @return [Hash] Hash with all power attributes
+      def to_h
+        {
+          id: id,
+          name: name,
+          type: type,
+          description: description,
+          effects: effects,
+          prerequisites: prerequisites,
+          origin_id: origin_id,
+          deities: deities
+        }.compact
+      end
+    end
+  end
+end

data/src/ruby/tormenta20/models/regra.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "json"
+
+module Tormenta20
+  module Models
+    # Model representing a Regra (Rule) in Tormenta20.
+    #
+    # Rules contain structured data about game mechanics such as
+    # skills, conditions, combat rules, and other game systems.
+    #
+    # @example Find all rules
+    #   Tormenta20.regras.all
+    #
+    # @example Find a specific rule
+    #   Tormenta20.regras.find("pericias")
+    #
+    # @!attribute [rw] id
+    #   @return [String] Unique identifier (e.g., "pericias")
+    # @!attribute [rw] name
+    #   @return [String] Rule name in Portuguese
+    # @!attribute [rw] description
+    #   @return [String, nil] Rule description
+    # @!attribute [rw] data
+    #   @return [Hash, Array] Structured rule data (JSON)
+    class Regra < Base
+      self.table_name = "regras"
+
+      validates :id, presence: true, uniqueness: true
+      validates :name, presence: true
+      validates :data, presence: true
+
+      # Convert the rule to a hash representation.
+      #
+      # @return [Hash] Hash with all rule attributes (nil values excluded)
+      def to_h
+        {
+          id: id,
+          name: name,
+          description: description,
+          data: data
+        }.compact
+      end
+    end
+  end
+end

data/src/ruby/tormenta20/seeder.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Tormenta20
+  # Handles importing JSON data into the database
+  module Seeder
+    JSON_BASE_PATH = File.expand_path("../../json", __dir__)
+
+    class << self
+      def seed_all(verbose: false)
+        @verbose = verbose
+        log "Seeding database..."
+
+        seed_origens
+        seed_poderes_habilidades_unicas
+        seed_divindades
+        seed_poderes_concedidos
+        seed_poderes_tormenta
+        seed_classes
+        seed_magias
+        seed_equipamentos
+        seed_itens_superiores
+        seed_regras
+
+        log "Database seeded successfully!"
+      end
+
+      def seeded?
+        Models::Origem.count.positive?
+      rescue StandardError
+        false
+      end
+
+      private
+
+      def log(message)
+        puts message if @verbose
+      end
+
+      def seed_origens
+        import_json_files(
+          "origens",
+          Models::Origem,
+          %i[id name description items benefits unique_power]
+        )
+      end
+
+      def seed_poderes_habilidades_unicas
+        import_json_files(
+          "poderes/habilidades_unicas_de_origem",
+          Models::Poder,
+          %i[id name description effects prerequisites],
+          extra_attrs: { type: "habilidade_unica_origem" },
+          transform: lambda { |data|
+            data[:origin_id] = data.delete(:origin) if data[:origin]
+            data
+          }
+        )
+      end
+
+      def seed_divindades
+        import_json_files(
+          "deuses",
+          Models::Divindade,
+          %i[id name title description beliefs_objectives holy_symbol energy
+             preferred_weapon devotees granted_powers obligations_restrictions]
+        )
+      end
+
+      def seed_poderes_concedidos
+        import_json_files(
+          "poderes/poderes_concedidos",
+          Models::Poder,
+          %i[id name description effects prerequisites deities],
+          extra_attrs: { type: "poder_concedido" }
+        )
+      end
+
+      def seed_poderes_tormenta
+        import_json_files(
+          "poderes/poderes_da_tormenta",
+          Models::Poder,
+          %i[id name description effects prerequisites],
+          extra_attrs: { type: "poder_tormenta" }
+        )
+      end
+
+      def seed_classes
+        import_json_files(
+          "classes",
+          Models::Classe,
+          %i[id name hit_points mana_points skills proficiencies abilities powers progression spellcasting]
+        )
+      end
+
+      def seed_magias
+        json_dir = File.join(JSON_BASE_PATH, "magias")
+        return unless Dir.exist?(json_dir)
+
+        Dir.glob(File.join(json_dir, "*.json")).each do |file|
+          data = JSON.parse(File.read(file), symbolize_names: true)
+          import_magia(data)
+        rescue StandardError
+          next
+        end
+      end
+
+      def import_magia(data)
+        raw_target = data[:target]
+        target = if raw_target.is_a?(Hash)
+                   raw_target
+                 else
+                   (raw_target.is_a?(Array) ? raw_target.first || {} : {})
+                 end
+        effect_details = data[:effect_details].is_a?(Hash) ? data[:effect_details] : {}
+        resistence = data[:resistence].is_a?(Hash) ? data[:resistence] : {}
+        extra_costs = data[:extra_costs].is_a?(Hash) ? data[:extra_costs] : {}
+
+        Models::Magia.find_or_initialize_by(id: data[:id]).tap do |magia|
+          magia.name = data[:name]
+          magia.type = data[:type]
+          magia.circle = data[:circle]
+          magia.school = data[:school]
+          magia.execution = data[:execution]
+          magia.execution_details = data[:execution_details]
+          magia.range = data[:range]
+          magia.duration = data[:duration]
+          magia.duration_details = data[:duration_details]
+          magia.counterspell = data[:counterspell]
+          magia.description = data[:description] || ""
+
+          magia.target_amount = target[:amount]
+          magia.target_up_to = if target[:up_to].nil?
+                                 nil
+                               else
+                                 (target[:up_to] ? 1 : 0)
+                               end
+          magia.target_type = target[:type]
+
+          magia.effect = data[:effect]
+          magia.effect_shape = effect_details[:shape]
+          magia.effect_dimention = effect_details[:dimention]
+          magia.effect_size = effect_details[:size]
+          magia.effect_other_details = effect_details[:other_details]
+
+          magia.area_effect = data[:area_effect]
+          magia.area_effect_details = data[:area_effect_details]
+
+          magia.resistence_effect = resistence[:effect]
+          magia.resistence_skill = resistence[:skill]
+
+          magia.extra_costs_material_component = extra_costs[:material_component]
+          magia.extra_costs_material_cost = extra_costs[:material_component_cost]
+          magia.extra_costs_pm_debuff = extra_costs[:pm_debuff]
+          magia.extra_costs_pm_sacrifice = extra_costs[:pm_sacrifice]
+
+          magia.enhancements = data[:enhancements] || []
+          magia.effects = data[:effects] || []
+
+          magia.save!
+        end
+      end
+
+      def seed_equipamentos
+        seed_armas
+        seed_armaduras
+        seed_escudos
+        seed_itens
+      end
+
+      def seed_armas
+        import_json_files(
+          "equipamentos/armas",
+          Models::Arma,
+          %i[id name category price damage damage_type critical range weight properties description]
+        )
+      end
+
+      def seed_armaduras
+        import_json_files(
+          "equipamentos/armaduras",
+          Models::Armadura,
+          %i[id name category price defense_bonus armor_penalty weight properties description]
+        )
+      end
+
+      def seed_escudos
+        import_json_files(
+          "equipamentos/escudos",
+          Models::Escudo,
+          %i[id name price defense_bonus armor_penalty weight properties description],
+          transform: lambda { |data|
+            data[:price] ||= data.delete(:preco)
+            data[:defense_bonus] ||= data.delete(:bonus_defesa)
+            data[:armor_penalty] ||= data.delete(:penalidade_armadura)
+            data[:weight] ||= data.delete(:espacos)
+            data
+          }
+        )
+      end
+
+      def seed_itens
+        import_json_files(
+          "equipamentos/itens",
+          Models::Item,
+          %i[id name category price weight description effects]
+        )
+      end
+
+      def seed_itens_superiores
+        seed_materiais_especiais
+        seed_melhorias
+      end
+
+      def seed_materiais_especiais
+        import_json_files(
+          "itens_superiores/materiais_especiais",
+          Models::MaterialEspecial,
+          %i[id name description applicable_to price_modifier effects]
+        )
+      end
+
+      def seed_melhorias
+        import_json_files(
+          "itens_superiores/melhorias",
+          Models::Melhoria,
+          %i[id name description applicable_to price effects]
+        )
+      end
+
+      def seed_regras
+        import_json_files(
+          "regras",
+          Models::Regra,
+          %i[id name description data],
+          transform: lambda { |raw|
+            base_keys = %i[id name description]
+            data_content = raw.reject { |k, _| base_keys.include?(k) }
+            { id: raw[:id], name: raw[:name], description: raw[:description], data: data_content }
+          }
+        )
+      end
+
+      def import_json_files(subdir, model, attrs, extra_attrs: {}, transform: nil)
+        json_dir = File.join(JSON_BASE_PATH, subdir)
+        return unless Dir.exist?(json_dir)
+
+        Dir.glob(File.join(json_dir, "*.json")).each do |file|
+          data = JSON.parse(File.read(file), symbolize_names: true)
+          data = transform.call(data) if transform
+
+          record = model.find_or_initialize_by(id: data[:id])
+          attrs.each do |attr|
+            record.send("#{attr}=", data[attr]) if data.key?(attr)
+          end
+          extra_attrs.each do |attr, value|
+            record.send("#{attr}=", value)
+          end
+          record.save!
+        rescue StandardError
+          next
+        end
+      end
+    end
+  end
+end

data/src/ruby/tormenta20/version.rb

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

data/src/ruby/tormenta20.rb

@@ -1,12 +1,174 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'ostruct'
-require 'bundler'
+require "json"
+require "active_record"
+require "sqlite3"
 
-Bundler.setup(:default)
+require_relative "tormenta20/database"
 
-require_relative 'open_struct_json'
-Dir[__dir__ + "/tormenta20/*.rb"].each {|file| require file }
+# Load base model first, then other models
+require_relative "tormenta20/models/base"
+Dir["#{__dir__}/tormenta20/models/*.rb"].each { |file| require file unless file.include?("base") }
 
-module Tormenta20; end
+# Load other modules
+Dir["#{__dir__}/tormenta20/*.rb"].each { |file| require file unless file.include?("database") }
+
+# Tormenta20 is a Ruby library providing data about the Brazilian TTRPG Tormenta20.
+#
+# It includes a pre-built SQLite database with information about spells, classes,
+# origins, deities, powers, and equipment from the Tormenta20 system.
+#
+# @example Basic usage
+#   require 'tormenta20'
+#
+#   # Query spells
+#   Tormenta20.magias.arcanas.by_circle("3")
+#
+#   # Find a specific class
+#   Tormenta20.classes.find("guerreiro")
+#
+# @author LuanGB
+# @see https://github.com/LuanGB/tormenta20
+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
+    # @return [void]
+    #
+    # @example Use default builtin 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)
+    end
+
+    # @!group Query Interface
+
+    # Access the Origem (Origin) model for querying character origins.
+    #
+    # @return [Class<Models::Origem>] The Origem model class
+    # @example
+    #   Tormenta20.origens.all
+    #   Tormenta20.origens.with_unique_power
+    def origens
+      Models::Origem
+    end
+
+    # Access the Poder (Power) model for querying powers and abilities.
+    #
+    # @return [Class<Models::Poder>] The Poder model class
+    # @example
+    #   Tormenta20.poderes.poderes_concedidos
+    #   Tormenta20.poderes.by_type("poder_tormenta")
+    def poderes
+      Models::Poder
+    end
+
+    # Access the Divindade (Deity) model for querying deities.
+    #
+    # @return [Class<Models::Divindade>] The Divindade model class
+    # @example
+    #   Tormenta20.divindades.energia_positiva
+    #   Tormenta20.divindades.find("khalmyr")
+    def divindades
+      Models::Divindade
+    end
+
+    # Access the Classe (Character Class) model for querying classes.
+    #
+    # @return [Class<Models::Classe>] The Classe model class
+    # @example
+    #   Tormenta20.classes.conjuradores
+    #   Tormenta20.classes.find("arcanista")
+    def classes
+      Models::Classe
+    end
+
+    # Access the Magia (Spell) model for querying spells.
+    #
+    # @return [Class<Models::Magia>] The Magia model class
+    # @example
+    #   Tormenta20.magias.arcanas
+    #   Tormenta20.magias.by_circle("3").by_school("evoc")
+    def magias
+      Models::Magia
+    end
+
+    # Access the Arma (Weapon) model for querying weapons.
+    #
+    # @return [Class<Models::Arma>] The Arma model class
+    # @example
+    #   Tormenta20.armas.simples
+    #   Tormenta20.armas.ranged
+    def armas
+      Models::Arma
+    end
+
+    # Access the Armadura (Armor) model for querying armors.
+    #
+    # @return [Class<Models::Armadura>] The Armadura model class
+    # @example
+    #   Tormenta20.armaduras.leves
+    #   Tormenta20.armaduras.pesadas
+    def armaduras
+      Models::Armadura
+    end
+
+    # Access the Escudo (Shield) model for querying shields.
+    #
+    # @return [Class<Models::Escudo>] The Escudo model class
+    # @example
+    #   Tormenta20.escudos.all
+    def escudos
+      Models::Escudo
+    end
+
+    # Access the Item model for querying general items.
+    #
+    # @return [Class<Models::Item>] The Item model class
+    # @example
+    #   Tormenta20.itens.by_category("alquimico")
+    def itens
+      Models::Item
+    end
+
+    # Access the MaterialEspecial (Special Material) model.
+    #
+    # @return [Class<Models::MaterialEspecial>] The MaterialEspecial model class
+    # @example
+    #   Tormenta20.materiais_especiais.all
+    def materiais_especiais
+      Models::MaterialEspecial
+    end
+
+    # Access the Melhoria (Enhancement) model for querying magic enhancements.
+    #
+    # @return [Class<Models::Melhoria>] The Melhoria model class
+    # @example
+    #   Tormenta20.melhorias.all
+    def melhorias
+      Models::Melhoria
+    end
+
+    # Access the Regra (Rule) model for querying rules and reference data.
+    #
+    # @return [Class<Models::Regra>] The Regra model class
+    # @example
+    #   Tormenta20.regras.find("pericias")
+    def regras
+      Models::Regra
+    end
+
+    # @!endgroup
+  end
+
+  # Auto-setup database when gem is loaded
+  setup
+end