kweerie 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8c4f949ad0ee144a37015f2444ad19721390ee94a59b1fc118599409b6b0f0a
-  data.tar.gz: a8b741b11e8dd572f6fccba9f06becbb75b06f0444e879f43b21f70d164d2ba7
+  metadata.gz: a1ca73e0c3e5890aa9805eed0b491c100be177b958fc9bab9592eaf4f2cdb0d0
+  data.tar.gz: b79729e675821e02c2ff02e3dfcdb8e5237230364790cc9e59e1d4a953ea8da6
 SHA512:
-  metadata.gz: 368206d1376231a56d197911245878f8efdf8eb33f86f47135c079f2d3c28b2ac5a70786b7bafaa694b980f6f192ea6ac2d43ffcdb41f77bbd24aee295c7b9c4
-  data.tar.gz: 82c8cb0e9a1171f3a0e90b0db23ebc5f35e2b82401f4db2066b3903db383b8e08f619ab25edefbc0bea4ebab93fde9072d86895bfa864a1f793c4370f5f02f03
+  metadata.gz: 511ea093375cca24abbb8514a98b26cfb662239b836c3da7140aac4ef06ba7a23bf40074e1d9a973ac56a1cd02d1dd5dac486409968bed8f40b39312b6a8ac6d
+  data.tar.gz: abd8e02e09a00f3d4dd683c5e9e179386c053ed0c390d2f09a8c227866e39ff6303400766f2ff173eaf5d379e3bcad84840621a2fdde5b593c76e8643c72741a

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.3
 
 Style/StringLiterals:
   Enabled: true
@@ -11,3 +11,36 @@ Style/StringLiteralsInInterpolation:
 
 Layout/LineLength:
   Max: 120
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength: 
+  Enabled: false
+
+Metrics/AbcSize: 
+  Enabled: false
+
+Style/MultilineBlockChain: 
+  Enabled: false
+
+Metrics/PerceivedComplexity: 
+  Enabled: false
+
+Metrics/AbcSize: 
+  Enabled: false
+
+Gemspec/RequiredRubyVersion: 
+  Enabled: false
+
+Metrics/BlockLength: 
+  Enabled: false
+
+Naming/AccessorMethodName:
+  Enabled: false

data/CHANGELOG.md

@@ -1,4 +1,10 @@
 ## [Unreleased]
+## [0.2.0] - 2024-11-12
+
+- changed BaseObjects to BaseObject.
+- remove automatic type inference.
+- added cast_select.
+- added tiny amound of custom types.
 
 ## [0.1.0] - 2024-11-06
 

data/README.md

@@ -47,30 +47,30 @@ Execute your query:
 
 ```ruby
 results = UserSearch.with(
-  name: 'John%',
+  name: 'Eclipsoid%',
   email: '%@example.com'
 )
-# => [{"id"=>9981, "name"=>"John Doe", "email"=>"johndoe@example.com"}]
+# => [{"id"=>109981, "name"=>"Eclipsoid Doe", "email"=>"eclipsoiddoe@example.com"}]
 ```
 
 ### Object Mapping
 
-While `Kweerie::Base` returns plain hashes, you can use `Kweerie::BaseObjects` to get typed Ruby objects with proper attribute methods:
+While `Kweerie::Base` returns plain hashes, you can use `Kweerie::BaseObject` to get typed Ruby objects with proper attribute methods:
 
 ```ruby
-class UserSearch < Kweerie::BaseObjects
+class UserSearch < Kweerie::BaseObject
   bind :name, as: '$1'
   bind :created_at, as: '$2'
 end
 
 # Returns array of objects instead of hashes
 users = UserSearch.with(
-  name: 'Claude',
+  name: 'Eclipsoid',
   created_at: '2024-01-01'
 )
 
 user = users.first
-user.name         # => "Claude"
+user.name         # => "Eclipsoid"
 user.created_at   # => 2024-01-01 00:00:00 +0000 (Time object)
 ```
 
@@ -148,118 +148,149 @@ UsersByStatus.all                    # ✗ Raises ArgumentError
 UsersByStatus.with(status: 'active') # ✓ Correct usage
 ```
 
-Both methods work with `Kweerie::Base` and `Kweerie::BaseObjects`, returning arrays of hashes or objects respectively:
+Both methods work with `Kweerie::Base` and `Kweerie::BaseObject`, returning arrays of hashes or objects respectively:
 
 ```ruby
 # Returns array of hashes
 class AllUsers < Kweerie::Base
 end
 users = AllUsers.all
