calculable_attrs 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0b5dd4bb3612fe4d97e9abf8c246d1e2e0fc540
-  data.tar.gz: c1f98f2e019eff2f6caa8b2a973f432a991b1512
+  metadata.gz: 29b013d46b1eda78f5b0032bb59662a40ea920fc
+  data.tar.gz: 4410bf96fc63ce202ecfb1e40084078adddc9565
 SHA512:
-  metadata.gz: 531805fd07f189896eed424f7613469fc3c7b16cd36f79997fbe7624bcec6551edd0aa6cf7430d232e755d5663a7c5f69946a6df7a1167df29128bd90e4f748f
-  data.tar.gz: 19a1fd7a6a42b6047a852e7bb746324708b5e733f5b1dc88049f61dc99026ae1bd3192cd8a79294931defdefec2e6664cfe97c04baff3a72dde8e431f86f832d
+  metadata.gz: d3c8a9d3e4893577e94cdd16157f92b7ec841da83eff1f773fb7e661412ea18a44a7238c281f4000cd54cb16f068f9c29f04635a5129a68ceb91ca25bf2d350e
+  data.tar.gz: 50e135f1ce8bbfff3171781e038987b265b90623e6d97602ffd0b505f0182e65cfab67094b517217ec876e689531f72d02867a25f4b0044eb46901b46b7f38d7

data/lib/calculable_attrs/active_record/relation.rb

@@ -42,80 +42,79 @@ module CalculableAttrs::ActiveRecord::Relation
       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, sope| sope.calculate }
-      put_calcaulated_values(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)
     end
 
     @records
   end
 
-  def collect_models_calculable_attrs(models_calculable_scopes, klass, attrs_to_calcualte)
-    attrs_to_calcualte = [attrs_to_calcualte] unless attrs_to_calcualte.is_a?(Array)
+  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_calcualte.each do |attrs_to_calcualte_item|
+    attrs_to_calculate.each do |attrs_to_calculate_item|
 
-      case attrs_to_calcualte_item
+      case attrs_to_calculate_item
       when Symbol
-        if klass.reflect_on_association(attrs_to_calcualte_item)
-          collect_association_calculable_attrs(models_calculable_scopes, klass, attrs_to_calcualte_item, true)
+        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_calcualte_item)
+          scope.add_attr(attrs_to_calculate_item)
         end
       when true
         scope.add_all_attrs
       when Hash
-        attrs_to_calcualte_item.each do |association_name, association_attrs_to_calcualte|
-          collect_association_calculable_attrs(models_calculable_scopes, klass, association_name, association_attrs_to_calcualte)
+        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
   end
 
-  def collect_association_calculable_attrs(models_calculable_scopes, klass, assocaition_name, association_attrs_to_calcualte)
-    assocaition = klass.reflect_on_association(assocaition_name)
-    if assocaition
-      collect_models_calculable_attrs(models_calculable_scopes, assocaition.klass, association_attrs_to_calcualte)
+  def collect_association_calculable_attrs(models_calculable_scopes, klass, association_name, association_attrs_to_calculate)
+    association = klass.reflect_on_association(association_name)
+    if association
+      collect_models_calculable_attrs(models_calculable_scopes, association.klass, association_attrs_to_calculate)
     else
-      p "CALCUALBLE_ATTRS: WAINING: Model #{ klass.name } does't have association attribute #{ assocaition_name }."
+      p "CALCULABLE_ATTRS: WAINING: Model #{ klass.name } doesn't have association attribute #{ association_name }."
     end
   end
 
   def collect_models_ids(models_calculable_scopes, records, attrs_to_calculate)
-    itereate_scoped_records_recursively(models_calculable_scopes, records, attrs_to_calculate) do |scope, record|
+    iterate_scoped_records_recursively(models_calculable_scopes, records, attrs_to_calculate) do |scope, record|
       scope.add_id(record.id)
     end
   end
 
 
-  def put_calcaulated_values(models_calculable_scopes, records, attrs_to_calculate)
-    itereate_scoped_records_recursively(models_calculable_scopes, records, attrs_to_calculate) do |scope, record|
-      record.calculable_attrs_values = scope.calcualted_attrs_values(record.id)
+  def put_calculated_values(models_calculable_scopes, records, attrs_to_calculate)
+    iterate_scoped_records_recursively(models_calculable_scopes, records, attrs_to_calculate) do |scope, record|
+      record.calculable_attrs_values = scope.calculated_attrs_values(record.id)
     end
   end
 
-  def itereate_scoped_records_recursively(models_calculable_scopes, records, attrs_to_calculate, &block)
-    itereate_records_recursively(records, attrs_to_calculate) do |record|
+  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]
       block.call(scope, record) if scope
     end
   end
 
-  def itereate_records_recursively(records, attrs_to_calculate, &block)
-    attrs_to_calcualte = [attrs_to_calcualte] unless attrs_to_calcualte.is_a?(Array)
+  def iterate_records_recursively(records, attrs_to_calculate, &block)
     records = [records] unless records.is_a?(Array)
 
     records.each do |record|
       block.call(record)
 
       attrs_to_calculate.select {|item| item.is_a?(Hash)}.each do |hash|
-        hash.each do |assocaition_name, assocaition_attributes|
-          if record.respond_to?(assocaition_name)
-            associated_records = record.send(assocaition_name)
+        hash.each do |association_name, association_attributes|
+          if record.respond_to?(association_name)
+            associated_records = record.send(association_name)
             associated_records = associated_records.respond_to?(:to_a) ? associated_records.to_a : associated_records
-            itereate_records_recursively(associated_records, attrs_to_calculate, &block)
+            iterate_records_recursively(associated_records, attrs_to_calculate, &block)
           end
         end
       end
     end
   end
