forty_facets 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e439d4f05f7a8bfe44665eec3bed14cf9d323e2
-  data.tar.gz: c2c5a838fe3489158e5a88947e30cedfe68472b0
+  metadata.gz: 25afbbdd35eee3919efcdbf6766ef3173ad1a2fe
+  data.tar.gz: 864056c9c65d99a49a890177d7ff87440a18d62b
 SHA512:
-  metadata.gz: 35018e26f1a6a037cf48d9e48d5df2fcd4df016758b4a5f91314b5f1b7ae6d36c5c91e6bd85d4f372417447fca70545469be79c2f6b8ff74aa94309eecf2d273
-  data.tar.gz: 337b7d8da1cfb036564bb03b1e997e0fd4de8d705d3efab261ec5bd5cc657f21f62a8c0a6f3b0c54b86f377644c35b0e8435ef0dfd7c4ed31555911965306989
+  metadata.gz: 6f40a9650e2b73e552092a810e33c06390f81f554185e6d8af4749b881828ed5065a06e013ca1956b08eff121920bf19b613598a931cbc1fd60fe687da915187
+  data.tar.gz: 2e49716fd8a9b30ffe935d49976f2175068507c2c4448996913b2c08ea1e10e9714a3c91265560e3d573f0804f13c9100effc31a317f654418df3a20517d67e5

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.travis.yml

@@ -0,0 +1,2 @@
+language: ruby
+

data/README.md