-# => [{"id" => 1, "name" => "Claude"}, ...]
+# => [{"id" => 1, "name" => "Eclipsoid"}, ...]
 
 # Returns array of objects
-class AllUsers < Kweerie::BaseObjects
+class AllUsers < Kweerie::BaseObject
 end
 users = AllUsers.all
-# => [#<AllUsers id=1 name="Claude">, ...]
+# => [#<AllUsers id=1 name="Eclipsoid">, ...]
 ```
 
-### Automatic Type Casting
+### Object Interface
 
-BaseObjects automatically casts common PostgreSQL types to their Ruby equivalents:
+BaseObject provide several useful methods:
 
 ```ruby
-# In your SQL file
-SELECT 
-  name,
-  created_at,                    -- timestamp
-  age::integer,                  -- integer
-  score::float,                  -- float
-  active::boolean,               -- boolean
-  metadata::jsonb,               -- jsonb
-  tags::jsonb                    -- jsonb array
-FROM users;
-
-# In your Ruby code
-user = UserSearch.with(name: 'Claude').first
-
-user.created_at   # => Time object
-user.age          # => Integer
-user.score        # => Float
-user.active       # => true/false
-user.metadata     # => Hash with string keys
-user.tags         # => Array
-
-# Nested JSONB data is properly accessible
-user.metadata["role"]                    # => "admin"
-user.metadata["preferences"]["theme"]    # => "dark"
+# Hash-like access
+user[:name]                    # => "Eclipsoid"
+user.fetch(:email, 'N/A')      # => Returns 'N/A' if email is nil
+
+# Serialization
+user.to_h                      # => Hash with string keys
+user.to_json                   # => JSON string
+
+# Comparison
+user1 == user2                 # Compare all attributes
+users.sort_by(&:created_at)    # Sortable
 ```
 
-### Pattern Matching Support
+### SQL File Location
 
-BaseObjects support Ruby's pattern matching syntax:
+By default, Kweerie looks for SQL files adjacent to their Ruby query classes. You can customize this behavior:
 
 ```ruby
-case user
-in { name:, metadata: { role: "admin" } }
-  puts "Admin user: #{name}"
-in { name:, metadata: { role: "user" } }
-  puts "Regular user: #{name}"
+# Default behavior - looks for user_search.sql next to this file
+class UserSearch < Kweerie::Base
 end
 
-# Nested pattern matching
-case user
-in { metadata: { preferences: { theme: "dark" } } }
-  puts "Dark theme user"
+# Specify absolute path from Rails root
+class UserSearch < Kweerie::Base
+  sql_file_location root: 'db/queries/complex_user_search.sql'
+end
+
+# Specify path relative to the Ruby file
+class UserSearch < Kweerie::Base
+  sql_file_location relative: '../sql/user_search.sql'
+end
+
+# Explicitly use default behavior
+class UserSearch < Kweerie::Base
+  sql_file_location :default
 end
 ```
 
-### Object Interface
+## Type Casting
 
-BaseObjects provide several useful methods:
+`cast_select` provides flexible, explicit type casting for your query result fields. Instead of relying on automatic type inference, you can specify exactly how each field should be cast. By default it will return as the string from the database.
+
+### Basic Usage
 
 ```ruby
-# Hash-like access
-user[:name]                    # => "Claude"
-user.fetch(:email, 'N/A')      # => Returns 'N/A' if email is nil
+class UserQuery < Kweerie::BaseObjects
+  cast_select :age, as: ->(val) { val.to_i }
+  cast_select :active, as: Types::Boolean
+  cast_select :metadata, as: Types::PgJsonb
+end
+```
 
-# Serialization
-user.to_h                      # => Hash with string keys
-user.to_json                   # => JSON string
+### Casting Options
 
-# Comparison
-user1 == user2                 # Compare all attributes
-users.sort_by(&:created_at)    # Sortable
+#### Built-in Type Classes
+The gem includes a few built-in type classes for specific scenarios, you'll find a comprehensive amount of them in rails:
+
+```ruby
+# Boolean casting (handles various boolean representations)
+cast_select :active, as: Types::Boolean
+
+# JSONB casting (handles both objects and arrays)
+cast_select :metadata, as: Types::PgJsonb
 
