occams-record 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 22118121c55c3eeb9cc211b6871f34d6ad9d94a5
-  data.tar.gz: bad217602878815157dba40a38cfd52ac58fdd6d
+  metadata.gz: 704aeee89a29c6faaf5044e3eba09efdffa64bbd
+  data.tar.gz: 70415bb9a9a32a11dca5d1a25d4eff04ffc19571
 SHA512:
-  metadata.gz: 1da29e4dad1adabf559e808b691c9281d299abde694999ae4de00a8502ebfe61b9dcde370d84ddea754744fcc32580b644759a48a37b9de3ca521bca4a9d6836
-  data.tar.gz: 8daa621bd1b62c34750afb1075f9f868bd030b313b8deb947011527464e97941a50b83b64a1d0e1ac46225b34dc8a6eabae2ed719f976db249697efb32f14986
+  metadata.gz: 487a7e553edb7f30e84ec4071d01596d36cf1232aa1016265bdf4b589f5a2118cfbcffaff0b2508927811638e6b6f4af5a51bd52726ab46f1b8297eb0db8dcda
+  data.tar.gz: 8f3f6d2850eb49dabefc1dd95221f19ec56ec70c00c067b5ddf79d0dd96b87bcab854ed99fc041502c598f6df267dd3e657e908f685f06d5a660aed44657869b

data/README.md

@@ -138,6 +138,36 @@ widgets[0].orders[0].description
 => "O839SJZ98B 1/8/2017"
 ```
 
+## Raw SQL queries
+
+If you have a complicated query to run, you may drop down to hand-written SQL while still taking advantage of eager loading and variable escaping. (Note the slightly different syntax for binding variables.)
+
+NOTE this feature is quite new and might have some bugs. Issues and Pull Requests welcome.
+
+```ruby
+widgets = OccamsRecord.sql(%(
+  SELECT * FROM widgets
+  WHERE category_id = %{cat_id}
+), {
+  cat_id: 5
+}).run
+```
+
+To perform eager loading, you must specify the base model. NOTE some database adapters, notably SQLite, require you to always specify the model.
+
+```ruby
+widgets = OccamsRecord.
+  sql(%(
+    SELECT * FROM widgets
+    WHERE category_id IN (%{cat_ids})
+  ), {
+    cat_ids: [5, 10]
+  }).
+  model(Widget).
+  eager_load(:category).
+  run
+```
+
 ## Unsupported features
 
 The following `ActiveRecord` are not supported, and I have no plans to do so. However, I'd be glad to accept pull requests.

data/lib/occams-record.rb

@@ -2,5 +2,6 @@ require 'active_record'
 require 'occams-record/version'
 require 'occams-record/merge'
 require 'occams-record/eager_loaders'
-require 'occams-record/result_row'
+require 'occams-record/results'
 require 'occams-record/query'
+require 'occams-record/raw_query'

data/lib/occams-record/batches.rb

@@ -50,7 +50,8 @@ module OccamsRecord
     #
     # Returns an Enumerator that yields batches of records, of size "of".
     # NOTE ActiveRecord 5+ provides the 'in_batches' method to do something
-    # similiar, although 4.2 does not. Also it does not respect ORDER BY.
+    # similiar, although 4.2 does not. Also it does not respect ORDER BY,
+    # whereas this does.
     #
     # @param of [Integer] batch size
     # @return [Enumerator] yields batches

data/lib/occams-record/eager_loaders.rb

@@ -10,19 +10,54 @@ module OccamsRecord
     autoload :HasMany, 'occams-record/eager_loaders/has_many'
     autoload :Habtm, 'occams-record/eager_loaders/habtm'
 
-    # Fetch the appropriate eager loader for the given association type.
-    def self.fetch!(ref)
-      case ref.macro
-      when :belongs_to
-        ref.options[:polymorphic] ? PolymorphicBelongsTo : BelongsTo
-      when :has_one
-        HasOne
-      when :has_many
-        HasMany
-      when :has_and_belongs_to_many
-        EagerLoaders::Habtm
-      else
-        raise "Unsupported association type `#{macro}`"
+    # Methods for adding eager loading to a query.
+    module Builder
+      #
+      # Specify an association to be eager-loaded. You may optionally pass a block that accepts a scope
+      # which you may modify to customize the query. For maximum memory savings, always `select` only
+      # the colums you actually need.
+      #
+      # @param assoc [Symbol] name of association
+      # @param scope [Proc] a scope to apply to the query (optional)
+      # @param select [String] a custom SELECT statement, minus the SELECT (optional)
+      # @param use [Array<Module>] optional Module to include in the result class (single or array)
+      # @param eval_block [Proc] a block where you may perform eager loading on *this* association (optional)
+      # @return [OccamsRecord::Query] returns self
+      #
+      def eager_load(assoc, scope = nil, select: nil, use: nil, &eval_block)
+        ref = @model ? @model.reflections[assoc.to_s] : nil
+        raise "OccamsRecord: No assocation `:#{assoc}` on `#{@model&.name || '<model missing>'}`" if ref.nil?
+        scope ||= -> { self.select select } if select
+        @eager_loaders << eager_loader_for_association(ref).new(ref, scope, use, &eval_block)
+        self
+      end
+
+      private
+
+      # Run all defined eager loaders into the given result rows
+      def eager_load!(rows)
+        @eager_loaders.each { |loader|
+          loader.query(rows) { |scope|
+            assoc_rows = Query.new(scope, use: loader.use, query_logger: @query_logger, &loader.eval_block).run
+            loader.merge! assoc_rows, rows
+          }
+        }
+      end
+
+      # Fetch the appropriate eager loader for the given association type.
+      def eager_loader_for_association(ref)
+        case ref.macro
+        when :belongs_to
+          ref.options[:polymorphic] ? PolymorphicBelongsTo : BelongsTo
+        when :has_one
+          HasOne
+        when :has_many
+          HasMany
+        when :has_and_belongs_to_many
+          EagerLoaders::Habtm
+        else
+          raise "Unsupported association type `#{macro}`"
+        end
       end
     end
   end