@@ -1,3 +1,7 @@
+[![Build Status](https://travis-ci.org/fortytools/forty_facets.svg)](https://travis-ci.org/fortytools/forty_facets)
+[![Coverage Status](https://coveralls.io/repos/fortytools/forty_facets/badge.png?branch=master)](https://coveralls.io/r/fortytools/forty_facets?branch=master)
+[![Code Climate](https://codeclimate.com/github/fortytools/forty_facets.png)](https://codeclimate.com/github/fortytools/forty_facets)
+
 # FortyFacets
 
 FortyFacets lets you easily build explorative search interfaces based on fields of your ActiveRecord models.

data/Rakefile

@@ -1 +1,9 @@
 require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/*_test.rb"
+end
+
+task :default => :test

data/forty_facets.gemspec

@@ -20,4 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "activerecord", ">= 4.0"
 end

data/lib/forty_facets/facet_search.rb

@@ -1,203 +1,38 @@
 module FortyFacets
+  # Inherit this class to create a custom search for your model
+  #
+  #   class MovieSearch < FortyFacets::FacetSearch
+  #     model 'Movie'
+  #
+  #     text :title
+  #     range :price
+  #     facet :genre, name: 'Genre'
+  #     facet :year, name: 'Releaseyear', order: :year
+  #     facet :studio, name: 'Studio', order: :name
+  #
+  #     orders 'Title' => :title,
+  #            'price, cheap first' => "price asc",
+  #            'price, expensive first' => {price: :desc, title: :desc}
+  #
+  #   end
   class FacetSearch
     attr_reader :filters, :orders
 
-
-    FieldDefinition = Struct.new(:search, :model_field, :options) do
-      def request_param
-        model_field
-      end
-    end
-
-    Filter = Struct.new(:field_definition, :search_instance, :value) do
-      def name
-        field_definition.options[:name] || field_definition.model_field
-      end
-
-      def empty?
-        value.nil? || value == '' || value == []
-      end
-
-      # generate a search with this filter removed
-      def without
-        search = search_instance
-        return search if empty?
-        new_params = search_instance.params
-        new_params.delete(field_definition.request_param)
-        search_instance.class.new_unwrapped(new_params)
-      end
-    end
-
-    class RangeField < FieldDefinition
-      class RangeFilter < Filter
-        def build_scope
-          return Proc.new { |base| base } if empty?
-          Proc.new {  |base| base.where("#{field_definition.model_field} >= ? AND #{field_definition.model_field} <= ? ", min_value, max_value ) }
-        end
-
-        def min_value
-          return nil if empty?
-          value.split(' - ').first
-        end
-
-        def max_value
-          return nil if empty?
-          value.split(' - ').last
-        end
-
-        def absolute_interval
-          @abosultes ||= without.result.select("min(#{field_definition.model_field}) as min, max(#{field_definition.model_field}) as max").first
-        end
-
-        def absolute_min
-          absolute_interval.min
-        end
-
-        def absolute_max
-          absolute_interval.max
-        end
-
-      end
-
-      def build_filter(search_instance, value)
-        RangeFilter.new(self, search_instance, value)
-      end
-    end
-
-    class TextField < FieldDefinition
-      class TextFilter < Filter
-        def build_scope
-          return Proc.new { |base| base } if empty?
-          like_value = expression_value(value)
-          Proc.new {  |base| base.where("#{field_definition.model_field} like ?", like_value ) }
-        end
-
-        def expression_value(term)
-          if field_definition.options[:prefix]
-           "#{term}%"
-          else
-           "%#{term}%"
-          end
-        end
-      end
-
-      def build_filter(search_instance, value)
-        TextFilter.new(self, search_instance, value)
-      end
-    end
-
-    class FacetField < FieldDefinition
-      FacetValue = Struct.new(:entity, :count, :selected)
-
-      class FacetFilter < Filter
-        def association
-          field_definition.search.root_class.reflect_on_association(field_definition.model_field)
-        end
-
-        # class objects in this filter
-        def klass
-          association.klass
-        end
-
-        def values
-          @values ||= Array.wrap(value).sort.uniq
-        end
-
-        def selected
-          @selected ||= klass.find(values)
-        end
-
-        def build_scope
-          return Proc.new { |base| base } if empty?
-          Proc.new {  |base| base.where(association.association_foreign_key => values) }
-        end
-
-        def facet
-          my_column = association.association_foreign_key
-          counts = without.result.select("#{my_column} as foreign_id, count(#{my_column}) as occurrences").group(my_column)
-          entities_by_id = klass.find(counts.map(&:foreign_id)).group_by(&:id)
-          facet = counts.inject([]) do |sum, count|
-            facet_entity = entities_by_id[count.foreign_id].first
-            is_selected = selected.include?(facet_entity)
-            sum << FacetValue.new(facet_entity, count.occurrences, is_selected)
-          end
-
-          order_accessor = field_definition.options[:order]
-          if order_accessor
-            facet.sort_by!{|facet_value| facet_value.entity.send(order_accessor) }
-          else
-            facet.sort_by!{|facet_value| -facet_value.count }
-          end
-          facet
-
-        end
-
-        def without
-          new_params = search_instance.params || {}
-          new_params.delete(field_definition.request_param)
-          search_instance.class.new_unwrapped(new_params)
-        end
-
-        def remove(value)
-          new_params = search_instance.params || {}
-          old_values = new_params[field_definition.request_param]
-          old_values.delete(value.id.to_s)
-          new_params.delete(field_definition.request_param) if old_values.empty?
-          search_instance.class.new_unwrapped(new_params)
-        end
-
-        def add(entity)
-          new_params = search_instance.params || {}
-          old_values = new_params[field_definition.request_param] ||= []
-          old_values << entity.id.to_s
-          search_instance.class.new_unwrapped(new_params)
-        end
-
-      end
-
-      def build_filter(search_instance, param_value)
-        FacetFilter.new(self, search_instance, param_value)
-      end
-
-    end
-
     class << self
       def model(model_name)
         @model_name = model_name
       end
 
       def text(model_field, opts = {})
-        definitions << TextField.new(self, model_field, opts)
+        definitions << TextFilterDefinition.new(self, model_field, opts)
       end
 
       def range(model_field, opts = {})
-        definitions << RangeField.new(self, model_field, opts)
+        definitions << RangeFilterDefintion.new(self, model_field, opts)
       end
 
       def facet(model_field, opts = {})
-        definitions << FacetField.new(self, model_field, opts)
-      end
-
-      OrderDefinition = Struct.new(:title, :clause) do
-        def build(search, order_param)
-          Order.new(search, self, order_param == title.to_s)
-        end
-
-        def request_value
-          title
-        end
-      end
-
-      Order = Struct.new(:search, :definition, :active) do
-        def title
-          definition.title
-        end
-
-        def by
-          new_params = search.params || {}
-          new_params[:order] = definition.request_value
-          search.class.new_unwrapped(new_params)
-        end
+        definitions << BelongsToFilter.new(self, model_field, opts)
       end
 
       def orders(name_and_order_options)
@@ -226,16 +61,12 @@ module FortyFacets
       end
 
       def order_definitions
-        @order_definitions
+        @order_definitions ||= []
       end
     end
 
-    def initialize(request_params)
-      params = if request_params && request_params[self.class.request_param_name]
-                 request_params[self.class.request_param_name]
-               else
-                 {}
-               end
+    def initialize(request_params = {})
+      params = request_to_search_params(request_params)
       @filters = self.class.definitions.inject([]) do |filters, definition|
         filters << definition.build_filter(self, params[definition.request_param])
       end
@@ -251,7 +82,7 @@ module FortyFacets
     end
 
     def filter(filter_name)
-      filter = @filters.find { |f| f.field_definition.model_field == filter_name }
+      filter = @filters.find { |f| f.filter_definition.model_field == filter_name }
       raise "unknown filter #{filter_name}" unless filter
       filter
     end
@@ -274,7 +105,7 @@ module FortyFacets
 
     def params
       params = @filters.inject({}) do |sum, filter|
-        sum[filter.field_definition.request_param] = filter.value.dup unless filter.empty?
+        sum[filter.filter_definition.request_param] = filter.value.dup unless filter.empty?
         sum
       end
       params[:order] = order.definition.request_value if order
@@ -288,6 +119,17 @@ module FortyFacets
     def unfiltered?
       @filters.reject(&:empty?).empty?
     end
+
+    private
+
+    def request_to_search_params(request_params)
+      if request_params && request_params[self.class.request_param_name]
+        request_params[self.class.request_param_name]
+      else
+        {}
+      end
+    end
+
   end
 end
 

data/lib/forty_facets/filter/belongs_to.rb

@@ -0,0 +1,80 @@
+module FortyFacets
+  class BelongsToFilter < FilterDefinition
+    FacetValue = Struct.new(:entity, :count, :selected)
+
+    class FacetFilter < Filter
+      def association
+        filter_definition.search.root_class.reflect_on_association(filter_definition.model_field)
+      end
+
+      # class objects in this filter
+      def klass
+        association.klass
+      end
+
+      def values
+        @values ||= Array.wrap(value).sort.uniq
+      end
+
+      def selected
+        @selected ||= klass.find(values)
+      end
+
+      def build_scope
+        return Proc.new { |base| base } if empty?
+        Proc.new {  |base| base.where(association.association_foreign_key => values) }
+      end
+
+      def facet
+        my_column = association.association_foreign_key
+        counts = without.result.select("#{my_column} as foreign_id, count(#{my_column}) as occurrences").group(my_column)
+        entities_by_id = klass.find(counts.map(&:foreign_id)).group_by(&:id)
+        facet = counts.inject([]) do |sum, count|
+          facet_entity = entities_by_id[count.foreign_id].first
+          is_selected = selected.include?(facet_entity)
+          sum << FacetValue.new(facet_entity, count.occurrences, is_selected)
+        end
+
+        order_facet!(facet)
+      end
+
+      def without
+        new_params = search_instance.params || {}
+        new_params.delete(filter_definition.request_param)
+        search_instance.class.new_unwrapped(new_params)
+      end
+
+      def remove(value)
+        new_params = search_instance.params || {}
+        old_values = new_params[filter_definition.request_param]
+        old_values.delete(value.id.to_s)
+        new_params.delete(filter_definition.request_param) if old_values.empty?
+        search_instance.class.new_unwrapped(new_params)
+      end
+
+      def add(entity)
+        new_params = search_instance.params || {}
+        old_values = new_params[filter_definition.request_param] ||= []
+        old_values << entity.id.to_s
+        search_instance.class.new_unwrapped(new_params)
+      end
+
+      private
+
+      def order_facet!(facet)
+        order_accessor = filter_definition.options[:order]
+        if order_accessor
+          facet.sort_by!{|facet_value| facet_value.entity.send(order_accessor) }
+        else
+          facet.sort_by!{|facet_value| -facet_value.count }
+        end
+        facet
+      end
+    end
+
+    def build_filter(search_instance, param_value)
+      FacetFilter.new(self, search_instance, param_value)
+    end
+
+  end
+end

data/lib/forty_facets/filter/range_filter_definition.rb

@@ -0,0 +1,37 @@
+module FortyFacets
+  class RangeFilterDefintion < FilterDefinition
+    class RangeFilter < Filter
+      def build_scope
+        return Proc.new { |base| base } if empty?
+        Proc.new {  |base| base.where("#{filter_definition.model_field} >= ? AND #{filter_definition.model_field} <= ? ", min_value, max_value ) }
+      end
+
+      def min_value
+        return nil if empty?
+        value.split(' - ').first
+      end
+
+      def max_value
+        return nil if empty?
+        value.split(' - ').last
+      end
+
+      def absolute_interval
+        @abosultes ||= without.result.select("min(#{filter_definition.model_field}) as min, max(#{filter_definition.model_field}) as max").first
+      end
+
+      def absolute_min
+        absolute_interval.min
+      end
+
+      def absolute_max
+        absolute_interval.max
+      end
+
+    end
+
+    def build_filter(search_instance, value)
+      RangeFilter.new(self, search_instance, value)
+    end
+  end
+end

data/lib/forty_facets/filter/text_filter_definition.rb

@@ -0,0 +1,23 @@
+module FortyFacets
+  class TextFilterDefinition < FilterDefinition
+    class TextFilter < Filter
+      def build_scope
+        return Proc.new { |base| base } if empty?
+        like_value = expression_value(value)
+        Proc.new {  |base| base.where("#{filter_definition.model_field} like ?", like_value ) }
+      end
+
+      def expression_value(term)
+        if filter_definition.options[:prefix]
+         "#{term}%"
+        else
+         "%#{term}%"
+        end
+      end
+    end
+
+    def build_filter(search_instance, value)
+      TextFilter.new(self, search_instance, value)
+    end
+  end
+end

data/lib/forty_facets/filter.rb

@@ -0,0 +1,24 @@
+module FortyFacets
+  # Base class for the objects representing a specific value for a specific
+  # type of filter. Most FilterDefinitions will have their own Filter subclass
+  # to control values for display and rendering to request parameters.
+  Filter = Struct.new(:filter_definition, :search_instance, :value) do
+    def name
+      filter_definition.options[:name] || filter_definition.model_field
+    end
+
+    def empty?
+      value.nil? || value == '' || value == []
+    end
+
+    # generate a search with this filter removed
+    def without
+      search = search_instance
+      return search if empty?
+      new_params = search_instance.params
+      new_params.delete(filter_definition.request_param)
+      search_instance.class.new_unwrapped(new_params)
+    end
+  end
+end
+

data/lib/forty_facets/filter_definition.rb

@@ -0,0 +1,9 @@
+module FortyFacets
+  # Base class for the classes storing the definition of differently behaving filters
+  FilterDefinition = Struct.new(:search, :model_field, :options) do
+    def request_param
+      model_field
+    end
+  end
+end
+

data/lib/forty_facets/order.rb

@@ -0,0 +1,16 @@
+module FortyFacets
+  # Represents the ordering for a specific search
+  Order = Struct.new(:search, :definition, :active) do
+    def title
+      definition.title
+    end
+
+    # Returns a search with the same filter ordered by this criteria
+    def by
+      new_params = search.params || {}
+      new_params[:order] = definition.request_value
+      search.class.new_unwrapped(new_params)
+    end
+  end
+end
+

data/lib/forty_facets/order_definition.rb

@@ -0,0 +1,15 @@
+module FortyFacets
+  # Stores the parameters of a order criteria for a search.
+  OrderDefinition = Struct.new(:title, :clause) do
+    def build(search, order_param)
+      Order.new(search, self, order_param == title.to_s)
+    end
+
+    # Returns the value that is used in the request parameter to indicate that
+    # the search result is ordered by this criteria.
+    def request_value
+      title
+    end
+  end
+end
+

data/lib/forty_facets/version.rb

@@ -1,3 +1,3 @@
 module FortyFacets
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/forty_facets.rb

@@ -3,4 +3,11 @@ require "forty_facets/version"
 module FortyFacets
 end
 
+require "forty_facets/order_definition"
+require "forty_facets/order"
+require "forty_facets/filter"
+require "forty_facets/filter_definition"
+require "forty_facets/filter/belongs_to"
+require "forty_facets/filter/range_filter_definition"
+require "forty_facets/filter/text_filter_definition"
 require "forty_facets/facet_search"

data/test/smoke_test.rb

@@ -0,0 +1,80 @@
+require 'coveralls'
+Coveralls.wear!
+
+require "minitest/autorun"
+require 'active_record'
+require 'logger'
+require_relative '../lib/forty_facets'
+
+silence_warnings do
+  ActiveRecord::Migration.verbose = false
+  ActiveRecord::Base.logger = Logger.new(nil)
+  ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+end
+
+ActiveRecord::Base.connection.instance_eval do
+
+  create_table :studios do |t|
+    t.string :name
+  end
+
+  create_table :movies do |t|
+    t.integer :studio_id
+    t.string :title
+    t.float :price
+  end
+
+end
+
+class Studio < ActiveRecord::Base
+end
+
+class Movie < ActiveRecord::Base
+  belongs_to :studio
+end
+
+class MovieSearch < FortyFacets::FacetSearch
+  model 'Movie'
+
+  text :title, name: 'Title'
+  facet :studio, name: 'Studio'
+  range :price, name: 'Price'
+end
+
+studios = []
+%w{A B C D}.each do |suffix|
+  studios << Studio.create!(name: "Studio #{suffix}")
+end
+
+rand = Random.new
+%w{Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren}.each_with_index do |title, index|
+  Movie.create!(title: title, studio: studios[index % studios.length], price: rand.rand(20.0))
+end
+
+class SmokeTest < Minitest::Test
+
+  def test_it_finds_all_movies
+    search = MovieSearch.new({})
+    assert_equal Movie.all.size, search.result.size
+  end
+
+  def test_text_filter
+    search = MovieSearch.new({'search' => { title: 'ipsum' }})
+    assert_equal 1, search.result.size
+    assert_equal 'ipsum', search.result.first.title
+  end
+
+  def test_belongs_to_filter
+    blank_search = MovieSearch.new
+    first_facet_value = blank_search.filter(:studio).facet.first
+    studio = first_facet_value.entity
+    assert_kind_of Studio, studio
+
+    movies_with_studio = Movie.where(studio: studio)
+    search_with_studio = blank_search.filter(:studio).add(studio)
+
+    assert_equal movies_with_studio.size, search_with_studio.result.size
+    assert_equal movies_with_studio.size, first_facet_value.count
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forty_facets
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Axel Tetzlaff
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-19 00:00:00.000000000 Z
+date: 2014-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,62 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: coveralls
+  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: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
 description: FortyFacets lets you easily build explorative search interfaces based
   on fields of your active_record models.
 email:
@@ -46,7 +102,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".coveralls.yml"
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -54,7 +112,16 @@ files:
 - forty_facets.gemspec
 - lib/forty_facets.rb
 - lib/forty_facets/facet_search.rb
+- lib/forty_facets/filter.rb
+- lib/forty_facets/filter/belongs_to.rb
+- lib/forty_facets/filter/range_filter_definition.rb
+- lib/forty_facets/filter/text_filter_definition.rb
+- lib/forty_facets/filter_definition.rb
+- lib/forty_facets/order.rb
+- lib/forty_facets/order_definition.rb
 - lib/forty_facets/version.rb
+- test/smoke_test.rb
+- test/test_helper.rb
 homepage: https://github.com/fortytools/forty_facets
 licenses:
 - MIT
@@ -79,4 +146,6 @@ rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Library for building facet searches for active_record models
-test_files: []
+test_files:
+- test/smoke_test.rb
+- test/test_helper.rb