-# Change tracking
-user.changed?                  # => Check if any attributes changed
-user.changes                   # => Hash of changes with [old, new] values
-user.original_attributes       # => Original attributes from DB
+# Postgres Array casting
+cast_select :tags, as: Types::PgArray
 ```
 
-### PostgreSQL Array Support
+#### Lambda/Proc Casting
+For simple transformations, you can use a lambda or proc:
 
-BaseObjects handles PostgreSQL arrays by converting them to Ruby arrays with proper type casting:
+```ruby
+class ProductQuery < Kweerie::BaseObjects
+  cast_select :price, as: ->(val) { val.to_f }
+  cast_select :quantity, as: ->(val) { val.to_i }
+  cast_select :sku, as: ->(val) { val.upcase }
+end
+```
+
+#### Method Reference Casting
+You can reference an instance method for complex casting logic:
 
 ```ruby
-# In your PostgreSQL schema
-create_table :users do |t|
-  t.integer :preferred_ordering, array: true, default: []
-  t.string :tags, array: true
-  t.float :scores, array: true
+class OrderQuery < Kweerie::BaseObjects
+  cast_select :total, as: :calculate_total
+  
+  def calculate_total(val)
+    return if val.nil?
+
+    Money.new(val)
+  end
 end
+```
+
+### Custom Type Classes
+
+For reusable, complex casting logic, you can create custom type classes, or use the ones provided by rails:
 
-# In your query
-user = UserSearch.with(name: 'Claude').first
+```ruby
+class Types::Money
+  def cast(value)
+    return nil if value.nil?
+
+    (value.to_f * 100).to_i # Store as cents
+  end
+end
 
