calculated_attributes 0.0.22 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f5d1e1c6a85809abd342ec35a184d0ae2f7a18d2
-  data.tar.gz: f294bd5a311c92f6c4b14d6b4ed532c5a13117c6
+  metadata.gz: c8141eabe21755f5e75184d22da98d5368e6c165
+  data.tar.gz: 18f6d50e0ed85de3aebb5e52a5cfe194b7c33fc2
 SHA512:
-  metadata.gz: 72d6a5a63cdb53272e9d3cab73945fb91b3d23a7bc09ac5588195d0351bb3f4d77d4d93645dcba01f7d44657a6717acfae266c57762269edb118bd16e4f6fd88
-  data.tar.gz: 1e4e6d4ab5b312e99c7ec28df1f8710fb08b8521aa7ccda3aa312c99b2e6344626a58261c1bb9be09efea51be60c62ca89719852beda27945a832d0b79de70f9
+  metadata.gz: 8bd4c465bef83c4bfc3ad161a2095bc2908c08cb05db4638b0c9398355063b60a6a5dc7ecd7a5826a9ebe4553db42072396cc4fd8649d84bf9daabddb574558f
+  data.tar.gz: 24bb795211e8ef9fb38728aea7c40560ac3b3ccbc3ec8029e4e4755f43dea633564b59a20b0b46bf60bc57aa82713ff371afc6c9dfe91eda7991d8952935a22f

data/README.md

