numbered_relationships 0.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 Curtis Ekstrom
+
+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,144 @@
+# NumberedRelationships
+
+This gem implements basic filtering of ActiveRecord models on the class and instance level based
+on the amount of relationships belonging to the object or its associations.
+
+## Benefits/ Raison d'Etre
+Defining a scope or model method that implements such basic having/count functionality on an
+ActiveRecord model is trivial:
+
+```ruby
+class Joker << ActiveRecord::Base
+	has_many :jokes
+
+	def self.with_at_least_n_jokes(n)
+		self.joins(:jokes).group("jokes.id HAVING count(joker_id) >= n")
+	end
+end
+```
+But what if we want to filter a jester's jokes as well?  ActiveSupport defines concerns to make module inclusion really simple:
+```ruby
+module Humor
+	extend ActiveSupport::Concern
+	included do
+		has_many :jokes
+		def with_at_least_n_jokes(n)
+			self.joins(:jokes).group("jokes.id HAVING count(joker_id) >= n")
+		end
+	end
+end
+
+class Joker < ActiveRecord::Base
+	include Humor
+end
+```
+Great! We can find the really humurous
+```ruby
+Joker.with_at_least_n_jokes(200)
+```
+But the following might break, as the hard-coded foreign key "joker_id" might not exist in the 
+jesters table.
+```ruby
+class Jester < ActiveRecord::Base
+	include Humor
+end
+```
+The problem is quite clear: the scopes define queries using specific implementation details,
+making reuse nearly impossible.
+
+But there's also a larger issue here: jokes are only one possible association.  If we want the
+Jester model to include, say, music_instruments -- and to be able to filter on their amount --
+we're back at square one, writing another module for each association.
+
+This gem provides relief. Instead of defining modules with hard-coded method names and queries, it uses ActiveRecord's reflection capabilities to enable amount-based filtering on all models and their associations:
+```ruby
+# Class-based filters
+Joker.with_at_least(2, :music_instruments)
+Joker.with_at_least(200, :jokes)
+```
+
+```ruby
+# Instance-based association filters
+@first_joker = Joker.find(1)
+@first_joker.jokes.with_at_least(10, :tomatoes)
+```
+These also call scoped() on all queries and return an instance of ActiveRecord::Relation, meaning that these methods are chainable:
+```ruby
+@first_joker.performances.with_at_least(10, :dramatic_moments).where(:duration > 10)
+```
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'numbered_relationships'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install numbered_relationships
+
+## Usage
+This gem extends ActiveRecord, meaning the installation immediately offers the following methods:
+
+```ruby
+Joker.with_at_least(1, :joke)
+Joker.with_at_most(2, :jokes)
+Joker.with_exactly(2, :jokes)
+Joker.without(2, :jokes)
+Joker.with_more_than(2, :jokes)
+Joker.with_less_than(2, :jokes)
+
+j = Joker.find(123)
+j.jokes.with_at_least(1, :laugh)
+j.jokes.with_at_most(2, :laughs)
+j.jokes.with_exactly(2, :laughs)
+j.jokes.without(11, :laughs)
+j.jokes.with_more_than(18, :laughs)
+j.jokes.with_less_than(2, :laughs)
+```
+It's also possible to use class methods or scopes defined on the association class:
+```ruby
+Joker.with_at_least(1, [:dirty], :joke)
+
+```
+As long as the class method or scope :dirty is defined on Joker:
+```ruby
+class Joke
+  def self.dirty
+  	where(funny: true)
+  end
+end
+```
+this code will properly filter the results before attempting to group them.  It outputs the following SQL:
+```sql
+SELECT jesters.* FROM jesters 
+INNER JOIN jokes ON jokes.jester_id = jesters.id 
+WHERE jokes.funny = 't' 
+GROUP BY jesters.id 
+HAVING count(jokes.id) >= 1
+```
+These methods, like all other class methods, are chainable, meaning the following would also work:
+```ruby
+Joker.with_at_least(1, [:dirty, :insulting, :crying_on_the_floor], :joke)
+```
+
+A call to a non-existent association will -- at least for the moment -- simply return:
+```ruby
+[]
+```
+
+## TODO:
+1. Improve exception handling.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/clekstro/numbered_relationships)![Travis CI Status](https://secure.travis-ci.org/clekstro/numbered_relationships.png)

data/Rakefile

@@ -0,0 +1,27 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'NumberedRelationships'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+

data/lib/numbered_relationships.rb

@@ -0,0 +1,53 @@
+require_relative 'numbered_relationships/constructor_finder'
+
+module NumberedRelationships
+  module AmountFilters
+    extend ActiveSupport::Concern
+
+    def with_at_least(n, filters=[], assoc)
+      find_related_objects(n, assoc, '>=', filters, self)
+    end
+
+    def with_at_most(n, filters=[], assoc)
+      find_related_objects(n, assoc, '<=', filters, self)
+    end
+
+    def with_exactly(n, filters=[], assoc)
+      find_related_objects(n, assoc, '=', filters, self)
+    end
+
+    def without(n, filters=[], assoc)
+      find_related_objects(n, assoc, '<>', filters, self)
+    end
+
+    def with_more_than(n, filters=[], assoc)
+      find_related_objects(n, assoc, '>', filters, self)
+    end
+
+    def with_less_than(n, filters=[], assoc)
+      find_related_objects(n, assoc, '<', filters, self)
+    end
+
+    private
+
+    def find_related_objects(n, assoc, operator, filters, klass)
+      reflection = determine_reflection(klass, assoc)
+      return klass.scoped unless reflection
+
+      ConstructorFinder::find({
+        n: n,
+        operator: operator,
+        filters: filters,
+        klass: klass,
+        reflection: reflection
+      }).construct
+    end
+    
+    def determine_reflection(klass, assoc)
+      klass.reflect_on_association(assoc) || klass.reflect_on_association(assoc.to_s.tableize.to_sym)
+    end
+
+  end
+end
+
+ActiveRecord::Base.send :extend, NumberedRelationships::AmountFilters

data/lib/numbered_relationships/constructor.rb

@@ -0,0 +1,45 @@
+module NumberedRelationships
+  class Constructor
+    def initialize(options={})
+      @n = options[:n]
+      @operator = options[:operator]
+      @filters = options[:filters]
+      @klass = options[:klass]
+      @reflection = options[:reflection]
+    end
+
+    def construct
+      return @klass.scoped unless @reflection
+    end
+
+    private 
+
+    def table
+      @klass.name.tableize
+    end
+
+    def foreign_key
+      @reflection.foreign_key
+    end
+
+    def association
+      @reflection.name
+    end
+
+    def join_table
+      @klass.reflect_on_association(association.to_sym).options[:join_table]
+    end
+    
+    def through_model
+      @reflection.options[:through]
+    end
+
+    def constantize_klass
+      association.to_s.classify.constantize
+    end
+    
+    def chain_symbols(symbols)
+      symbols.map{ |s| s.to_s }.join('.')
+    end
+  end
+end

data/lib/numbered_relationships/constructor_finder.rb

@@ -0,0 +1,19 @@
+require_relative 'has_many'
+require_relative 'has_many_through'
+require_relative 'has_and_belongs_to_many'
+
+module NumberedRelationships
+	module ConstructorFinder
+    def self.find(options={})
+      reflection = options[:reflection]
+      case reflection.macro
+      when :has_and_belongs_to_many
+        HasAndBelongsToManyConstructor.new(options)
+      when :has_many
+        thru = reflection.options[:through] if reflection
+        return HasManyConstructor.new(options) unless thru
+        HasManyThroughConstructor.new(options)
+      end
+    end
+	end
+end

data/lib/numbered_relationships/has_and_belongs_to_many.rb

@@ -0,0 +1,23 @@
+require_relative 'constructor'
+
+module NumberedRelationships
+	class HasAndBelongsToManyConstructor < Constructor
+		def construct
+      super
+      return construct_habtm_with_join_table if join_table
+      construct_habtm_without_join_table
+    end
+
+    def construct_habtm_with_join_table
+      @klass.joins(association)
+            .group("#{table}.id")
+            .having("count(#{join_table}.#{foreign_key}) #{@operator} #{@n}")
+    end
+
+    def construct_habtm_without_join_table
+      @klass.joins(association)
+            .group("#{table}.id")
+            .having("count(#{foreign_key}) #{@operator} #{@n}")
+    end
+	end
+end

data/lib/numbered_relationships/has_many.rb

@@ -0,0 +1,23 @@
+require_relative 'constructor'
+
+module NumberedRelationships
+  class HasManyConstructor < Constructor
+    def construct
+      super
+      return construct_has_many_filtered unless @filters.empty?
+      construct_has_many_unfiltered
+    end
+    def construct_has_many_unfiltered
+      @klass.joins(association)
+            .group("#{table}.id")
+            .having("count(#{association.to_s}.id) #{@operator} #{@n}")
+    end
+
+    def construct_has_many_filtered
+      @klass.joins(association)
+            .merge(eval("#{constantize_klass}.#{chain_symbols(@filters)}"))
+            .group("#{table}.id")
+            .having("count(#{association.to_s}.id) #{@operator} #{@n}")
+    end
+  end
+end

data/lib/numbered_relationships/has_many_through.rb

@@ -0,0 +1,12 @@
+require_relative 'constructor'
+
+module NumberedRelationships
+  class HasManyThroughConstructor < Constructor
+    def construct
+      super
+      @klass.joins(through_model, association)
+          .group("#{table}.id")
+          .having("count(#{association.to_s}.id) #{@operator} #{@n}")
+    end
+  end
+end

data/lib/numbered_relationships/version.rb

@@ -0,0 +1,3 @@
+module NumberedRelationships
+  VERSION = "0.2"
+end

data/lib/tasks/numbered_relationships_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :numbered_relationships do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: numbered_relationships
+version: !ruby/object:Gem::Version
+  version: '0.2'
+  prerelease: 
+platform: ruby
+authors:
+- Curtis Ekstrom
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.7
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl_rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Amount-based filtering for AR Models and Associations
+email:
+- ce@canvus.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/numbered_relationships/constructor.rb
+- lib/numbered_relationships/constructor_finder.rb
+- lib/numbered_relationships/has_and_belongs_to_many.rb
+- lib/numbered_relationships/has_many.rb
+- lib/numbered_relationships/has_many_through.rb
+- lib/numbered_relationships/version.rb
+- lib/numbered_relationships.rb
+- lib/tasks/numbered_relationships_tasks.rake
+- MIT-LICENSE
+- Rakefile
+- README.md
+homepage: https://github.com/clekstro/numbered_relationships
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Extend ActiveRecord models with amount-based filters for models and their
+  associations
+test_files: []