-user.preferred_ordering  # => [1, 3, 2]
-user.tags                 # => ["ruby", "rails"]
-user.scores              # => [98.5, 87.2, 92.0]
+class Types::PGIntArray < Types::PgArray
+  def cast(value)
+    super.map(&:to_i)  # Convert array elements to integers
+  end
+end
+
+class InvoiceQuery < Kweerie::BaseObjects
+  cast_select :amount, as: Types::Money
+  cast_select :line_items, as: Types::PGIntArray
+end
 ```
 
 ### Performance Considerations
 
-BaseObjects creates a unique class for each query result set, with the following optimizations:
+BaseObject creates a unique class for each query result set, with the following optimizations:
 
 - Classes are cached and reused for subsequent queries
 - Attribute readers are defined upfront
@@ -300,9 +331,9 @@ end
 
 ## Requirements
 
-- Ruby 2.7 or higher
+- Ruby 3 or higher
 - PostgreSQL (this gem is PostgreSQL-specific and uses the `pg` gem)
-- Rails 6+ (optional, needed for the generator and default ActiveRecord integration)
+- Rails 7+ (optional, needed for the generator and default ActiveRecord integration)
 
 ## Features
 
@@ -312,14 +343,6 @@ end
 - ✅ Configurable connection handling
 - ✅ Parameter validation
 
-### Why Kweerie?
-
-- **SQL Views Overkill**: When a database view is too heavy-handed but you still want to keep SQL separate from Ruby
-- **Version Control**: Keep your SQL under version control alongside your Ruby code
-- **Parameter Safety**: Built-in parameter binding prevents SQL injection
-- **Simple Interface**: Clean, simple API for executing parameterized queries
-- **Rails Integration**: Works seamlessly with Rails and ActiveRecord
-
 ### Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
@@ -338,6 +361,9 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## FAQ
 
+**Q: Why does Kweerie exist?**  
+A: PostgreSQL DB views are powerful and (honestly) preferred for what kweerie offers, but they need migrations to change, which isn't always practical when you just need a query. Kweerie provides that flexibility. Plus, SQL is more readable in a single file than when nested in Ruby code. SQL is powerful and doesn’t always need to be hidden behind abstractions.
+
 **Q: Why PostgreSQL only?**  
 A: Kweerie uses PostgreSQL-specific features for parameter binding and result handling. Supporting other databases would require different parameter binding syntax and result handling.
 

data/lib/kweerie/base.rb

@@ -5,37 +5,142 @@ module Kweerie
     class << self
       def inherited(subclass)
         subclass.instance_variable_set(:@bindings, {})
+        subclass.instance_variable_set(:@class_location, caller_locations(1, 1)[0].path)
         super
       end
 
+      # == Parameter Binding
+      #
+      # Binds a parameter to a SQL placeholder. Parameters are required by default and
+      # must be provided when executing the query.
+      #
+      # === Options
+      #
+      # * <tt>:as</tt> - The SQL placeholder (e.g., '$1', '$2') that this parameter maps to
+      #
+      # === Examples
+      #
+      #   class UserSearch < Kweerie::Base
+      #     # Single parameter
+      #     bind :name, as: '$1'
+      #
+      #     # Multiple parameters
+      #     bind :email, as: '$2'
+      #     bind :status, as: '$3'
+      #   end
+      #
+      #   # Using the query
+      #   UserSearch.with(
+      #     name: 'Eclipsoid',
+      #     email: '%@example.com',
+      #     status: 'active'
+      #   )
+      #
+      # === Notes
+      #
+      # * Parameters must be provided in the order they appear in the SQL
+      # * All bound parameters are required
+      # * Use PostgreSQL's COALESCE for optional parameters
+      #
       def bind(param_name, as:)
         @bindings[param_name] = as
       end
 
       attr_reader :bindings
 
-      def sql_path
-        @sql_path ||= begin
-          subclass_file = "#{name.underscore}.sql"
-          possible_paths = Kweerie.configuration.sql_paths.call
-
-          sql_file = possible_paths.map do |path|
-            File.join(root_path, path, subclass_file)
-          end.find { |f| File.exist?(f) }
-
-          unless sql_file
-            raise SQLFileNotFound,
-                  "Could not find SQL file for #{name} in paths: #{possible_paths.join(", ")}"
+      # == SQL File Location
+      #
+      # Specifies the location of the SQL file for this query. By default, Kweerie looks for
+      # an SQL file with the same name as the query class in the same directory.
+      #
+      # === Options
+      #
+      # * <tt>:default</tt> - Use default file naming (class_name.sql in same directory)
+      # * <tt>root: 'path'</tt> - Path relative to Rails.root
+      # * <tt>relative: 'path'</tt> - Path relative to the query class file
+      #
+      # === Examples
+      #
+      #   class UserSearch < Kweerie::Base
+      #     # Default behavior - looks for user_search.sql in same directory
+      #     sql_file_location :default
+      #
+      #     # Use a specific file from Rails root
+      #     sql_file_location root: 'db/queries/complex_user_search.sql'
+      #
+      #     # Use a file relative to this class
+      #     sql_file_location relative: '../sql/user_search.sql'
+      #   end
+      #
+      # === Notes
+      #
+      # * Root paths require Rails to be defined
+      # * Paths should use forward slashes even on Windows
+      # * File extensions should be included in the path
+      # * Relative paths are relative to the query class file location
+      #
+      def sql_file_location(location = :default)
+        @sql_file_location =
+          case location
+          when :default
+            nil
+          when Hash
+            if location.key?(:root)
+              { root: location[:root].to_s }
+            elsif location.key?(:relative)
+              { relative: location[:relative].to_s }
+            else
+              raise ArgumentError,
+                    "Invalid sql_file_location option. Use :default, root: 'path', or relative: 'path'"
+            end
+          else
+            raise ArgumentError,
+                  "Invalid sql_file_location option. Use :default, root: 'path', or relative: 'path'"
           end
+      end
 
-          sql_file
-        end
+      def sql_path
+        @sql_path ||= SQLPathResolver.new(@sql_file_location, name).resolve
       end
 
       def sql_content
         @sql_content ||= File.read(sql_path)
       end
 
+      # == Execute Query with Parameters
+      #
+      # Executes the SQL query with the provided parameters. All bound parameters must be provided
+      # unless using .all for parameter-free queries.
+      #
+      # === Parameters
+      #
+      # * <tt>params</tt> - Hash of parameter names and values that match the bound parameters
+      #
+      # === Returns
+      #
+      # Array of hashes representing the query results. When using Kweerie::BaseObject,
+      # returns array of typed objects instead.
+      #
+      # === Examples
+      #
+      #   # With parameters
+      #   UserSearch.with(
+      #     name: 'Eclipsoid',
+      #     email: '%@example.com'
+      #   )
+      #   # => [{"id"=>1, "name"=>"Eclipsoid", "email"=>"eclipsoid@example.com"}]
+      #
+      #   # With type casting (BaseObject)
+      #   UserSearch.with(created_after: '2024-01-01')
+      #   # => [#<UserSearch id=1 created_at=2024-01-01 00:00:00 +0000>]
+      #
+      # === Notes
+      #
+      # * Raises ArgumentError if required parameters are missing
+      # * Raises ArgumentError if extra parameters are provided
+      # * Returns empty array if no results found
+      # * Parameters are bound safely using pg-ruby's parameter binding
+      #
       def with(params = {})
         validate_params!(params)
         param_values = order_params(params)

data/lib/kweerie/base_object.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string"
+require "json"
+
+module Kweerie
+  class BaseObject < Base
+    class << self
+      def with(params = {})
+        results = super
+        return [] if results.empty?
+
+        # Create a unique result class for this query
+        result_class = generate_result_class(results.first.keys)
+
+        # Map results to objects
+        results.map { |row| result_class.new(row) }
+      end
+
+      def cast_select(field, as: nil)
+        cast_definitions[field] = as if as
+      end
+
+      def cast_definitions
+        @cast_definitions ||= {}
+      end
+
+      private
+
+      def generate_result_class(attribute_names)
+        @generate_result_class ||= ResultClassGenerator.generate(self, attribute_names)
+      end
+    end
+  end
+end

data/lib/kweerie/result_class_components/accessors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ResultClassComponents
+  module Accessors
+    def [](key)
+      instance_variable_get("@#{key}")
+    end
+
+    def fetch(key, default = nil)
+      instance_variable_defined?("@#{key}") ? instance_variable_get("@#{key}") : default
+    end
+
+    def original_attributes
+      @_original_attributes
+    end
+
+    def raw_original_attributes
+      @_raw_original_attributes
+    end
+  end
+end

data/lib/kweerie/result_class_components/comparison.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ResultClassComponents
+  module Comparison
+    def <=>(other)
+      return nil unless other.is_a?(self.class)
+
+      to_h <=> other.to_h
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+
+      to_h == other.to_h
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      to_h.hash
+    end
+  end
+end

data/lib/kweerie/result_class_components/key_transformation.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ResultClassComponents
+  module KeyTransformation
+    def deep_stringify_keys(obj)
+      case obj
+      when Hash
+        obj.transform_keys(&:to_s)
+           .transform_values { |v| deep_stringify_keys(v) }
+      when Array
+        obj.map { |item| item.is_a?(Hash) ? deep_stringify_keys(item) : item }
+      else
+        obj
+      end
+    end
+
+    def deep_symbolize_keys(obj)
+      case obj
+      when Hash
+        obj.transform_keys(&:to_sym)
+           .transform_values { |v| deep_symbolize_keys(v) }
+      when Array
+        obj.map { |item| item.is_a?(Hash) ? deep_symbolize_keys(item) : item }
+      else
+        obj
+      end
+    end
+  end
+end

data/lib/kweerie/result_class_components/serialization.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ResultClassComponents
+  module Serialization
+    def to_h
+      attribute_names.each_with_object({}) do |name, hash|
+        value = instance_variable_get("@#{name}")
+        hash[name.to_s] = serialize_value(value)
+      end
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+
+    def deconstruct_keys(keys)
+      symbolized = deep_symbolize_keys(to_h)
+      keys ? symbolized.slice(*keys) : symbolized
+    end
+
+    private
+
+    def serialize_value(value)
+      value.is_a?(Hash) ? deep_stringify_keys(value) : value
+    end
+  end
+end

data/lib/kweerie/result_class_components/type_casting.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ResultClassComponents
+  module TypeCasting
+    def type_cast_value(value, type_definition)
+      return value if type_definition.nil?
+
+      case type_definition
+      when Symbol
+        public_send(type_definition, value)
+      when Proc
+        type_definition.call(value)
+      when Class
+        type_definition.new.cast(value)
+      else
+        raise ArgumentError, "Unsupported type definition: #{type_definition}"
+      end
+    end
+  end
+end

data/lib/kweerie/result_class_generator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "result_class_components/accessors"
+require_relative "result_class_components/comparison"
+require_relative "result_class_components/key_transformation"
+require_relative "result_class_components/serialization"
+require_relative "result_class_components/type_casting"
+
+module Kweerie
+  class ResultClassGenerator
+    def self.generate(parent_class, attribute_names)
+      Class.new(parent_class) do
+        include Comparable
+        include ResultClassComponents::Accessors
+        include ResultClassComponents::Comparison
+        include ResultClassComponents::KeyTransformation
+        include ResultClassComponents::Serialization
+        include ResultClassComponents::TypeCasting
+
+        # Define attr_readers for all columns
+        attribute_names.each { |name| attr_reader name }
+
+        define_method :initialize do |attrs|
+          # Store both raw and casted versions
+          cast_definitions = parent_class.cast_definitions
+
+          @_raw_original_attributes = attrs.dup
+          @_original_attributes = attrs.each_with_object({}) do |(key, value), hash|
+            type_definition = cast_definitions[key.to_sym]
+            casted_value = type_cast_value(value, type_definition)
+            hash[key.to_s] = casted_value
+            instance_variable_set("@#{key}", casted_value)
+          end
+
+          super() if defined?(super)
+        end
+
+        # Nice inspect output
+        define_method :inspect do
+          attrs = attribute_names.map do |name|
+            "#{name}=#{instance_variable_get("@#{name}").inspect}"
+          end.join(" ")
+          "#<#{self.class.superclass.name} #{attrs}>"
+        end
+
+        # Make attribute_names available to instance methods
+        define_method(:attribute_names) { attribute_names }
+      end
+    end
+  end
+end

data/lib/kweerie/sql_path_resolver.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class SQLPathResolver
+  class ConfigurationError < StandardError; end
+  class SQLFileNotFound < StandardError; end
+
+  def initialize(sql_file_location, name = nil)
+    @sql_file_location = sql_file_location
+    @name = name
+  end
+
+  def resolve
+    return resolve_root_path if root_path?
+    return resolve_relative_path if relative_path?
+
+    resolve_default_path
+  end
+
+  private
+
+  attr_reader :sql_file_location, :name
+
+  def root_path?
+    sql_file_location&.key?(:root)
+  end
+
+  def relative_path?
+    sql_file_location&.key?(:relative)
+  end
+
+  def resolve_root_path
+    raise ConfigurationError, "Root path requires Rails to be defined" unless defined?(Rails)
+
+    path = Rails.root.join(sql_file_location[:root]).to_s
+    validate_file_exists!(path)
+    path
+  end
+
+  def resolve_relative_path
+    relative_file = sql_file_location[:relative]
+    find_in_configured_paths(relative_file) or
+      raise SQLFileNotFound, "Could not find SQL file #{relative_file}"
+  end
+
+  def resolve_default_path
+    raise ArgumentError, "Name must be provided for default path resolution" unless name
+
+    sql_filename = "#{name.underscore}.sql"
+    find_in_configured_paths(sql_filename) or
+      raise SQLFileNotFound, "SQL file not found for #{name}"
+  end
+
+  def find_in_configured_paths(filename)
+    configured_paths.find do |path|
+      full_path = File.join(path, filename)
+      return full_path if File.exist?(full_path)
+    end
+  end
+
+  def configured_paths
+    Kweerie.configuration.sql_paths.call
+  end
+
+  def validate_file_exists!(path)
+    raise SQLFileNotFound, "Could not find SQL file at #{path}" unless File.exist?(path)
+  end
+end

data/lib/kweerie/types/boolean.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Types
+  class Boolean
+    TRUTHY = [true, 1, "1", "t", "T", "true", "TRUE"].freeze
+    FALSEY = [false, 0, "0", "f", "F", "false", "FALSE"].freeze
+
+    def cast(value)
+      return nil if value.nil?
+      return value if value.is_a?(Boolean)
+
+      if TRUTHY.include?(value)
+        true
+      elsif FALSEY.include?(value)
+        false
+      else
+        raise ArgumentError, "Invalid boolean value: #{value}"
+      end
+    end
+  end
+end

data/lib/kweerie/types/pg_array.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Types
+  class PgArray
+    def cast(value)
+      clean_value = value.gsub(/^{|}$/, "")
+      return [] if clean_value.empty?
+
+      elements = clean_value.split(/,(?=(?:[^"]*"[^"]*")*[^"]*$)/)
+      elements.map { |element| cast_array_element(element) }
+    end
+
+    def cast_array_element(element)
+      case element
+      when /^\d+$/ then element.to_i
+      when /^\d*\.\d+$/          then element.to_f
+      when /^(true|false)$/i     then element.downcase == "true"
+      when /^"(.*)"$/            then ::Regexp.last_match(1)
+      else element
+      end
+    end
+  end
+end

data/lib/kweerie/types/pg_jsonb.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Types
+  class PgJsonb
+    def cast(value)
+      return {} if value.nil?
+      return value if value.is_a?(Hash)
+
+      JSON.parse(value.to_s)
+    rescue JSON::ParserError
+      raise ArgumentError, "Invalid JSON value: #{value}"
+    end
+  end
+end

data/lib/kweerie/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kweerie
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/lib/kweerie.rb

@@ -26,4 +26,9 @@ end
 
 require_relative "kweerie/configuration"
 require_relative "kweerie/base"
-require_relative "kweerie/base_objects"
+require_relative "kweerie/base_object"
+require_relative "kweerie/sql_path_resolver"
+require_relative "kweerie/result_class_generator"
+require_relative "kweerie/types/boolean"
+require_relative "kweerie/types/pg_array"
+require_relative "kweerie/types/pg_jsonb"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kweerie
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Toby
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-07 00:00:00.000000000 Z
+date: 2024-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -68,8 +68,18 @@ files:
 - lib/generators/kweerie/kweerie_generator.rb
 - lib/kweerie.rb
 - lib/kweerie/base.rb
-- lib/kweerie/base_objects.rb
+- lib/kweerie/base_object.rb
 - lib/kweerie/configuration.rb
+- lib/kweerie/result_class_components/accessors.rb
+- lib/kweerie/result_class_components/comparison.rb
+- lib/kweerie/result_class_components/key_transformation.rb
+- lib/kweerie/result_class_components/serialization.rb
+- lib/kweerie/result_class_components/type_casting.rb
+- lib/kweerie/result_class_generator.rb
+- lib/kweerie/sql_path_resolver.rb
+- lib/kweerie/types/boolean.rb
+- lib/kweerie/types/pg_array.rb
+- lib/kweerie/types/pg_jsonb.rb
 - lib/kweerie/version.rb
 - sig/kweerie.rbs
 homepage: https://github.com/tobyond/kweerie

data/lib/kweerie/base_objects.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/string"
-require "json"
-
-module Kweerie
-  class BaseObjects < Base
-    class << self
-      def with(params = {})
-        results = super
-        return [] if results.empty?
-
-        # Create a unique result class for this query
-        result_class = generate_result_class(results.first.keys)
-
-        # Map results to objects
-        results.map { |row| result_class.new(row) }
-      end
-
-      private
-
-      def generate_result_class(attribute_names)
-        @generate_result_class ||= Class.new(self) do
-          # Include comparison and serialization modules
-          include Comparable
-
-          # Define attr_readers for all columns
-          attribute_names.each do |name|
-            attr_reader name
-          end
-
-          define_method :initialize do |attrs|
-            # Store both raw and casted versions
-            @_raw_original_attributes = attrs.dup
-            @_original_attributes = attrs.transform_keys(&:to_s).transform_values do |value|
-              type_cast_value(value)
-            end
-
-            attrs.each do |name, value|
-              casted_value = type_cast_value(value)
-              instance_variable_set("@#{name}", casted_value)
-            end
-            super() if defined?(super)
-          end
-
-          define_method :type_cast_value do |value|
-            case value
-            when /^\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d{2})?$/ # DateTime check
-              Time.parse(value)
-            when /^\d+$/ # Integer check
-              value.to_i
-            when /^\d*\.\d+$/ # Float check
-              value.to_f
-            when /^(true|false)$/i # Boolean check
-              value.downcase == "true"
-            when /^{.*}$/ # Could be PG array or JSON
-              if value.start_with?("{") && value.end_with?("}") && !value.include?('"=>') && !value.include?(": ")
-                # PostgreSQL array (simple heuristic: no "=>" or ":" suggests it's not JSON)
-                parse_pg_array(value)
-              else
-                # Attempt JSON parse
-                begin
-                  parsed = JSON.parse(value)
-                  deep_stringify_keys(parsed)
-                rescue JSON::ParserError
-                  value
-                end
-              end
-            when /^[\[{]/ # Pure JSON (arrays starting with [ or other JSON objects)
-              begin
-                parsed = JSON.parse(value)
-                deep_stringify_keys(parsed)
-              rescue JSON::ParserError
-                value
-              end
-            else
-              value
-            end
-          end
-
-          define_method :parse_pg_array do |value|
-            # Remove the curly braces
-            clean_value = value.gsub(/^{|}$/, "")
-            return [] if clean_value.empty?
-
-            # Split on comma, but not within quoted strings
-            elements = clean_value.split(/,(?=(?:[^"]*"[^"]*")*[^"]*$)/)
-
-            elements.map do |element|
-              case element
-              when /^\d+$/ # Integer
-                element.to_i
-              when /^\d*\.\d+$/ # Float
-                element.to_f
-              when /^(true|false)$/i # Boolean
-                element.downcase == "true"
-              when /^"(.*)"$/ # Quoted string
-                ::Regexp.last_match(1)
-              else
-                element
-              end
-            end
-          end
-
-          define_method :deep_symbolize_keys do |obj|
-            case obj
-            when Hash
-              obj.transform_keys(&:to_sym).transform_values { |v| deep_symbolize_keys(v) }
-            when Array
-              obj.map { |item| item.is_a?(Hash) ? deep_symbolize_keys(item) : item }
-            else
-              obj
-            end
-          end
-
-          # Nice inspect output
-          define_method :inspect do
-            attrs = attribute_names.map do |name|
-              "#{name}=#{instance_variable_get("@#{name}").inspect}"
-            end.join(" ")
-            "#<#{self.class.superclass.name} #{attrs}>"
-          end
-
-          # Hash-like access
-          define_method :[] do |key|
-            instance_variable_get("@#{key}")
-          end
-
-          define_method :fetch do |key, default = nil|
-            instance_variable_defined?("@#{key}") ? instance_variable_get("@#{key}") : default
-          end
-
-          # Comparison methods
-          define_method :<=> do |other|
-            return nil unless other.is_a?(self.class)
-
-            to_h <=> other.to_h
-          end
-
-          define_method :== do |other|
-            return false unless other.is_a?(self.class)
-
-            to_h == other.to_h
-          end
-
-          define_method :eql? do |other|
-            self == other
-          end
-
-          define_method :hash do
-            to_h.hash
-          end
-
-          # Add helper method for deep string keys
-          define_method :deep_stringify_keys do |obj|
-            case obj
-            when Hash
-              obj.transform_keys(&:to_s).transform_values { |v| deep_stringify_keys(v) }
-            when Array
-              obj.map { |item| item.is_a?(Hash) ? deep_stringify_keys(item) : item }
-            else
-              obj
-            end
-          end
-
-          # Serialization
-          define_method :to_h do
-            attribute_names.each_with_object({}) do |name, hash|
-              value = instance_variable_get("@#{name}")
-              # Ensure string keys in output
-              hash[name.to_s] = value.is_a?(Hash) ? deep_stringify_keys(value) : value
-            end
-          end
-
-          define_method :to_json do |*args|
-            to_h.to_json(*args)
-          end
-
-          # Pattern matching support (Ruby 2.7+)
-          define_method :deconstruct_keys do |keys|
-            symbolized = deep_symbolize_keys(to_h)
-            keys ? symbolized.slice(*keys) : symbolized
-          end
-
-          # Original attributes access
-          define_method :original_attributes do
-            @_original_attributes
-          end
-
-          # Raw attributes access
-          define_method :raw_original_attributes do
-            @_raw_original_attributes
-          end
-
-          # ActiveModel-like changes tracking
-          define_method :changed? do
-            to_h != @_original_attributes
-          end
-
-          define_method :changes do
-            to_h.each_with_object({}) do |(key, value), changes|
-              original = @_original_attributes[key]
-              changes[key] = [original, value] if original != value
-            end
-          end
-        end
-      end
-    end
-  end
-end