Merge pull request #2 from fortytools/development

merged ordered facet

README.md

@@ -99,6 +99,25 @@ Use the search object to display further narrowing options to the user
             = link_to genre.name, filter.add(genre).path
             %span.count= "(#{facet_value.count})"
 ```
+## API
+
+### Base class
+
+To create a custom search subclass `FortyFacets::FacetSearch`.
+
+```ruby
+class MySearch
+  model 'MyActiveRecordModel' # replace this with an class name from your models folder
+end
+```
+
+### Available declaration methods
+| keyword | options       |                                                                                                                         |
+|---------|---------------|-------------------------------------------------------------------------------------------------------------------------|
+| text    | prefix:true   | creates a filter to limit search result to entities containing the filter value in the given field                      |
+| facet   |               | creates a facetted filter on the specified model attribute (attribute or belongs_to)                                    |
+| range   |               | creates a range filter (param format 'FROM - TO') limiting result to entities with values in that range              | 
+| orders  |               | takes a hash mapping a label to an argument that the active record `order` method can be called with to sort the result |
 
 ## FAQ
 

lib/forty_facets/facet_search.rb

@@ -32,11 +32,11 @@ def range(model_field, opts = {})
       end
 
       def facet(model_field, opts = {})
-        definitions << BelongsToFilterDefinition.new(self, model_field, opts)
-      end
-
-      def facet_attr(model_field, opts = {})
-        definitions << AttributeFilterDefinition.new(self, model_field, opts)
+        if self.root_scope.reflect_on_association(model_field)
+          definitions << BelongsToFilterDefinition.new(self, model_field, opts)
+        else
+          definitions << AttributeFilterDefinition.new(self, model_field, opts)
+        end
       end
 
       def orders(name_and_order_options)

lib/forty_facets/filter.rb

@@ -7,10 +7,6 @@ def name
       filter_definition.options[:name] || filter_definition.model_field
     end
 
-    def values
-      @values ||= Array.wrap(value).sort.uniq
-    end
-
     def empty?
       value.nil? || value == '' || value == []
     end
@@ -24,5 +20,29 @@ def without
       search_instance.class.new_unwrapped(new_params)
     end
   end
+
+  # Base class for filter with multiple values and grouped facet values
+  class FacetFilter < Filter
+    def values
+      @values ||= Array.wrap(value).sort.uniq
+    end
+
+      protected
+
+      def order_facet!(facet)
+        order_accessor = filter_definition.options[:order]
+        if order_accessor
+          if order_accessor.is_a?(Proc)
+            facet.sort_by!{|facet_value| order_accessor.call(facet_value.entity) }
+          else
+            facet.sort_by!{|facet_value| facet_value.entity.send(order_accessor) }
+          end
+        else
+          facet.sort_by!{|facet_value| -facet_value.count }
+        end
+        facet
+      end
+
+  end
 end
 

lib/forty_facets/filter/attribute_filter_definition.rb

@@ -1,6 +1,6 @@
 module FortyFacets
   class AttributeFilterDefinition < FilterDefinition
-    class AttributeFilter < Filter
+    class AttributeFilter < FacetFilter
       def selected
         entity = search_instance.class.root_class
         column = entity.columns_hash[filter_definition.model_field.to_s]
@@ -15,10 +15,12 @@ def build_scope
       def facet
         my_column = filter_definition.model_field
         counts = without.result.reorder('').select("#{my_column} AS facet_value, count(#{my_column}) as occurrences").group(my_column)
-        counts.map do |c|
+        facet = counts.map do |c|
           is_selected = selected.include?(c.facet_value)
           FacetValue.new(c.facet_value, c.occurrences, is_selected)
         end
+
+        order_facet!(facet)
       end
 
       def remove(value)

lib/forty_facets/filter/belongs_to_filter_definition.rb

@@ -1,6 +1,6 @@
 module FortyFacets
   class BelongsToFilterDefinition < FilterDefinition
-    class FacetFilter < Filter
+    class BelonsToFilter < FacetFilter
       def association
         filter_definition.search.root_class.reflect_on_association(filter_definition.model_field)
       end
@@ -48,21 +48,10 @@ def add(entity)
         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)
+      BelonsToFilter.new(self, search_instance, param_value)
     end
 
   end

test/smoke_test.rb

@@ -39,7 +39,7 @@ class MovieSearch < FortyFacets::FacetSearch
 
   text :title, name: 'Title'
   facet :studio, name: 'Studio'
-  facet_attr :year
+  facet :year, order: Proc.new {|year| -year}
   range :price, name: 'Price'
 end
 
@@ -116,4 +116,10 @@ def test_belongs_to_filter
     assert_equal movies_with_studio.size, first_facet_value.count
   end
 
+  def test_sort_by_proc
+    blank_search = MovieSearch.new
+    facet_entities = blank_search.filter(:year).facet.map(&:entity)
+    assert_equal Movie.all.map(&:year).sort.uniq.reverse, facet_entities
+  end
+
 end