occams-record 1.0.0.rc6 → 1.0.0.rc7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 851fb48e34ce23fa35958cb72bae9ea977f21fa96694bf9ba20a1c98e706a518
-  data.tar.gz: ac548521b2303bce203a0d18ff73a4542ec68ea6cbdd9842a1b9115fd373b1b6
+SHA1:
+  metadata.gz: 964e9c20b250ab9599801912147978d7d477104d
+  data.tar.gz: 48184b52dbf038c40508bb6ab06e93399567196e
 SHA512:
-  metadata.gz: 6575024104f85f9c3565834e5cf4c012df74aa11dbe9ae9b71b6638035c4d048729cf6e543bce46cd79556ba0dbbb817509a8ffc9fc091c1ce3890ffde8579db
-  data.tar.gz: 8d6100ac2cd92fa4d36fecca233f8684cb96984a56d0322179101130f4cb9c53ba9a2d599bf868f6b69cfb4a2caa108e770d21eba6ec1e2facd3177dab5dc142
+  metadata.gz: 90243f9b079d7e94a6d474ffdee700dd1212e3066e96e2af89d662d70d7a253e85cbf1a793d9bd377b1962715205efa941a35d48f3b5d984710570f359c6cd24
+  data.tar.gz: 302edf479ab834b775394a6b1962fb0f1a707b81e4ea5e6db9d8441b5ad72e00ca5adf3c86a389f18e0923b621b425192b7eb7eb1fe5cead18c49aa3fbf2c29a

data/README.md