data/lib/occams-record/eager_loaders/base.rb

@@ -25,7 +25,7 @@ module OccamsRecord
       #
       # Yield one or more ActiveRecord::Relation objects to a given block.
       #
-      # @param rows [Array<OccamsRecord::ResultRow>] Array of rows used to calculate the query.
+      # @param rows [Array<OccamsRecord::Results::Row>] Array of rows used to calculate the query.
       #
       def query(rows)
         raise 'Not Implemented'
@@ -34,8 +34,8 @@ module OccamsRecord
       #
       # Merges the associated rows into the parent rows.
       #
-      # @param assoc_rows [Array<OccamsRecord::ResultRow>]
-      # @param rows [Array<OccamsRecord::ResultRow>]
+      # @param assoc_rows [Array<OccamsRecord::Results::Row>]
+      # @param rows [Array<OccamsRecord::Results::Row>]
       #
       def merge!(assoc_rows, rows)
         raise 'Not Implemented'

data/lib/occams-record/eager_loaders/belongs_to.rb

@@ -5,7 +5,7 @@ module OccamsRecord
       #
       # Yield one or more ActiveRecord::Relation objects to a given block.
       #
-      # @param rows [Array<OccamsRecord::ResultRow>] Array of rows used to calculate the query.
+      # @param rows [Array<OccamsRecord::Results::Row>] Array of rows used to calculate the query.
       #
       def query(rows)
         ids = rows.map { |r| r.send @ref.foreign_key }.compact.uniq
@@ -15,8 +15,8 @@ module OccamsRecord
       #
       # Merge the association rows into the given rows.
       #
-      # @param assoc_rows [Array<OccamsRecord::ResultRow>] rows loaded from the association
-      # @param rows [Array<OccamsRecord::ResultRow>] rows loaded from the main model
+      # @param assoc_rows [Array<OccamsRecord::Results::Row>] rows loaded from the association
+      # @param rows [Array<OccamsRecord::Results::Row>] rows loaded from the main model
       #
       def merge!(assoc_rows, rows)
         Merge.new(rows, name).

