kweerie 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28a36928eab4b34cff2a0fbdcf7e4614264f501d7e75f0b08ae6c28f151cd641
-  data.tar.gz: 8f0332f34bf28dc46c33cb671bb03e95330d08a9e15eed735be6ca64964d10db
+  metadata.gz: f11c69ed8356612d3a1df5dfb98b4751061db706908f7b2efe6ace375f53c73e
+  data.tar.gz: b33644c5b64bb941bf88bf6207ced00706e84a1c83c2b60fa9c7dddc680dd0fe
 SHA512:
-  metadata.gz: 026f1786bbb42976b0461951005f448e7b2169b6962a5f06737a9cc2fbdd99af93c84ea5d5ee277067788e349c6e73df98096154bebea79f6a2b9b5f450f0234
-  data.tar.gz: d3e8e06dcaa23ea12f205e623861ba08cd16b2be877e9008571efbe38a6f6a536efb717ed45ca977102c9b2fa2cf5ebec737a31faf6e8e4accf4e93f51412395
+  metadata.gz: 9f05d4db4050c840ac87c60b60e44dd27413fc3fee685cd81fd5320d6bb9d37f01ee5a1f29691989f1ec4f3de2a566d1a8fd0057696b54982bdd012170a0ea2b
+  data.tar.gz: 11560ae4acff559585472f020d29d0367ca431cd3f9398cfb75aa1e27b6a08057e8f6b1d5270b7f6ef043551c9f15d3b95434d586400390c512c75b410dc7661

data/README.md

@@ -53,6 +53,132 @@ results = UserSearch.with(
 # => [{"id"=>9981, "name"=>"John Doe", "email"=>"johndoe@example.com"}]
 ```
 
+### Object Mapping
+
+While `Kweerie::Base` returns plain hashes, you can use `Kweerie::BaseObjects` to get typed Ruby objects with proper attribute methods:
+
+```ruby
+class UserSearch < Kweerie::BaseObjects
+  bind :name, as: '$1'
+  bind :created_at, as: '$2'
+end
+
+# Returns array of objects instead of hashes
+users = UserSearch.with(
+  name: 'Claude',
+  created_at: '2024-01-01'
+)
+
+user = users.first
+user.name         # => "Claude"
+user.created_at   # => 2024-01-01 00:00:00 +0000 (Time object)
+```
+
+### Automatic Type Casting
+
+BaseObjects automatically casts common PostgreSQL types to their Ruby equivalents:
+
+```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"
+```
+
+### Pattern Matching Support
+
+BaseObjects support Ruby's pattern matching syntax:
+
+```ruby
+case user
+in { name:, metadata: { role: "admin" } }
+  puts "Admin user: #{name}"
+in { name:, metadata: { role: "user" } }
+  puts "Regular user: #{name}"
+end
+
+# Nested pattern matching
+case user
+in { metadata: { preferences: { theme: "dark" } } }
+  puts "Dark theme user"
+end
+```
+
+### Object Interface
+
+BaseObjects provide several useful methods:
+
+```ruby
+# Hash-like access
+user[:name]                    # => "Claude"
+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
+
+# 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
+```
+
+## PostgreSQL Array Support
+
+BaseObjects handles PostgreSQL arrays by converting them to Ruby arrays with proper type casting:
+
+```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
+end
+
+# In your query
+user = UserSearch.with(name: 'Claude').first
+
+user.preferred_ordering  # => [1, 3, 2]
+user.tags                 # => ["ruby", "rails"]
+user.scores              # => [98.5, 87.2, 92.0]
+```
+
+## Performance Considerations
+
+BaseObjects 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
+- Type casting happens once during initialization
+- No method_missing or dynamic method definition per instance
+- Efficient pattern matching support
+
+For queries where you don't need the object interface, use `Kweerie::Base` instead for slightly better performance.
+
 ### Rails Generator
 
 If you're using Rails, you can use the generator to create new query files:

data/lib/generators/kweerie/kweerie_generator.rb

@@ -32,11 +32,11 @@ class KweerieGenerator < Rails::Generators::NamedBase
       -- Write your SQL query here
       -- Available parameters: #{parameters.map { |p| "$#{parameters.index(p) + 1} (#{p})" }.join(", ")}
 
-      SELECT
+      -- SELECT
         -- your columns here
-      FROM
+      -- FROM
         -- your tables here
-      WHERE
+      -- WHERE
         -- your conditions here
     SQL
   end

data/lib/kweerie/base_objects.rb

@@ -0,0 +1,202 @@
+# 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 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 :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 :initialize do |attrs|
+            # Store original attributes with the same type casting
+            @_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
+          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.name || "Record"} #{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
+
+          # 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

data/lib/kweerie/version.rb

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

data/lib/kweerie.rb

@@ -26,3 +26,4 @@ end
 
 require_relative "kweerie/configuration"
 require_relative "kweerie/base"
+require_relative "kweerie/base_objects"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kweerie
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Toby
@@ -11,33 +11,33 @@ cert_chain: []
 date: 2024-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: pg
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -67,6 +67,7 @@ files:
 - lib/generators/kweerie/kweerie_generator.rb
 - lib/kweerie.rb
 - lib/kweerie/base.rb
+- lib/kweerie/base_objects.rb
 - lib/kweerie/configuration.rb
 - lib/kweerie/version.rb
 - sig/kweerie.rbs