calculable_attrs 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2cb90fc5396803596c76b7179e003580f5325a57
-  data.tar.gz: a6d5fa763da75d215749063635f0aec3a787c5ea
+  metadata.gz: 57c06a0f4f9704dd33c80b66e571b32df767ad3d
+  data.tar.gz: 77a6b0903406d4f36c197fa0db1ae1f7fedfadf4
 SHA512:
-  metadata.gz: 8cd92421d55e7e32b2f742721851f7d2285165a5be5db5066195669e7d03bfa31e78aa767a4b224ade25939ed3b0b48491d7ddad984a35d1bfe45a280206eeed
-  data.tar.gz: 07fc087b96843bc8be86ff3053a1f06226c2806a86b721a1722e1fb790ecdeba34917b236ac2a0ca998ff298f0527f0a3217e643542ded97a78870ce4e9aca7b
+  metadata.gz: ebbfb7711a299a2b597a9ef419ee4af4bf2c1592636e30a7734063eb3811d6c20421a0137170c758f04fcb910cfff344e2c68c6b215ca247b01a4a2910a1721f
+  data.tar.gz: 6e6df74cae0281b0ed8d8d9d9e92a262106b3d813c63bce4faac7bec583fbd33d75bb38b369519c1b398fdd18753d9f3e2d1300c39c815661b4ccdcceca1b602

data/lib/calculable_attrs/active_record/querying.rb

@@ -1,3 +1,3 @@
 module CalculableAttrs::ActiveRecord::Querying
-   delegate :calculate_attrs, to: :all
+   delegate :calculate_attrs, :includes_calculable_attrs, :joins_calculable_attrs,  to: :all
 end

data/lib/calculable_attrs/active_record/relation.rb

@@ -1,25 +1,48 @@
 module CalculableAttrs::ActiveRecord::Relation
-  def calculate_attrs(*attrs)
-    spawn.calculate_attrs!(*attrs)
-  end
+  JOINED_RELATION_NAME = 'calculated_attrs'
 
-  def calculate_attrs!(*attrs)
-    attrs.reject!(&:blank?)
-    attrs.flatten!
-
-    attrs = [true] if attrs.empty?
+  def includes_calculable_attrs(*attrs)
+    spawn.includes_calculable_attrs!(*attrs)
+  end
+  alias_method :calculate_attrs, :includes_calculable_attrs
 
-    self.calculate_attrs_values |= attrs
+  def includes_calculable_attrs!(*attrs)
+    set_calculable_attrs_included(refine_calculable_attrs(attrs))
     self
   end
+  alias_method :calculate_attrs!, :includes_calculable_attrs!
 
-  def calculate_attrs_values
-    @values[:calculate_attrs] || []
+  def joins_calculable_attrs(*attrs)
+    spawn.joins_calculable_attrs!(*attrs)
   end
 