data/lib/occams-record/eager_loaders/habtm.rb

@@ -5,7 +5,7 @@ module OccamsRecord
       #
       # Yield one or more ActiveRecord::Relation objects to a given block.
       #
-      # @param rows [Array<OccamsRecord::ResultRow>] Array of rows used to calculate the query.
+      # @param rows [Array<OccamsRecord::Results::Row>] Array of rows used to calculate the query.
       #
       def query(rows)
         assoc_ids = join_rows(rows).map { |row| row[1] }.compact.uniq
@@ -15,8 +15,8 @@ module OccamsRecord
       #
       # Merge the association rows into the given rows.
       #
-      # @param assoc_rows [Array<OccamsRecord::ResultRow>] rows loaded from the association
-      # @param rows [Array<OccamsRecord::ResultRow>] rows loaded from the main model
+      # @param assoc_rows [Array<OccamsRecord::Results::Row>] rows loaded from the association
+      # @param rows [Array<OccamsRecord::Results::Row>] rows loaded from the main model
       #
       def merge!(assoc_rows, rows)
         joins_by_id = join_rows(rows).reduce({}) { |a, join|
@@ -46,7 +46,7 @@ module OccamsRecord
       #
       # Fetches (and caches) an array of rows from the join table. The rows are [fkey, assoc_fkey].
       #
-      # @param rows [Array<OccamsRecord::ResultRow>]
+      # @param rows [Array<OccamsRecord::Results::Row>]
       # @return [Array<Array<String>>]
       #
       def join_rows(rows)

data/lib/occams-record/eager_loaders/has_many.rb

@@ -5,8 +5,8 @@ module OccamsRecord
       #
       # Merge the association rows into the given rows.
       #
-      # @param assoc_rows [Array<OccamsRecord::ResultRow>] rows loaded from the association
-      # @param rows [Array<OccamsRecord::ResultRow>] rows loaded from the main model
+      # @param assoc_rows [Array<OccamsRecord::Results::Row>] rows loaded from the association
+      # @param rows [Array<OccamsRecord::Results::Row>] rows loaded from the main model
       #
       def merge!(assoc_rows, rows)
         Merge.new(rows, name).

data/lib/occams-record/eager_loaders/has_one.rb

@@ -5,7 +5,7 @@ module OccamsRecord
       #
       # Yield one or more ActiveRecord::Relation objects to a given block.
       #
-      # @param rows [Array<OccamsRecord::ResultRow>] Array of rows used to calculate the query.
+      # @param rows [Array<OccamsRecord::Results::Row>] Array of rows used to calculate the query.
       #
       def query(rows)
         return if rows.empty?
@@ -18,8 +18,8 @@ module OccamsRecord
       #
       # Merge the association rows into the given rows.
       #
-      # @param assoc_rows [Array<OccamsRecord::ResultRow>] rows loaded from the association
-      # @param rows [Array<OccamsRecord::ResultRow>] rows loaded from the main model
+      # @param assoc_rows [Array<OccamsRecord::Results::Row>] rows loaded from the association
+      # @param rows [Array<OccamsRecord::Results::Row>] rows loaded from the main model
       #
       def merge!(assoc_rows, rows)
         Merge.new(rows, name).

data/lib/occams-record/eager_loaders/polymorphic_belongs_to.rb

@@ -25,7 +25,7 @@ module OccamsRecord
       #
       # Yield ActiveRecord::Relations to the given block, one for every "type" represented in the given rows.
       #
-      # @param rows [Array<OccamsRecord::ResultRow>] Array of rows used to calculate the query.
+      # @param rows [Array<OccamsRecord::Results::Row>] Array of rows used to calculate the query.
       #
       def query(rows)
         rows_by_type = rows.group_by(&@foreign_type)

data/lib/occams-record/merge.rb

@@ -6,13 +6,13 @@ module OccamsRecord
   # After initializing, perform a specific type of merge by calling the appropriate *! method.
   #
   class Merge
-    # @return [Array<OccamsRecord::ResultRow>] the rows into which associated rows will be merged
+    # @return [Array<OccamsRecord::Results::Row>] the rows into which associated rows will be merged
     attr_reader :target_rows
 
     #
     # Initialize a new Merge operation.
     #
-    # @param target_rows [Array<OccamsRecord::ResultRow] the rows into which associated rows should be merged
+    # @param target_rows [Array<OccamsRecord::Results::Row] the rows into which associated rows should be merged
     # @param assoc_name [String|Symbol] name of the attribute where associated rows will be put
     #
     def initialize(target_rows, assoc_name)
@@ -24,7 +24,7 @@ module OccamsRecord
     # Merge a single assoc_row into each target_rows (or nil if one can't be found).
     # target_attr and assoc_attr are the matching keys on target_rows and assoc_rows, respectively.
     #
-    # @param assoc_rows [Array<OccamsRecord::ResultRow>] rows to merge into target_rows
+    # @param assoc_rows [Array<OccamsRecord::Results::Row>] rows to merge into target_rows
     # @param target_attr [String|Symbol] name of the matching key on the target records
     # @param assoc_attr [String] name of the matching key on the associated records
     #

data/lib/occams-record/query.rb

@@ -35,10 +35,9 @@ module OccamsRecord
     attr_reader :model
     # @return [ActiveRecord::Relation] scope for building the main SQL query
     attr_reader :scope
-    # @return [ActiveRecord::Connection]
-    attr_reader :conn
 
     include Batches
+    include EagerLoaders::Builder
 
     #
     # Initialize a new query.
@@ -53,51 +52,23 @@ module OccamsRecord
       @model = scope.klass
       @scope = scope
       @eager_loaders = eager_loaders
-      @conn = model.connection
       @use = use
       @query_logger = query_logger
       instance_eval(&eval_block) if eval_block
     end
 
-    #
-    # Specify an association to be eager-loaded. You may optionally pass a block that accepts a scope
-    # which you may modify to customize the query. For maximum memory savings, always `select` only
-    # the colums you actually need.
-    #
-    # @param assoc [Symbol] name of association
-    # @param scope [Proc] a scope to apply to the query (optional)
-    # @param select [String] a custom SELECT statement, minus the SELECT (optional)
-    # @param use [Array<Module>] optional Module to include in the result class (single or array)
-    # @param eval_block [Proc] a block where you may perform eager loading on *this* association (optional)
-    # @return [OccamsRecord::Query] returns self
-    #
-    def eager_load(assoc, scope = nil, select: nil, use: nil, &eval_block)
-      ref = model.reflections[assoc.to_s]
-      raise "OccamsRecord: No assocation `:#{assoc}` on `#{model.name}`" if ref.nil?
-      scope ||= -> { self.select select } if select
-      @eager_loaders << EagerLoaders.fetch!(ref).new(ref, scope, use, &eval_block)
-      self
-    end
-
     #
     # Run the query and return the results.
     #
-    # @return [Array<OccamsRecord::ResultRow>]
+    # @return [Array<OccamsRecord::Results::Row>]
     #
     def run
       sql = scope.to_sql
       @query_logger << sql if @query_logger
-      result = conn.exec_query sql
-      row_class = OccamsRecord.build_result_row_class(model, result.columns, result.column_types, @eager_loaders.map(&:name), modules: @use)
+      result = model.connection.exec_query sql
+      row_class = OccamsRecord::Results.klass(result.columns, result.column_types, @eager_loaders.map(&:name), model: model, modules: @use)
       rows = result.rows.map { |row| row_class.new row }
-
-      @eager_loaders.each { |loader|
-        loader.query(rows) { |scope|
-          assoc_rows = Query.new(scope, use: loader.use, query_logger: @query_logger, &loader.eval_block).run
-          loader.merge! assoc_rows, rows
-        }
-      }
-
+      eager_load! rows
       rows
     end
 

data/lib/occams-record/raw_query.rb

@@ -0,0 +1,128 @@
+module OccamsRecord
+  #
+  # Starts building a OccamsRecord::RawQuery. Pass it a raw SQL statement, optionally followed by
+  # a Hash of binds. While this doesn't offer an additional performance boost, it's a nice way to
+  # write safe, complicated SQL by hand while also supporting eager loading.
+  #
+  #   results = OccamsRecord.sql(%(
+  #     SELECT * FROM widgets
+  #     WHERE category_id = %{cat_id}
+  #   ), {
+  #     cat_id: 5
+  #   }).run
+  #
+  # If you want to do eager loading, you must first the define a model to pull the associations from.
+  # NOTE If you're using SQLite, you must *always* specify the model.
+  #
+  #   results = OccamsRecord.
+  #     sql(%(
+  #       SELECT * FROM widgets
+  #       WHERE category_id IN (%{cat_ids})
+  #     ), {
+  #       cat_ids: [5, 10]
+  #     }).
+  #     model(Widget).
+  #     eager_load(:category).
+  #     run
+  #
+  # @param sql [String] The SELECT statement to run. Binds should use the built-in Ruby "%{bind_name}" syntax.
+  # @param binds [Hash] Bind values (Symbol keys)
+  # @param use [Array<Module>] optional Module to include in the result class (single or array)
+  # @param query_logger [Array] (optional) an array into which all queries will be inserted for logging/debug purposes
+  # @return [OccamsRecord::RawQuery]
+  #
+  def self.sql(sql, binds, use: nil, query_logger: nil)
+    RawQuery.new(sql, binds, use: use, query_logger: nil)
+  end
+
+  #
+  # Represents a raw SQL query to be run and eager associations to be loaded. Use OccamsRecord.sql to create your queries
+  # instead of instantiating objects directly.
+  #
+  class RawQuery
+    # @return [String]
+    attr_reader :sql
+    # @return [Hash]
+    attr_reader :binds
+
+    include EagerLoaders::Builder
+
+    #
+    # Initialize a new query.
+    #
+    # @param sql [String] The SELECT statement to run. Binds should use the built-in Ruby "%{bind_name}" syntax.
+    # @param binds [Hash] Bind values (Symbol keys)
+    # @param use [Array<Module>] optional Module to include in the result class (single or array)
+    # @param eager_loaders [OccamsRecord::EagerLoaders::Base]
+    # @param query_logger [Array] (optional) an array into which all queries will be inserted for logging/debug purposes
+    # @param eval_block [Proc] block that will be eval'd on this instance. Can be used for eager loading. (optional)
+    #
+    def initialize(sql, binds, use: nil, eager_loaders: [], query_logger: nil)
+      @sql = sql
+      @binds = binds
+      @use = use
+      @eager_loaders = eager_loaders
+      @query_logger = query_logger
+      @model = nil
+      @conn = @model&.connection || ActiveRecord::Base.connection
+    end
+
+    #
+    # Specify the model to be used to load eager associations. Normally this would be the main table you're
+    # SELECTing from.
+    #
+    # NOTE Some database adapters, notably SQLite's, require that the model *always* be specified, even if you
+    # aren't doing eager loading.
+    #
+    # @param klass [ActiveRecord::Base]
+    # @return [OccamsRecord::RawQuery] self
+    #
+    def model(klass)
+      @model = klass
+      self
+    end
+
+    #
+    # Run the query and return the results.
+    #
+    # @return [Array<OccamsRecord::Results::Row>]
+    #
+    def run
+      result = @conn.exec_query escaped_sql
+      row_class = OccamsRecord::Results.klass(result.columns, result.column_types, @eager_loaders.map(&:name), model: @model, modules: @use)
+      rows = result.rows.map { |row| row_class.new row }
+      eager_load! rows
+      rows
+    end
+
+    alias_method :to_a, :run
+
+    #
+    # If you pass a block, each result row will be yielded to it. If you don't,
+    # an Enumerable will be returned.
+    #
+    # @return Enumerable
+    #
+    def each
+      if block_given?
+        to_a.each { |row| yield row }
+      else
+        to_a.each
+      end
+    end
+
+    private
+
+    # Returns the SQL as a String with all variables escaped
+    def escaped_sql
+      sql % binds.reduce({}) { |a, (col, val)|
+        a[col.to_sym] = if val.is_a? Array
+                          val.map { |x| @conn.quote x }.join(', ')
+                        else
+                          @conn.quote val
+                        end
+        a
+      }
+    end
+  end
+end

data/lib/occams-record/results.rb

@@ -0,0 +1,106 @@
+module OccamsRecord
+  module Results
+    # ActiveRecord's internal type casting API changes from version to version.
+    CASTER = case ActiveRecord::VERSION::MAJOR
+             when 4 then :type_cast_from_database
+             when 5 then :deserialize
+             end
+
+    #
+    # Dynamically build a class for a specific set of result rows. It inherits from OccamsRecord::Results::Row, and optionall includes
+    # a user-defined module.
+    #
+    # @param column_names [Array<String>] the column names in the result set. The order MUST match the order returned by the query.
+    # @param column_types [Hash] Column name => type from an ActiveRecord::Result
+    # @param association_names [Array<String>] names of associations that will be eager loaded into the results.
+    # @param model [ActiveRecord::Base] the AR model representing the table (it holds column & type info).
+    # @param modules [Array<Module>] (optional)
+    # @return [OccamsRecord::Results::Row] a class customized for this result set
+    #
+    def self.klass(column_names, column_types, association_names = [], model: nil, modules: nil)
+      Class.new(Results::Row) do
+        Array(modules).each { |mod| include mod } if modules
+
+        self.columns = column_names.map(&:to_s)
+        self.associations = association_names.map(&:to_s)
+        self.model_name = model ? model.name : nil
+
+        # Build getters & setters for associations. (We need setters b/c they're set AFTER the row is initialized
+        attr_accessor(*association_names)
+
+        # Build a getter for each attribute returned by the query. The values will be type converted on demand.
+        model_column_types = model ? model.attributes_builder.types : {}
+        self.columns.each_with_index do |col, idx|
+          type =
+            column_types[col] ||
+            model_column_types[col] ||
+            raise("OccamsRecord: Column `#{col}` does not exist on model `#{self.model_name}`")
+
+          case type.type
+          when :datetime
+            define_method(col) { @cast_values[idx] ||= type.send(CASTER, @raw_values[idx]).in_time_zone }
+          else
+            define_method(col) { @cast_values[idx] ||= type.send(CASTER, @raw_values[idx]) }
+          end
+        end
+      end
+    end
+
+    #
+    # Abstract class for result rows.
+    #
+    class Row
+      class << self
+        # Array of column names
+        attr_accessor :columns
+        # Array of associations names
+        attr_accessor :associations
+        # Name of Rails model
+        attr_accessor :model_name
+      end
+      self.columns = []
+      self.associations = []
+
+      #
+      # Initialize a new result row.
+      #
+      # @param raw_values [Array] array of raw values from db
+      #
+      def initialize(raw_values)
+        @raw_values = raw_values
+        @cast_values = {}
+      end
+
+      #
+      # Return row as a Hash (recursive).
+      #
+      # @param symbolize_names [Boolean] if true, make Hash keys Symbols instead of Strings
+      # @return [Hash] a Hash with String or Symbol keys
+      #
+      def to_h(symbolize_names: false)
+        hash = self.class.columns.reduce({}) { |a, col_name|
+          key = symbolize_names ? col_name.to_sym : col_name
+          a[key] = send col_name
+          a
+        }
+
+        self.class.associations.reduce(hash) { |a, assoc_name|
+          key = symbolize_names ? assoc_name.to_sym : assoc_name
+          assoc = send assoc_name
+          a[key] = if assoc.is_a? Array
+                     assoc.map { |x| x.to_h(symbolize_names: symbolize_names) }
+                   elsif assoc
+                     assoc.to_h(symbolize_names: symbolize_names)
+                   end
+          a
+        }
+      end
+
+      alias_method :to_hash, :to_h
+
+      def inspect
+        "#<OccamsRecord::Results::Row @model_name=#{self.class.model_name} @raw_values=#{@raw_values}>"
+      end
+    end
+  end
+end

data/lib/occams-record/version.rb

@@ -3,5 +3,5 @@
 #
 module OccamsRecord
   # Library version
-  VERSION = '0.7.0'.freeze
+  VERSION = '0.8.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: occams-record
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Jordan Hollinger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-05 00:00:00.000000000 Z
+date: 2017-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -49,7 +49,8 @@ files:
 - lib/occams-record/eager_loaders/polymorphic_belongs_to.rb
 - lib/occams-record/merge.rb
 - lib/occams-record/query.rb
-- lib/occams-record/result_row.rb
+- lib/occams-record/raw_query.rb
+- lib/occams-record/results.rb
 - lib/occams-record/version.rb
 homepage: https://github.com/jhollinger/occams-record
 licenses:
@@ -63,7 +64,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/occams-record/result_row.rb

@@ -1,95 +0,0 @@
-module OccamsRecord
-  # ActiveRecord's internal type casting API changes from version to version.
-  TYPE_CAST_METHOD = case ActiveRecord::VERSION::MAJOR
-                     when 4 then :type_cast_from_database
-                     when 5 then :deserialize
-                     end
-
-  #
-  # Dynamically build a class for a specific set of result rows. It inherits from OccamsRecord::ResultRow, and optionall includes
-  # a user-defined module.
-  #
-  # @param model [ActiveRecord::Base] the AR model representing the table (it holds column & type info).
-  # @param column_names [Array<String>] the column names in the result set. The order MUST match the order returned by the query.
-  # @param column_types [Hash] Column name => type from an ActiveRecord::Result
-  # @param association_names [Array<String>] names of associations that will be eager loaded into the results.
-  # @param modules [Array<Module>] (optional)
-  # @return [OccamsRecord::ResultRow] a class customized for this result set
-  #
-  def self.build_result_row_class(model, column_names, column_types, association_names, modules: nil)
-    Class.new(ResultRow) do
-      Array(modules).each { |mod| include mod } if modules
-
-      self.columns = column_names.map(&:to_s)
-      self.associations = association_names.map(&:to_s)
-      self.model_name = model.name
-
-      # Build getters & setters for associations. (We need setters b/c they're set AFTER the row is initialized
-      attr_accessor(*association_names)
-
-      # Build a getter for each attribute returned by the query. The values will be type converted on demand.
-      self.columns.each_with_index do |col, idx|
-        type =
-          column_types[col] ||
-          model.attributes_builder.types[col] ||
-          raise("OccamsRecord: Column `#{col}` does not exist on model `#{self.model_name}`")
-        define_method col do
-          @cast_values_cache[idx] ||= type.send(TYPE_CAST_METHOD, @raw_values[idx])
-        end
-      end
-    end
-  end
-
-  #
-  # Abstract class for result rows.
-  #
-  class ResultRow
-    class << self
-      # Array of column names
-      attr_accessor :columns
-      # Array of associations names
-      attr_accessor :associations
-      # Name of Rails model
-      attr_accessor :model_name
-    end
-    self.columns = []
-    self.associations = []
-
-    #
-    # Initialize a new result row.
-    #
-    # @param raw_values [Array] array of raw values from db
-    #
-    def initialize(raw_values)
-      @raw_values = raw_values
-      @cast_values_cache = {}
-    end
-
-    #
-    # Return row as a Hash (recursive).
-    #
-    # @param symbolize_names [Boolean] if true, make Hash keys Symbols instead of Strings
-    # @return [Hash] a Hash with String or Symbol keys
-    #
-    def to_h(symbolize_names: false)
-      hash = self.class.columns.reduce({}) { |a, col_name|
-        key = symbolize_names ? col_name.to_sym : col_name
-        a[key] = send col_name
-        a
-      }
-
-      self.class.associations.reduce(hash) { |a, assoc_name|
-        key = symbolize_names ? assoc_name.to_sym : assoc_name
-        assoc = send assoc_name
-        a[key] = if assoc.is_a? Array
-                   assoc.map { |x| x.to_h(symbolize_names: symbolize_names) }
-                 elsif assoc
-                   assoc.to_h(symbolize_names: symbolize_names)
-                 end
-        a
-      }
-    end
-
-    alias_method :to_hash, :to_h
-  end
-end