-end
+end

data/lib/calculable_attrs/calculator.rb

@@ -18,7 +18,7 @@ class CalculableAttrs::Calculator
   end
 
   def calculate(attrs, id)
-    if(id.is_a?(Array))
+    if id.is_a?(Array)
       calculate_many(attrs, id)
     else
       calculate_one(attrs, id)
@@ -28,12 +28,12 @@ class CalculableAttrs::Calculator
   def calculate_many(attrs, ids)
     query = base_query(attrs, ids).select("#{ @foreign_key } AS #{ CALCULABLE_FOREIGN_KEY }").group(@foreign_key)
     records = query.load
-    noramlize_many_records_result(ids, attrs, records)
+    normalize_many_records_result(ids, attrs, records)
   end
 
   def calculate_one(attrs, id)
     record = base_query(attrs, id).load.first
-    noramlize_one_record_result(attrs, record)
+    normalize_one_record_result(attrs, record)
   end
 
   def calculate_all(id)
@@ -51,10 +51,10 @@ class CalculableAttrs::Calculator
         @formulas[name] = value[0]
         @defaults[name] = value[1]
       else
-        raise "CALCUALBEL_ATTRS: Invalid attribute array for  #{ name }. Expected ['formula', default_value]"
+        raise "CALCULABLE_ATTRS: Invalid attribute array for  #{ name }. Expected ['formula', default_value]"
       end
     else
-      raise "CALCUALBEL_ATTRS: Invalid attribute value for  #{ name }"
+      raise "CALCULABLE_ATTRS: Invalid attribute value for  #{ name }"
     end
   end
 
@@ -62,19 +62,19 @@ class CalculableAttrs::Calculator
     @relation.call.select(build_select(attrs)).where( @foreign_key => id)
   end
 
-  def noramlize_many_records_result(ids, attrs, records)
+  def normalize_many_records_result(ids, attrs, records)
     normalized = {}
     records.each do |row|
       id = row[CALCULABLE_FOREIGN_KEY].to_i
-      normalized[id] = noramlize_one_record_result(attrs, row)
+      normalized[id] = normalize_one_record_result(attrs, row)
     end
     ids.each  do |id|
-      normalized[id] ||= noramlize_one_record_result(attrs, nil)
+      normalized[id] ||= normalize_one_record_result(attrs, nil)
     end
     normalized
   end
 
-  def noramlize_one_record_result(attrs, record)
+  def normalize_one_record_result(attrs, record)
     attrs.map { |a| [a, record.try(a) || ( @defaults.key?(a) ? @defaults[a] : 0)] }.to_h
   end
 
@@ -82,4 +82,4 @@ class CalculableAttrs::Calculator
   def build_select(attrs)
     attrs.map { |a| "#{ @formulas[a] } AS #{ a }" }.join(', ')
   end
-end
+end

data/lib/calculable_attrs/model_calculable_attrs_scope.rb

@@ -7,9 +7,9 @@ class CalculableAttrs::ModelCalculableAttrsScope
     @ids = []
   end
 
-  def add_attr(attrribute)
-    attrribute = attrribute.to_sym
-    @attrs.push(attrribute) unless @attrs.include?(attrribute)
+  def add_attr(attribute)
+    attribute = attribute.to_sym
+    @attrs.push(attribute) unless @attrs.include?(attribute)
   end
 
   def add_all_attrs
@@ -26,33 +26,33 @@ class CalculableAttrs::ModelCalculableAttrsScope
 
   def calculate
     @calculable_attrs_values = nil
-    calculators_to_use.each do |calulator|
-      calcualted_values = calulator.calculate_many(attrs | @attrs, ids)
-      merge_calculated_values(calcualted_values)
+    calculators_to_use.each do |calculator|
+      calculated_values = calculator.calculate_many(attrs | @attrs, ids)
+      merge_calculated_values(calculated_values)
     end
   end
 
-  def calcualted_attrs_values(id)
+  def calculated_attrs_values(id)
     @calculable_attrs_values[id.to_i]
   end
 
 
   private
 
-  def merge_calculated_values(calcualted_values)
+  def merge_calculated_values(calculated_values)
     if @calculable_attrs_values
-      calcualted_values.each {|id,values| @calculable_attrs_values[id].merge!(calcualted_values[id]) }
+      calculated_values.each {|id, values| @calculable_attrs_values[id].merge!(calculated_values[id]) }
     else
-      @calculable_attrs_values = calcualted_values
+      @calculable_attrs_values = calculated_values
     end
   end
 
   def calculators_to_use
     calculators_to_use = []
     @attrs.each do |attribute|
-      calulator = @model.calculable_attrs_calculators[attribute]
-      calculators_to_use.push(calulator) unless calculators_to_use.include?(calulator)
+      calculator = @model.calculable_attrs_calculators[attribute]
+      calculators_to_use.push(calculator) unless calculators_to_use.include?(calculator)
     end
     calculators_to_use
   end
-end
+end

data/lib/calculable_attrs/version.rb

@@ -1,3 +1,3 @@
 module CalculableAttrs
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: calculable_attrs
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Dmitry Sharkov
@@ -28,14 +28,14 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
@@ -70,19 +70,19 @@ dependencies:
   name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: |2
       Imagine you an Account model which has many transactions.
-      calculable_attrs gem allows you to define Accoutn#blalace and SUM(transactions.amount) directrly in your Account model.
+      calculable_attrs gem allows you to define Account#blalace and SUM(transactions.amount) directly in your Account model.
       And solves n+1 problem for you in an elegant way.
 email:
 - dmitry.sharkov@gmail.com