calculable_attrs 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 57c06a0f4f9704dd33c80b66e571b32df767ad3d
-  data.tar.gz: 77a6b0903406d4f36c197fa0db1ae1f7fedfadf4
+  metadata.gz: bc9300a7e0499492982a09b34c989978fed6c09b
+  data.tar.gz: c635f7b8e3db6594bcbd1a780c1a96738ee281f3
 SHA512:
-  metadata.gz: ebbfb7711a299a2b597a9ef419ee4af4bf2c1592636e30a7734063eb3811d6c20421a0137170c758f04fcb910cfff344e2c68c6b215ca247b01a4a2910a1721f
-  data.tar.gz: 6e6df74cae0281b0ed8d8d9d9e92a262106b3d813c63bce4faac7bec583fbd33d75bb38b369519c1b398fdd18753d9f3e2d1300c39c815661b4ccdcceca1b602
+  metadata.gz: 3405f74980918e7621336cb67c3f4d01e12dae5b9579113a3874caeb75e47871dc672502f1a351ce27a673e612dfe792cda00628cf98761b135026a91c4cffcd
+  data.tar.gz: 5aed3a55144e62bca6a0500a1de8f5f61f69aaa2096059a0911478dddc0ff7c3d97a32449169f8c9cd603a54c677ff930f1d0c273183e4f1fe7d67454d9f78a8

data/lib/calculable_attrs/active_record/relation.rb

@@ -18,30 +18,6 @@ module CalculableAttrs::ActiveRecord::Relation
 
   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
 
@@ -50,8 +26,12 @@ sql
     base.class_eval do
       alias_method :calculable_orig_exec_queries, :exec_queries
       def exec_queries
-        calculable_orig_exec_queries
-        append_calculable_attrs
+        if calculable_attrs_joined.empty?
+          calculable_orig_exec_queries
+        else
+          wrap_with_left_joins_and_exec_queries
+        end
+        apped_calculable_attrs
         @records
       end
     end
@@ -59,6 +39,14 @@ sql
 
   private
 
+
+
+  def wrap_with_left_joins_and_exec_queries
+    relation = wrap_with_calculable_joins(spawn)
+    @records = relation.send(:calculable_orig_exec_queries)
+    @loaded = true
+  end
+
   def refine_calculable_attrs(attrs)
     attrs.reject!(&:blank?)
     attrs.flatten!
@@ -86,19 +74,86 @@ sql
     @values[:calculable_attrs_included] |= values
   end
 
-  def append_calculable_attrs
+  def wrap_with_calculable_joins(relation)
+    scope = CalculableAttrs::ModelCalculableAttrsScope.new(klass)
+    scope.add_attrs(calculable_attrs_joined)
+
+    original_sql = relation.to_sql
+
+    sql_parser = CalculableAttrs::Utils::SqlParser.new(original_sql)
+    select_sql_snippets = [sql_parser.first_select_snippet]
+    where_sql_snippet = sql_parser.last_where_snippet
+    relation.reset
+
+
+    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 = "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"
+
+      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(',')
+      select_sql_snippets << calculable_values_sql
+
+      if where_sql_snippet
+        attrs_to_calculate.each do |attr|
+          original_names = [
+            "#{ klass.table_name.underscore }.#{ attr }",
+            "\"#{ klass.table_name.underscore }\".#{ attr }",
+            "#{ klass.table_name.underscore }.\"#{ attr }\"",
+            "\"#{ klass.table_name.underscore }\".\"#{ attr }\"",
+          ]
+          replacement_name = "#{ joined_relation_name }.#{ klass.name.underscore }_#{ attr }"
+          replacement = klass.send(:sanitize_sql, ["COALESCE(#{ replacement_name }, ?)", calcualtor.default(attr)])
+          original_names.each { |original_name| where_sql_snippet.gsub!(original_name, replacement) }
+        end
+      end
+
+      relation.joins!(left_join_sql)
+
+    end
+    sql_select = select_sql_snippets.join(',')
+    #relation.rewhere(where_sql_snippet) if where_sql_snippet
+    if where_sql_snippet
+      relation.where_values = nil
+      relation.where!(where_sql_snippet)
+    end
+    relation._select!(sql_select)
+    relation
+  end
+
+
+
+  def apped_calculable_attrs
+    append_included_calculable_attrs
+    append_joinded_calculable_attrs
+  end
+
+  def append_included_calculable_attrs
     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 append_joinded_calculable_attrs