@@ -1,3 +1,5 @@
+[![Gem Version](https://badge.fury.io/rb/calculated_attributes.svg)](https://badge.fury.io/rb/calculated_attributes)
+
 # CalculatedAttributes
 
 Automatically add calculated attributes from accessory select queries to ActiveRecord models.

data/lib/calculated_attributes/arel_patches.rb

@@ -0,0 +1,5 @@
+Arel::SelectManager.send(:include, Module.new do
+  def projections
+    @ctx.projections
+  end
+end)

data/lib/calculated_attributes/model_methods.rb

@@ -0,0 +1,79 @@
+module CalculatedAttributes
+  def calculated(*args)
+    @config ||= CalculatedAttributes::Config.new
+    @config.calculated(args.first, args.last) if args.size == 2
+    @config
+  end
+
+  class CalculatedAttributes
+    class Config
+      def calculated(title = nil, lambda = nil)
+        @calculations ||= {}
+        @calculations[title] ||= lambda if title && lambda
+        @calculations
+      end
+    end
+  end
+end
+ActiveRecord::Base.extend CalculatedAttributes
+
+ActiveRecord::Base.send(:include, Module.new do
+  def calculated(*args)
+    if self.class.respond_to? :scoped
+      self.class.scoped.calculated(*args).find(id)
+    else
+      self.class.all.calculated(*args).find(id)
+    end
+  end
+
+  def method_missing(sym, *args, &block)
+    no_sym_in_attr =
+      if @attributes.respond_to? :include?
+        !@attributes.include?(sym.to_s)
+      else
+        !@attributes.key?(sym.to_s)
+      end
+    if no_sym_in_attr && (self.class.calculated.calculated[sym] || self.class.base_class.calculated.calculated[sym])
+      Rails.logger.warn("Using calculated value without including it in the relation: #{sym}") if defined? Rails
+      class_with_attr =
+        if self.class.calculated.calculated[sym]
+          self.class
+        else
+          self.class.base_class
+        end
+      if class_with_attr.respond_to? :scoped
+        class_with_attr.scoped.calculated(sym).find(id).send(sym)
+      else
+        class_with_attr.all.calculated(sym).find(id).send(sym)
+      end
+    else
+      super(sym, *args, &block)
+    end
+  end
+
+  def respond_to?(method, include_private = false)
+    no_sym_in_attr =
+      if @attributes.respond_to? :include?
+        !@attributes.include?(method.to_s)
+      elsif @attributes.respond_to? :key?
+        !@attributes.key?(method.to_s)
+      else
+        true
+      end
+    super || (no_sym_in_attr && (self.class.calculated.calculated[method] || self.class.base_class.calculated.calculated[method]))
+  end
+end)
+
+ActiveRecord::Relation.send(:include, Module.new do
+  def calculated(*args)
+    projections = arel.projections
+    args.each do |arg|
+      lam = klass.calculated.calculated[arg] || klass.base_class.calculated.calculated[arg]
+      sql = lam.call
+      new_projection = sql.is_a?(String) ? Arel.sql("(#{sql})").as(arg.to_s) : sql.as(arg.to_s)
+      new_projection.calculated_attr!
+      projections.push new_projection
+    end
+    select(projections)
+  end
+end)

data/lib/calculated_attributes/rails_3_patches.rb

@@ -0,0 +1,70 @@
+module ActiveRecord
+  module AttributeMethods
+    module ClassMethods
+      # Generates all the attribute related methods for columns in the database
+      # accessors, mutators and query methods.
+      def define_attribute_methods
+        unless defined?(@attribute_methods_mutex)
+          msg = 'It looks like something (probably a gem/plugin) is overriding the ' \
+                'ActiveRecord::Base.inherited method. It is important that this hook executes so ' \
+                'that your models are set up correctly. A workaround has been added to stop this ' \
+                'causing an error in 3.2, but future versions will simply not work if the hook is ' \
+                'overridden. If you are using Kaminari, please upgrade as it is known to have had ' \
+                "this problem.\n\n"
+          msg << 'The following may help track down the problem:'
+
+          meth = method(:inherited)
+          if meth.respond_to?(:source_location)
+            msg << " #{meth.source_location.inspect}"
+          else
+            msg << " #{meth.inspect}"
+          end
+          msg << "\n\n"
+
+          ActiveSupport::Deprecation.warn(msg)
+
+          @attribute_methods_mutex = Mutex.new
+        end
+
+        # Use a mutex; we don't want two thread simaltaneously trying to define
+        # attribute methods.
+        @attribute_methods_mutex.synchronize do
+          return if attribute_methods_generated?
+          superclass.define_attribute_methods unless self == base_class
+          columns_to_define =
+            if defined?(calculated) && calculated.instance_variable_get('@calculations')
+              calculated_keys = calculated.instance_variable_get('@calculations').keys
+              column_names.reject { |c| calculated_keys.include? c.intern }
+            else
+              column_names
+            end
+          super(columns_to_define)
+          columns_to_define.each { |name| define_external_attribute_method(name) }
+          @attribute_methods_generated = true
+        end
+      end
+    end
+  end
+
+  module Associations
+    class JoinDependency
+      attr_writer :calculated_columns
+
+      def instantiate(rows)
+        primary_key = join_base.aliased_primary_key
+        parents = {}
+
+        records = rows.map do |model|
+          primary_id = model[primary_key]
+          parent = parents[primary_id] ||= join_base.instantiate(model)
+          construct(parent, @associations, join_associations, model)
+          @calculated_columns.each { |column| parent[column.right] = model[column.right] }
+          parent
+        end.uniq
+
+        remove_duplicate_results!(active_record, records, @associations)
+        records
+      end
+    end
+  end
+end

data/lib/calculated_attributes/rails_4_patches.rb

@@ -0,0 +1,64 @@
+module ActiveRecord
+  module AttributeMethods
+    module ClassMethods
+      # Generates all the attribute related methods for columns in the database
+      # accessors, mutators and query methods.
+      def define_attribute_methods
+        return false if @attribute_methods_generated
+        # Use a mutex; we don't want two threads simultaneously trying to define
+        # attribute methods.
+        generated_attribute_methods.synchronize do
+          return false if @attribute_methods_generated
+          superclass.define_attribute_methods unless self == base_class
+          columns_to_define =
+            if defined?(calculated) && calculated.instance_variable_get('@calculations')
+              calculated_keys = calculated.instance_variable_get('@calculations').keys
+              column_names.reject { |c| calculated_keys.include? c.intern }
+            else
+              column_names
+            end
+          super(columns_to_define)
+          @attribute_methods_generated = true
+        end
+        true
+      end
+    end
+  end
+
+  module Associations
+    class JoinDependency
+      attr_writer :calculated_columns
+
+      def instantiate(result_set, aliases)
+        primary_key = aliases.column_alias(join_root, join_root.primary_key)
+
+        seen = Hash.new do |i, object_id|
+          i[object_id] = Hash.new do |j, child_class|
+            j[child_class] = {}
+          end
+        end
+
+        model_cache = Hash.new { |h, klass| h[klass] = {} }
+        parents = model_cache[join_root]
+        column_aliases = aliases.column_aliases join_root
+
+        message_bus = ActiveSupport::Notifications.instrumenter
+
+        payload = {
+          record_count: result_set.length,
+          class_name: join_root.base_klass.name
+        }
+
+        message_bus.instrument('instantiation.active_record', payload) do
+          result_set.each do |row_hash|
+            parent = parents[row_hash[primary_key]] ||= join_root.instantiate(row_hash, column_aliases)
+            @calculated_columns.each { |column| parent[column.right] = model[column.right] }
+            construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+          end
+        end
+
+        parents.values
+      end
+    end
+  end
+end

data/lib/calculated_attributes/rails_patches.rb

@@ -0,0 +1,45 @@
+module ActiveRecord
+  module FinderMethods
+    def construct_relation_for_association_find(join_dependency)
+      calculated_columns = arel.projections.select { |p| p.is_a?(Arel::Nodes::Node) && p.calculated_attr? }
+      relation = except(:includes, :eager_load, :preload, :select).select(join_dependency.columns.concat(calculated_columns))
+      join_dependency.calculated_columns = calculated_columns
+      apply_join_dependency(relation, join_dependency)
+    end
+  end
+end
+
+module ActiveRecord
+  module AttributeMethods
+    module Write
+      # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+. Empty strings
+      # for fixnum and float columns are turned into +nil+.
+      def write_attribute(attr_name, value)
+        if ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR == 2
+          write_attribute_with_type_cast(attr_name, value, true)
+        else
+          attr_name = attr_name.to_s
+          attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
+          @attributes_cache.delete(attr_name)
+          column = column_for_attribute(attr_name)
+
+          @attributes[attr_name] = type_cast_attribute_for_write(column, value)
+        end
+      end
+    end
+  end
+end
+
+module Arel
+  module Nodes
+    class Node
+      def calculated_attr!
+        @is_calculated_attr = true
+      end
+
+      def calculated_attr?
+        @is_calculated_attr
+      end
+    end
+  end
+end

data/lib/calculated_attributes/version.rb

@@ -1,3 +1,3 @@
 module CalculatedAttributes
-  VERSION = '0.0.22'
+  VERSION = '0.1.0'
 end

data/lib/calculated_attributes.rb

@@ -1,226 +1,11 @@
 require 'calculated_attributes/version'
 require 'active_record'
 
-module CalculatedAttributes
-  def calculated(*args)
-    @config ||= CalculatedAttributes::Config.new
-    @config.calculated(args.first, args.last) if args.size == 2
-    @config
-  end
-
-  class CalculatedAttributes
-    class Config
-      def calculated(title = nil, lambda = nil)
-        @calculations ||= {}
-        @calculations[title] ||= lambda if title && lambda
-        @calculations
-      end
-    end
-  end
-end
-ActiveRecord::Base.extend CalculatedAttributes
-
-ActiveRecord::Base.send(:include, Module.new do
-  def calculated(*args)
-    if self.class.respond_to? :scoped
-      self.class.scoped.calculated(*args).find(id)
-    else
-      self.class.all.calculated(*args).find(id)
-    end
-  end
-
-  def method_missing(sym, *args, &block)
-    no_sym_in_attr =
-      if @attributes.respond_to? :include?
-        !@attributes.include?(sym.to_s)
-      else
-        !@attributes.key?(sym.to_s)
-      end
-    if no_sym_in_attr && (self.class.calculated.calculated[sym] || self.class.base_class.calculated.calculated[sym])
-      Rails.logger.warn("Using calculated value without including it in the relation: #{sym}") if defined? Rails
-      class_with_attr =
-        if self.class.calculated.calculated[sym]
-          self.class
-        else
-          self.class.base_class
-        end
-      if class_with_attr.respond_to? :scoped
-        class_with_attr.scoped.calculated(sym).find(id).send(sym)
-      else
-        class_with_attr.all.calculated(sym).find(id).send(sym)
-      end
-    else
-      super(sym, *args, &block)
-    end
-  end
-
-  def respond_to?(method, include_private = false)
-    no_sym_in_attr =
-      if @attributes.respond_to? :include?
-        !@attributes.include?(method.to_s)
-      elsif @attributes.respond_to? :key?
-        !@attributes.key?(method.to_s)
-      else
-        true
-      end
-    super || (no_sym_in_attr && (self.class.calculated.calculated[method] || self.class.base_class.calculated.calculated[method]))
-  end
-end)
-
-ActiveRecord::Relation.send(:include, Module.new do
-  def calculated(*args)
-    projections = arel.projections
-    args.each do |arg|
-      lam = klass.calculated.calculated[arg] || klass.base_class.calculated.calculated[arg]
-      sql = lam.call
-      new_projection = sql.is_a?(String) ? Arel.sql("(#{sql})").as(arg.to_s) : sql.as(arg.to_s)
-      new_projection.calculated_attr!
-      projections.push new_projection
-    end
-    select(projections)
-  end
-end)
-
-Arel::SelectManager.send(:include, Module.new do
-  def projections
-    @ctx.projections
-  end
-end)
-
-module ActiveRecord
-  module FinderMethods
-    def construct_relation_for_association_find(join_dependency)
-      calculated_columns = arel.projections.select { |p| p.is_a?(Arel::Nodes::Node) && p.calculated_attr? }
-      relation = except(:includes, :eager_load, :preload, :select).select(join_dependency.columns.concat(calculated_columns))
-      join_dependency.calculated_columns = calculated_columns
-      apply_join_dependency(relation, join_dependency)
-    end
-  end
-
-  module AttributeMethods
-    module ClassMethods
-      # Generates all the attribute related methods for columns in the database
-      # accessors, mutators and query methods.
-      def define_attribute_methods
-        case ActiveRecord::VERSION::MAJOR
-        when 3
-          unless defined?(@attribute_methods_mutex)
-            msg = "It looks like something (probably a gem/plugin) is overriding the " \
-                  "ActiveRecord::Base.inherited method. It is important that this hook executes so " \
-                  "that your models are set up correctly. A workaround has been added to stop this " \
-                  "causing an error in 3.2, but future versions will simply not work if the hook is " \
-                  "overridden. If you are using Kaminari, please upgrade as it is known to have had " \
-                  "this problem.\n\n"
-            msg << "The following may help track down the problem:"
-
-            meth = method(:inherited)
-            if meth.respond_to?(:source_location)
-              msg << " #{meth.source_location.inspect}"
-            else
-              msg << " #{meth.inspect}"
-            end
-            msg << "\n\n"
-
-            ActiveSupport::Deprecation.warn(msg)
-
-            @attribute_methods_mutex = Mutex.new
-          end
-
-          # Use a mutex; we don't want two thread simaltaneously trying to define
-          # attribute methods.
-          @attribute_methods_mutex.synchronize do
-            return if attribute_methods_generated?
-            superclass.define_attribute_methods unless self == base_class
-            columns_to_define =
-              if defined?(calculated) && calculated.instance_variable_get('@calculations')
-                calculated_keys = calculated.instance_variable_get('@calculations').keys
-                column_names.reject { |c| calculated_keys.include? c.intern }
-              else
-                column_names
-              end
-            super(columns_to_define)
-            columns_to_define.each { |name| define_external_attribute_method(name) }
-            @attribute_methods_generated = true
-          end
-
-        when 4
-          return false if @attribute_methods_generated
-          # Use a mutex; we don't want two threads simultaneously trying to define
-          # attribute methods.
-          generated_attribute_methods.synchronize do
-            return false if @attribute_methods_generated
-            superclass.define_attribute_methods unless self == base_class
-            columns_to_define =
-              if defined?(calculated) && calculated.instance_variable_get('@calculations')
-                calculated_keys = calculated.instance_variable_get('@calculations').keys
-                column_names.reject { |c| calculated_keys.include? c.intern }
-              else
-                column_names
-              end
-            super(columns_to_define)
-            @attribute_methods_generated = true
-          end
-          true
-        end
-      end
-    end
-  end
-
-  module Associations
-    class JoinDependency
-      attr_writer :calculated_columns
-
-      def instantiate(rows)
-        primary_key = join_base.aliased_primary_key
-        parents = {}
-
-        records = rows.map do |model|
-          primary_id = model[primary_key]
-          parent = parents[primary_id] ||= join_base.instantiate(model)
-          construct(parent, @associations, join_associations, model)
-          @calculated_columns.each { |column| parent[column.right] = model[column.right] }
-          parent
-        end.uniq
-
-        remove_duplicate_results!(active_record, records, @associations)
-        records
-      end
-    end
-  end
-end
-
-module ActiveRecord
-  module AttributeMethods
-    module Write
-      # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+. Empty strings
-      # for fixnum and float columns are turned into +nil+.
-      def write_attribute(attr_name, value)
-        if ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR == 2
-          write_attribute_with_type_cast(attr_name, value, true)
-        else
-          attr_name = attr_name.to_s
-          attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
-          @attributes_cache.delete(attr_name)
-          column = column_for_attribute(attr_name)
-
-          @attributes[attr_name] = type_cast_attribute_for_write(column, value)
-        end
-      end
-    end
-  end
-end
-
-
-module Arel
-  module Nodes
-    class Node
-      def calculated_attr!
-        @is_calculated_attr = true
-      end
-
-      def calculated_attr?
-        @is_calculated_attr
-      end
-    end
-  end
-end
+# Include patches.
+require 'calculated_attributes/rails_patches'
+require 'calculated_attributes/arel_patches'
+fail "Unsupported ActiveRecord version: #{ActiveRecord::VERSION::MAJOR}" unless [3, 4].include? ActiveRecord::VERSION::MAJOR
+require "calculated_attributes/rails_#{ActiveRecord::VERSION::MAJOR}_patches"
+
+# Include model code.
+require 'calculated_attributes/model_methods'

data/spec/spec_helper.rb

@@ -3,6 +3,4 @@ require 'calculated_attributes'
 ActiveRecord::Base.establish_connection(adapter: 'sqlite3',
                                         database: File.dirname(__FILE__) + '/calculated_attributes.sqlite3')
 
-load File.dirname(__FILE__) + '/support/schema.rb'
-load File.dirname(__FILE__) + '/support/models.rb'
-load File.dirname(__FILE__) + '/support/data.rb'
+%w(schema models data).each { |f| load File.dirname(__FILE__) + "/support/#{f}.rb" }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: calculated_attributes
 version: !ruby/object:Gem::Version
-  version: 0.0.22
+  version: 0.1.0
 platform: ruby
 authors:
 - Zach Schneider
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-01 00:00:00.000000000 Z
+date: 2015-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: appraisal
@@ -131,6 +131,11 @@ files:
 - gemfiles/rails4_2.gemfile
 - gemfiles/rails4_2.gemfile.lock
 - lib/calculated_attributes.rb
+- lib/calculated_attributes/arel_patches.rb
+- lib/calculated_attributes/model_methods.rb
+- lib/calculated_attributes/rails_3_patches.rb
+- lib/calculated_attributes/rails_4_patches.rb
+- lib/calculated_attributes/rails_patches.rb
 - lib/calculated_attributes/version.rb
 - spec/lib/calculated_attributes_spec.rb
 - spec/spec_helper.rb