calculated_attributes 0.0.15

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9c877786aece3b27fdc6487e1f0fde18e972e509
+  data.tar.gz: 7aea77ccc13a0ac2ccc8177dfc69dc799c606100
+SHA512:
+  metadata.gz: 8376dbbcbb9eb0590c813574dea24279282b6ba01062b647c395d545926128b5cf640fd40cd986b6edbf8a4a3d74756ecf1a4e6487c961ebdecafe8791367043
+  data.tar.gz: 3653cf42956ff9a77528981e6429d3e372747e2b1a219870090fa108a0b5fc9367718c0d1631a3550446ada3e8848370bd5a8fd04033119cce6c03148aac252f

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+# Ignore test database.
+/spec/*.sqlite3

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,22 @@
+AllCops:
+  Exclude:
+    - db/**/*
+
+BlockNesting: 
+  Max: 4
+ClassLength:
+  Enabled: False
+ClassVars:
+  Enabled: False
+CyclomaticComplexity:
+  Enabled: False
+Documentation:
+  Enabled: false
+LineLength:
+  Enabled: false
+MethodLength:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/PerceivedComplexity:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in calculated_attributes.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Aha! Labs Inc
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,83 @@
+# CalculatedAttributes
+
+Automatically add calculated attributes from accessory select queries to ActiveRecord models.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'calculated_attributes'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install calculated_attributes
+
+## Usage
+
+Add each calculated attribute to your model using the `calculated` keyword. It accepts two parameters: a symbol representing the name of the calculated attribute, and a lambda containing a string to calculate the attribute.
+
+For example, if we have two models, `Post` and `Comment`, and `Comment` has a `post_id` attribute, we might write the following code to add a comments count to each `Post` record in a relation:
+
+    class Post < ActiveRecord::Base
+    ...
+      calculated :comments_count, -> { "select count(*) from comments where comments.post_id = posts.id" }
+    ...
+    end
+    
+Then, the comments count may be accessed as follows:
+
+    Post.scoped.calculated(:comments_count).first.comments_count
+    #=> 5
+    
+Multiple calculated attributes may be attached to each model. If we add a `Tag` model that also has a `post_id`, we can update the Post model as following:
+
+    class Post < ActiveRecord::Base
+    ...
+      calculated :comments_count, -> { "select count(*) from comments where comments.post_id = posts.id" }
+      calculated :tags_count, -> { "select count(*) from tags where tags.post_id = posts.id" }
+    ...
+    end
+    
+And then access both the `comments_count` and `tags_count` like so:
+
+    post = Post.scoped.calculated(:comments_count, :tags_count).first
+    post.comments_count
+    #=> 5
+    post.tags_count
+    #=> 2
+    
+You may also use the `calculated` method on a single model instance, like so:
+
+    Post.first.calculated(:comments_count).comments_count
+    #=> 5
+    
+If you have defined a `calculated` method, results of that method will be returned rather than throwing a method missing error even if you don't explicitly use the `calculated()` call on the instance:
+
+    Post.first.comments_count
+    #=> 5
+    
+If you like, you may define `calculated` lambdas using Arel syntax:
+
+    class Post < ActiveRecord::Base
+    ...
+      calculated :comments_count, -> { Comment.select(Arel::Nodes::NamedFunction.new("COUNT", [Comment.arel_table[:id]])).where(Comment.arel_table[:post_id].eq(Post.arel_table[:id])) }
+    ...
+    end
+
+## Contributing
+
+1. Fork it ( https://github.com/aha-app/calculated_attributes/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## Credits
+
+Written by Zach Schneider based on ideas from Chris Waters.

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/calculated_attributes.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'calculated_attributes/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'calculated_attributes'
+  spec.version       = CalculatedAttributes::VERSION
+  spec.authors       = ['Zach Schneider']
+  spec.email         = ['zach@aha.io']
+  spec.summary       = 'Automatically add calculated attributes to ActiveRecord models.'
+  spec.homepage      = 'https://github.com/aha-app/calculated_attributes'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'sqlite3'
+
+  spec.add_dependency 'activerecord', '3.2.21'
+end

data/lib/calculated_attributes.rb

@@ -0,0 +1,121 @@
+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)
+    self.class.scoped.calculated(*args).find(id)
+  end
+
+  def method_missing(sym, *args, &block)
+    if !@attributes.include?(sym.to_s) && (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
+      class_with_attr.scoped.calculated(sym).find(id).send(sym)
+    else
+      super(sym, *args, &block)
+    end
+  end
+
+  def respond_to?(method, include_private = false)
+    super || (!@attributes.include?(method.to_s) && (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
+      if sql.is_a? String
+        new_projection = Arel.sql("(#{sql})").as(arg.to_s)
+        new_projection.calculated_attr!
+        projections.push new_projection
+      else
+        new_projection = sql.as(arg.to_s)
+        new_projection.calculated_attr!
+        projections.push new_projection
+      end
+    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
+end
+
+module ActiveRecord
+  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 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

@@ -0,0 +1,3 @@
+module CalculatedAttributes
+  VERSION = '0.0.15'
+end

data/spec/lib/calculated_attributes_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe 'calculated_attributes' do
+  it 'includes calculated attributes' do
+    expect(Post.scoped.calculated(:comments).first.comments).to eq(1)
+  end
+
+  it 'includes multiple calculated attributes' do
+    post = Post.scoped.calculated(:comments, :comments_two).first
+    expect(post.comments).to eq(1)
+    expect(post.comments_two).to eq(1)
+  end
+
+  it 'includes chained calculated attributes' do
+    post = Post.scoped.calculated(:comments).calculated(:comments_two).first
+    expect(post.comments).to eq(1)
+    expect(post.comments_two).to eq(1)
+  end
+
+  it 'nests with where query' do
+    expect(Post.where(id: 1).calculated(:comments).first.comments).to eq(1)
+  end
+
+  it 'nests with order query' do
+    expect(Post.order('id DESC').calculated(:comments).first.id).to eq(Post.count)
+  end
+
+  it 'allows access via model instance method' do
+    expect(Post.first.calculated(:comments).comments).to eq(1)
+  end
+
+  it 'allows anonymous access via model instance method' do
+    expect(Post.first.comments).to eq(1)
+  end
+
+  it 'allows anonymous access via model instance method with STI and lambda on base class' do
+    expect(Tutorial.first.comments).to eq(1)
+  end
+
+  it 'allows anonymous access via model instance method with STI and lambda on subclass' do
+    expect(Article.first.sub_comments).to eq(1)
+  end
+
+  it 'does not allow anonymous access for nonexisting calculated block' do
+    expect { Post.first.some_attr }.to raise_error(NoMethodError)
+  end
+
+  it 'does not allow anonymous access for nonexisting calculated block with STI' do
+    expect { Tutorial.first.some_attr }.to raise_error(NoMethodError)
+  end
+
+  it 'allows access to multiple calculated attributes via model instance method' do
+    post = Post.first.calculated(:comments, :comments_two)
+    expect(post.comments).to eq(1)
+    expect(post.comments_two).to eq(1)
+  end
+
+  it 'allows attributes to be defined using AREL' do
+    expect(Post.scoped.calculated(:comments_arel).first.comments_arel).to eq(1)
+  end
+
+  it 'maintains previous scope' do
+    expect(Post.where(text: 'First post!').calculated(:comments).count).to eq(1)
+    expect(Post.where(text: 'First post!').calculated(:comments).first.comments).to eq(1)
+    expect(Post.where("posts.text = 'First post!'").calculated(:comments).first.comments).to eq(1)
+  end
+
+  it 'maintains subsequent scope' do
+    expect(Post.scoped.calculated(:comments).where(text: 'First post!').count).to eq(1)
+    expect(Post.scoped.calculated(:comments).where(text: 'First post!').first.comments).to eq(1)
+    expect(Post.scoped.calculated(:comments).where("posts.text = 'First post!'").first.comments).to eq(1)
+  end
+
+  it 'includes calculated attributes with STI and lambda on base class' do
+    expect(Tutorial.scoped.calculated(:comments).first.comments).to eq(1)
+  end
+
+  it 'includes calculated attributes with STI and lambda on subclass' do
+    expect(Article.scoped.calculated(:sub_comments).first.sub_comments).to eq(1)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+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'

data/spec/support/data.rb

@@ -0,0 +1,7 @@
+p = Post.create(text: 'First post!')
+Comment.create(post_id: p.id, text: 'First comment!')
+Post.create(text: 'Second post!')
+t = Tutorial.create(text: 'Tutorial!')
+Comment.create(post_id: t.id, text: 'First comment!')
+a = Article.create(text: 'Article!')
+Comment.create(post_id: a.id, text: 'First comment!')

data/spec/support/models.rb

@@ -0,0 +1,15 @@
+class Post < ActiveRecord::Base
+  calculated :comments, -> { 'select count(*) from comments where comments.post_id = posts.id' }
+  calculated :comments_two, -> { 'select count(*) from comments where comments.post_id = posts.id' }
+  calculated :comments_arel, -> { Comment.where(Comment.arel_table[:post_id].eq(Post.arel_table[:id])).select(Arel.sql('count(*)')) }
+end
+
+class Tutorial < Post
+end
+
+class Article < Post
+  calculated :sub_comments, -> { 'select count(*) from comments where comments.post_id = posts.id' }
+end
+
+class Comment < ActiveRecord::Base
+end

data/spec/support/schema.rb

@@ -0,0 +1,14 @@
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :posts, force: true do |t|
+    t.string :text
+    t.timestamps
+  end
+
+  create_table :comments, force: true do |t|
+    t.integer :post_id
+    t.string :text
+    t.timestamps
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: calculated_attributes
+version: !ruby/object:Gem::Version
+  version: 0.0.15
+platform: ruby
+authors:
+- Zach Schneider
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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
+  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
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.21
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.21
+description: 
+email:
+- zach@aha.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- calculated_attributes.gemspec
+- lib/calculated_attributes.rb
+- lib/calculated_attributes/version.rb
+- spec/lib/calculated_attributes_spec.rb
+- spec/spec_helper.rb
+- spec/support/data.rb
+- spec/support/models.rb
+- spec/support/schema.rb
+homepage: https://github.com/aha-app/calculated_attributes
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Automatically add calculated attributes to ActiveRecord models.
+test_files:
+- spec/lib/calculated_attributes_spec.rb
+- spec/spec_helper.rb
+- spec/support/data.rb
+- spec/support/models.rb
+- spec/support/schema.rb