@@ -167,13 +167,13 @@ But that's very wasteful. Occams gives us better options: `eager_load_many` and
 ```ruby
 products = OccamsRecord.
   query(Product.all).
-  eager_load_many(:customers, {:id => :product_id}, %w(
+  eager_load_many(:customers, {:id => :product_id}, "
     SELECT DISTINCT product_id, customers.*
     FROM line_items
       INNER JOIN orders ON line_items.order_id = orders.id
       INNER JOIN customers on orders.customer_id = customers.id
     WHERE line_items.product_id IN (%{ids})
-  ), binds: {
+  ", binds: {
     # additional bind values (ids will be passed in for you)
   }).
   run
@@ -230,9 +230,9 @@ The following ActiveRecord features are not supported, and likely never will be.
 
 # Benchmarking
 
-`bundle exec rake bench` will run a suite of speed and memory benchmarks comparing Occams Record to Active Record. [You can find an example of a typical run here.](https://github.com/jhollinger/occams-record/wiki/Measurements). These are primarily used during development to prevent performance regressions. An in-memory Sqlite database is used.
+`bundle exec rake bench` will run a suite of speed and memory benchmarks comparing Occams Record to Active Record. [You can find an example of a typical run here.](https://github.com/jhollinger/occams-record/wiki/Measurements) These are primarily used during development to prevent performance regressions. An in-memory Sqlite database is used.
 
-If you run your own benchmarks, keep in mind exactly what you're measuring. For example if you're benchmarking a report written in AR vs OR, there are many constants in that measurement: the time spent in the database, the time spent sending the database results over the network, any calculations you're doing in Ruby, and the time spent building your html/json/csv/etc. So if OR is 3x fastr than AR, the total runtime of said report *won't* improve by 3x.
+If you run your own benchmarks, keep in mind exactly what you're measuring. For example if you're benchmarking a report written in AR vs OR, there are many constants in that measurement: the time spent in the database, the time spent sending the database results over the network, any calculations you're doing in Ruby, and the time spent building your html/json/csv/etc. So if OR is 3x faster than AR, the total runtime of said report *won't* improve by 3x.
 
 On the other hand, Active Record makes it *very* easy to forget to eager load associations (the N+1 query problem). Occams Record fixes that. So if your report was missing some associations you could see easily see performance improvements well over 3x.
 

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

@@ -19,7 +19,7 @@ module OccamsRecord
       # @param from [Symbol] Opposite of `as`. `assoc` is the custom name and `from` is the name of association on the ActiveRecord model.
       # @param optimizer [Symbol] Only used for `through` associations. Options are :none (load all intermediate records) | :select (load all intermediate records but only SELECT the necessary columns)
       # @yield a block where you may perform eager loading on *this* association (optional)
-      # @return [OccamsRecord::Query] returns self
+      # @return self
       #
       def eager_load(assoc, scope = nil, select: nil, use: nil, as: nil, from: nil, optimizer: :select, &builder)
         @eager_loaders.add(assoc, scope, select: select, use: use, as: as, from: from, optimizer: optimizer, &builder)
@@ -41,7 +41,6 @@ module OccamsRecord
       # @param optimizer [Symbol] Only used for `through` associations. Options are :none (load all intermediate records) | :select (load all intermediate records but only SELECT the necessary columns)
       # @return [OccamsRecord::EagerLoaders::Base]
       #
-      #
       def nest(assoc, scope = nil, select: nil, use: nil, as: nil, from: nil, optimizer: :select)
         raise ArgumentError, "OccamsRecord::EagerLoaders::Builder#nest does not accept a block!" if block_given?
         @eager_loaders.add(assoc, scope, select: select, use: use, as: as, from: from, optimizer: optimizer) ||
@@ -73,6 +72,7 @@ module OccamsRecord
       # @param model [ActiveRecord::Base] optional - ActiveRecord model that represents what you're loading. required when using Sqlite.
       # @param use [Array<Module>] optional - Ruby modules to include in the result objects (single or array)
       # @yield eager load associations nested under this one
+      # @return self
       #
       def eager_load_one(name, mapping, sql, binds: {}, model: nil, use: nil, &builder)
         @eager_loaders << EagerLoaders::AdHocOne.new(name, mapping, sql, binds: binds, model: model, use: use, &builder)
@@ -105,6 +105,7 @@ module OccamsRecord
       # @param binds [Hash] any additional binds for your query.
       # @param model [ActiveRecord::Base] optional - ActiveRecord model that represents what you're loading. required when using Sqlite.
       # @yield eager load associations nested under this one
+      # @return self
       #
       def eager_load_many(name, mapping, sql, binds: {}, model: nil, use: nil, &builder)
         @eager_loaders << EagerLoaders::AdHocMany.new(name, mapping, sql, binds: binds, model: model, use: use, &builder)

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

@@ -18,8 +18,7 @@ module OccamsRecord
       # Initialize a new eager loading context.
       #
       # @param mode [ActiveRecord::Base] the model that contains the associations that will be referenced.
-      # @param polymorphic [Boolean] When true, model is allowed to change, and it's assumed that not every loader
-      # is applicable to every model.
+      # @param polymorphic [Boolean] When true, model is allowed to change, and it's assumed that not every loader is applicable to every model.
       #
       def initialize(model = nil, polymorphic: false)
         @model, @polymorphic = model, polymorphic

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

@@ -27,6 +27,7 @@ module OccamsRecord
         @chain = chain.each_with_index.map { |x, i|
           Link.new(x.source_reflection.name, x.source_reflection.macro, x, chain[i + 1])
         }
+        @chain[-1].name = @as if @as and @chain.any?
         @loader = build_loader
       end
 

data/lib/occams-record/errors.rb

@@ -14,6 +14,11 @@ module OccamsRecord
       @record, @name = record, name
       @model_name = record.class.model_name
     end
+
+    # @return [String]
+    def to_s
+      message
+    end
   end
 
   # Exception when an unselected column is called on a result row
@@ -45,6 +50,11 @@ module OccamsRecord
       @model_name, @attrs = model_name, attrs
     end
 
+    # @return [String]
+    def to_s
+      message
+    end
+
     # @return [String]
     def message
       "#{model_name} could not be found with #{attrs}!"

data/lib/occams-record/query.rb

@@ -3,9 +3,9 @@ require 'occams-record/batches'
 module OccamsRecord
   #
   # Starts building a OccamsRecord::Query. Pass it a scope from any of ActiveRecord's query builder
-  # methods or associations. If you want to eager loaded associations, do NOT us ActiveRecord for it.
-  # Instead, use OccamsRecord::Query#eager_load. Finally, call `run` to run the query and get back an
-  # array of objects.
+  # methods or associations. If you want to eager loaded associations, do NOT use ActiveRecord for it.
+  # Instead use OccamsRecord::Query#eager_load. Finally, call `run` (or any Enumerable method) to run
+  # the query and get back an array of objects.
   #
   #  results = OccamsRecord.
   #    query(Widget.order("name")).
@@ -61,6 +61,7 @@ module OccamsRecord
     #
     # @yield [ActiveRecord::Relation] the current scope which you may modify and return
     # @return [OccamsRecord::Query]
+    #
     def query
       scope = block_given? ? yield(@scope) : @scope
       Query.new(scope, use: @use, eager_loaders: @eager_loaders, query_logger: @query_logger)
@@ -83,8 +84,11 @@ module OccamsRecord
     #   # returns ALL rows
     #   occams.run
     #
-    # @return [Array<OccamsRecord::Results::Row>]
+    # Any Enumerable method (e.g. each, to_a, map, reduce, etc.) may be used instead. Additionally,
+    # `find_each` and `find_in_batches` are available.
+    #
     # @yield [ActiveRecord::Relation] You may use this to return and run a modified relation
+    # @return [Array<OccamsRecord::Results::Row>]
     #
     def run
       sql = block_given? ? yield(scope).to_sql : scope.to_sql

data/lib/occams-record/version.rb

@@ -3,5 +3,5 @@
 #
 module OccamsRecord
   # Library version
-  VERSION = '1.0.0.rc6'.freeze
+  VERSION = '1.0.0.rc7'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: occams-record
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc6
+  version: 1.0.0.rc7
 platform: ruby
 authors:
 - Jordan Hollinger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-10 00:00:00.000000000 Z
+date: 2019-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -79,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: The missing high-efficiency query API for ActiveRecord