-  def calculate_attrs_values=(values)
-    raise ImmutableRelation if @loaded
-    @values[:calculate_attrs] = values
+  def joins_calculable_attrs!(*attrs)
+    set_calculable_attrs_joined(refine_calculable_attrs(attrs))
+
+    scope = CalculableAttrs::ModelCalculableAttrsScope.new(klass)
+    scope.add_attrs(calculable_attrs_joined)
+    _select!("#{ klass.table_name }.*")
+    scope.calculators_to_use.each_with_index do |calcualtor, index|
+      joined_relation_name = '__' + JOINED_RELATION_NAME + '_' + index.to_s + '__'
+
+      attrs_to_calculate = scope.attrs && calcualtor.attrs
+      left_join_sql =
+<<-sql
+LEFT JOIN ( #{ calcualtor.query_with_grouping(attrs_to_calculate, nil).to_sql })
+AS #{ joined_relation_name }
+ON #{ joined_relation_name }.#{ calcualtor.calculable_foreign_key } = #{ klass.table_name }.id
+sql
+
+      calculable_values_sql = attrs_to_calculate.map do |attr|
+        attr_name = "#{ klass.name.underscore }_#{ attr }"
+        left_join_sql.sub!(" AS #{ attr }", " AS #{ attr_name }")
+        klass.send(:sanitize_sql, ["COALESCE(#{ joined_relation_name }.#{ attr_name }, ?) AS #{ attr_name }", calcualtor.default(attr)])
+      end.join(',')
+
+      joins!(left_join_sql)
+      _select!(calculable_values_sql)
+    end
+    self
   end
 
 
@@ -36,36 +59,68 @@ module CalculableAttrs::ActiveRecord::Relation
 
   private
 
+  def refine_calculable_attrs(attrs)
+    attrs.reject!(&:blank?)
+    attrs.flatten!
+    attrs = [true] if attrs.empty?
+    attrs
+  end
+
+  def calculable_attrs_joined
+    @values[:calculable_attrs_joined] || []
+  end
+
+  def set_calculable_attrs_joined(values)
+    raise ImmutableRelation if @loaded
+    @values[:calculable_attrs_joined] = [] unless @values[:calculable_attrs_joined]
+    @values[:calculable_attrs_joined] |= values
+  end
+
+  def calculable_attrs_included
+    @values[:calculable_attrs_included] || []
+  end
+
+  def set_calculable_attrs_included(values)
+    raise ImmutableRelation if @loaded
+    @values[:calculable_attrs_included] = [] unless @values[:calculable_attrs_included]
+    @values[:calculable_attrs_included] |= values
+  end
+
   def append_calculable_attrs
-    unless calculate_attrs_values.empty?
-      models_calculable_scopes= {}
-      collect_models_calculable_attrs(models_calculable_scopes, klass, calculate_attrs_values)
-      models_calculable_scopes = models_calculable_scopes.select { |model, scope| scope.has_attrs }
-      collect_models_ids(models_calculable_scopes, @records, calculate_attrs_values)
-      models_calculable_scopes.each { |model, scope| scope.calculate }
-      put_calculated_values(models_calculable_scopes, @records, calculate_attrs_values)
+    unless calculable_attrs_included.empty?
+      attrs = calculable_attrs_included - calculable_attrs_joined
+      models_calculable_scopes = collect_calculable_scopes(attrs)
+      collect_models_ids(models_calculable_scopes, @records, attrs)
+      models_calculable_scopes.values.each { |scope| scope.calculate }
+      put_calculated_values(models_calculable_scopes, @records, attrs)
+      put_joined_calculated_values(@records)
     end
 
     @records
   end
 
+  def collect_calculable_scopes(attrs)
+    models_calculable_scopes= {}
+    collect_models_calculable_attrs(models_calculable_scopes, klass, attrs)
+    models_calculable_scopes.select { |model, scope| scope.has_attrs }
+  end
+
   def collect_models_calculable_attrs(models_calculable_scopes, klass, attrs_to_calculate)
     attrs_to_calculate = [attrs_to_calculate] unless attrs_to_calculate.is_a?(Array)
     scope = (models_calculable_scopes[klass] ||= CalculableAttrs::ModelCalculableAttrsScope.new(klass))
     attrs_to_calculate.each do |attrs_to_calculate_item|
-
-    case attrs_to_calculate_item
-      when Symbol
-        if klass.reflect_on_association(attrs_to_calculate_item)
-          collect_association_calculable_attrs(models_calculable_scopes, klass, attrs_to_calculate_item, true)
-        else
-          scope.add_attr(attrs_to_calculate_item)
-        end
-      when true
-        scope.add_all_attrs
-      when Hash
-        attrs_to_calculate_item.each do |association_name, association_attrs_to_calculate|
-          collect_association_calculable_attrs(models_calculable_scopes, klass, association_name, association_attrs_to_calculate)
+      case attrs_to_calculate_item
+        when Symbol
+          if klass.reflect_on_association(attrs_to_calculate_item)
+            collect_association_calculable_attrs(models_calculable_scopes, klass, attrs_to_calculate_item, true)
+          else
+            scope.add_attr(attrs_to_calculate_item)
+          end
+        when true
+          scope.add_all_attrs
+        when Hash
+          attrs_to_calculate_item.each do |association_name, association_attrs_to_calculate|
+            collect_association_calculable_attrs(models_calculable_scopes, klass, association_name, association_attrs_to_calculate)
         end
       end
     end
@@ -93,6 +148,20 @@ module CalculableAttrs::ActiveRecord::Relation
     end
   end
 
+  def put_joined_calculated_values(records)
+    joined_attrs = calculable_attrs_joined
+    joined_attrs = klass.calculable_attrs if joined_attrs == [true]
+    unless joined_attrs.empty?
+      names_hash = joined_attrs.map {|attr| [attr, "#{ klass.name.underscore }_#{ attr }"]}.to_h
+      records.each do |record|
+        names_hash.each do |attr_name, attr_full_name|
+          value = record.send(attr_full_name)
+          record.set_calculable_attr_value(attr_name, value)
+        end
+      end
+    end
+  end
+
   def iterate_scoped_records_recursively(models_calculable_scopes, records, attrs_to_calculate, &block)
     iterate_records_recursively(records, attrs_to_calculate) do |record|
       scope = models_calculable_scopes[record.class]

data/lib/calculable_attrs/calculator.rb

@@ -1,6 +1,6 @@
 class CalculableAttrs::Calculator
   CALCULABLE_FOREIGN_KEY = '__calculable_id__'
-  attr_reader :attrs, :relation, :foreign_key
+  attr_reader :attrs, :relation, :foreign_key, :defaults
 
   def initialize(relation: nil, foreign_key: nil, attributes: nil)
     @relation = relation
@@ -25,12 +25,20 @@ class CalculableAttrs::Calculator
     end
   end
 
+  def calculable_foreign_key
+    CALCULABLE_FOREIGN_KEY
+  end
+
   def calculate_many(attrs, ids)
-    query = base_query(attrs, ids).select("#{ @foreign_key } AS #{ CALCULABLE_FOREIGN_KEY }").group(@foreign_key)
+    query = query_with_grouping(attrs, ids)
     records = query.load
     normalize_many_records_result(ids, attrs, records)
   end
 
+  def query_with_grouping(attrs, ids)
+    base_query(attrs, ids).select("#{ @foreign_key } AS #{ calculable_foreign_key }").group(@foreign_key)
+  end
+
   def calculate_one(attrs, id)
     record = base_query(attrs, id).load.first
     normalize_one_record_result(attrs, record)
@@ -45,7 +53,15 @@ class CalculableAttrs::Calculator
   end
 
   def scoped_relation(id)
-    @relation.call.where( @foreign_key => id)
+    if id
+      @relation.call.where( @foreign_key => id)
+    else
+      @relation.call
+    end
+  end
+
+  def default(attr)
+    @defaults.key?(attr) ? @defaults[attr] : 0
   end
 
   private
@@ -80,7 +96,7 @@ class CalculableAttrs::Calculator
   end
 
   def normalize_one_record_result(attrs, record)
-    attrs.map { |a| [a, record.try(a) || ( @defaults.key?(a) ? @defaults[a] : 0)] }.to_h
+    attrs.map { |a| [a, record.try(a) || default(a)] }.to_h
   end
 
 

data/lib/calculable_attrs/model_calculable_attrs_scope.rb

@@ -7,6 +7,14 @@ class CalculableAttrs::ModelCalculableAttrsScope
     @ids = []
   end
 
+  def add_attrs(attrs)
+    if attrs == true || attrs == [ true ]
+      add_all_attrs
+    else
+      attrs.each { |attr| add_attr(attr) }
+    end
+  end
+
   def add_attr(attribute)
     attribute = attribute.to_sym
     @attrs.push(attribute) unless @attrs.include?(attribute)
@@ -37,6 +45,15 @@ class CalculableAttrs::ModelCalculableAttrsScope
   end
 
 
+  def calculators_to_use
+    calculators_to_use = []
+    @attrs.each do |attribute|
+      calculator = @model.calculable_attrs_calculators[attribute]
+      calculators_to_use.push(calculator) unless calculators_to_use.include?(calculator)
+    end
+    calculators_to_use
+  end
+
   private
 
   def merge_calculated_values(calculated_values)
@@ -47,12 +64,5 @@ class CalculableAttrs::ModelCalculableAttrsScope
     end
   end
 
-  def calculators_to_use
-    calculators_to_use = []
-    @attrs.each do |attribute|
-      calculator = @model.calculable_attrs_calculators[attribute]
-      calculators_to_use.push(calculator) unless calculators_to_use.include?(calculator)
-    end
-    calculators_to_use
-  end
+
 end

data/lib/calculable_attrs/version.rb

@@ -1,3 +1,3 @@
 module CalculableAttrs
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: calculable_attrs
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Dmitry Sharkov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-26 00:00:00.000000000 Z
+date: 2014-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="