+    unless calculable_attrs_joined.empty?
+      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)

data/lib/calculable_attrs/utils/sql_parser.rb

@@ -0,0 +1,91 @@
+class CalculableAttrs::Utils::SqlParser
+  def initialize(sql)
+    @sql = sql
+    @masked_sql = mask_sql(sql)
+  end
+
+  def first_select_snippet
+    match = @masked_sql.match(/SELECT (?<select>.*?) FROM/)
+    from, to = *match.offset(:select)
+    @sql[from..to-1]
+  end
+
+  def last_where_snippet
+    last_where_start_at = @masked_sql.rindex('WHERE')
+    return unless last_where_start_at
+    masted_sql_starting_with_last_where = @masked_sql[last_where_start_at..-1]
+    match = masted_sql_starting_with_last_where.match(/WHERE (?<where>.*?)( GROUP| ORDER| LIMIT| OFFSET|$)/)
+    from, to = *match.offset(:where)
+    @sql[last_where_start_at + from..last_where_start_at+to-1]
+  end
+
+
+  private
+
+  def mask_sql(sql)
+    sql = mask_strings(sql)
+    sql = mask_brackets(sql)
+    sql
+  end
+
+  def mask_strings(sql, mask='x')
+    idx = 0
+    len = sql.size
+    masked_sql = ''
+    inside_string = false
+    while idx < len
+      ch = sql[idx]
+      if ch == '\''
+        if inside_string
+          next_not_apostroph_index = sql.index(/[^']/,idx)
+          next_not_apostroph_index = len unless next_not_apostroph_index
+          apostrophs_length = next_not_apostroph_index - idx
+          idx = next_not_apostroph_index
+          masked_sql << mask * apostrophs_length
+          inside_string = !(apostrophs_length % 2 == 1)
+        else
+          inside_string = true
+          masked_sql << mask
+          idx += 1
+        end
+      else
+        if inside_string
+          masked_sql << mask
+        else
+          masked_sql << ch
+        end
+        idx += 1
+      end
+    end
+
+    masked_sql
+  end
+
+
+  def mask_brackets(sql, mask='y')
+    idx = 0
+    len = sql.size
+    masked_sql = ''
+    stack_size = 0
+    while idx < len
+      ch = sql[idx]
+      case ch
+        when '('
+          stack_size += 1
+          masked_sql << mask
+        when ')'
+          stack_size -= 1
+          masked_sql << mask
+        else
+          if stack_size > 0
+            masked_sql << mask
+          else
+            masked_sql << ch
+          end
+      end
+      idx += 1
+    end
+
+    masked_sql
+  end
+end

data/lib/calculable_attrs/version.rb

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

data/lib/calculable_attrs.rb

@@ -1,8 +1,11 @@
-module CalculableAttrs; end
+module CalculableAttrs
+  module Utils; end
+end
 
 require 'calculable_attrs/active_record'
 require 'calculable_attrs/calculator'
 require 'calculable_attrs/model_calculable_attrs_scope'
+require 'calculable_attrs/utils/sql_parser'
 
 ::ActiveRecord::Base.include(CalculableAttrs::ActiveRecord::Base)
 ::ActiveRecord::Relation.include(CalculableAttrs::ActiveRecord::Relation)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: calculable_attrs
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Dmitry Sharkov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-03 00:00:00.000000000 Z
+date: 2014-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -113,6 +113,7 @@ files:
 - lib/calculable_attrs/active_record/relation.rb
 - lib/calculable_attrs/calculator.rb
 - lib/calculable_attrs/model_calculable_attrs_scope.rb
+- lib/calculable_attrs/utils/sql_parser.rb
 - lib/calculable_attrs/version.rb
 - lib/tasks/calculable_tasks.rake
 homepage: https://github.com/dmitrysharkov/calculable_attrs