facet_for 0.0.1 → 0.0.3

data/.gitignore

@@ -2,3 +2,6 @@
 .bundle
 Gemfile.lock
 pkg/*
+\#*#
+.\#*#
+

data/README.textile

@@ -0,0 +1,8 @@
+h1. facet_for
+
+facet_for is a collection of FormBuilder helpers that speed up the process of
+creating complex search forms with "Ransack":http://github.com/ernie/ransack
+
+h2. Installation
+
+Simply include 'facet_for' in your Gemfile

data/lib/facet_for/facet_helper.rb

@@ -0,0 +1,16 @@
+module FacetHelper
+  def render_facets(object, view)
+    facet_html = ''
+
+    view.meta_select.meta_select_facets.each do |facet|
+      facet_html << FacetFor.create_facet(:object => object,
+                                          :object_name => 'q',
+                                          :type => facet.predicate.to_sym,
+                                          :column_name => facet.column_name,
+                                          :params => params)
+    end
+    facet_html.html_safe
+  end
+end
+
+ActionView::Base.send :include, FacetHelper

data/lib/facet_for/form_builder.rb

@@ -0,0 +1,52 @@
+class ActionView::Helpers::FormBuilder
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::FormTagHelper
+  include ActionView::Helpers::FormOptionsHelper
+  include ActionView::Helpers::CaptureHelper
+  include ActionView::Helpers::AssetTagHelper
+
+  def facet_for(column, *args)
+
+    options = args.extract_options!
+
+    facet_html = ''
+
+    # Here, we collect information about the facet. What the user doesn't
+    # supply, we'll make our best guess for.
+
+    facet = { }
+    facet[:object] = @object
+    facet[:object_name] = @object_name
+    # Information about the column. This is used to generate the default
+    # label, and to pass the right selector to the Ransack fields.
+
+    facet[:column_name] = column
+    facet[:column_type] = options[:column_type]
+
+    # This is the type of field we will render. If this isn't provided, we'll
+    # determine this based on facet_column_type
+
+    facet[:type] = options[:type]
+
+    # Did we pass in the params? Send it down to determine if we have a value.
+
+    facet[:params] = options[:params]
+
+    # In the specific case of facet_type == :collection, we'll allow the user
+    # to specify their own collection. If it's an association, we'll attempt
+    # to provide one.
+
+    facet[:collection] = options[:collection]
+
+    # Are we labeling it differently?
+    facet[:label] = options[:label]
+
+    @facet = FacetFor::Facet.new(facet)
+
+    facet_html << @facet.render_facet
+
+    facet_html.html_safe
+  end
+
+
+end

data/lib/facet_for/version.rb

@@ -1,3 +1,3 @@
 module FacetFor
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/lib/facet_for.rb

@@ -1,176 +1,273 @@
 require "facet_for/version"
+require "facet_for/form_builder"
+require "facet_for/facet_helper"
+
+module FacetFor
+
+  PREDICATES = [
+                ['Contains', :cont],
+                ['Doesn\'t Contain', :not_cont],
+                ['Starts With', :start],
+                ['Doesn\'t Start With', :not_start],
+                ['Ends With', :end],
+                ['Doesn\'t End With', :not_end],
+                ['Between', :between],
+                ['Is Null', :null],
+                ['Is Not Null', :not_null],
+                ['Collection', :collection]
+               ]
+
+  def self.predicates
+    PREDICATES
+  end
 
-class ActionView::Helpers::FormBuilder
-  include ActionView::Helpers::TagHelper
-  include ActionView::Helpers::FormTagHelper
-  include ActionView::Helpers::FormOptionsHelper
-  include ActionView::Helpers::CaptureHelper
-  include ActionView::Helpers::AssetTagHelper
+  # We can use reflections to determine has_many and belongs_to associations
 
-  def facet_for(column, *args)
+  def self.create_facet(*args)
     options = args.extract_options!
 
-    facet_html = ''
+    @facet = Facet.new(options)
+    @facet.render_facet.html_safe
+  end
+
 
-    # Here, we collect information about the facet. What the user doesn't
-    # supply, we'll make our best guess for.
+  def self.column_options(q)
+    column_options = []
+    column_options.push([q.klass.to_s, options_for_model(q.klass)])
 
-    facet = { }
-    facet[:model] = @object.klass
+    q.context.searchable_associations.each do |association|
+      association_model = association.camelcase.singularize.constantize
+      column_options.push([association_model.to_s, options_for_model(association_model, association)])
+    end
 
-    facet[:column] = facet[:model].content_columns.select {                                      |x| x.name == column.to_s }
+    column_options
+  end
 
-    # Information about the column. This is used to generate the default
-    # label, and to pass the right selector to the Ransack fields.
+  def self.field_options(q)
+    field_options = options_for_model(q.klass) | q.context.searchable_associations.map { |a| [a.titleize, a.to_sym] }
 
-    facet[:column_name] = options[:column_name]
-    facet[:column_type] = options[:column_type]
+    field_options
+  end
 
-    # This is the type of field we will render. If this isn't provided, we'll
-    # determine this based on facet_column_type
+  def self.options_for_model(model, association = nil, grouped = false)
+    options = []
+    preface = ''
 
-    facet[:type] = options[:type]
+    if association # preface field names for cross model displaying
+      preface = "#{association}."
+    end
 
-    # In the specific case of facet_type == :collection, we'll allow the user
-    # to specify their own collection. If it's an association, we'll attempt
-    # to provide one.
+    if model.ransackable_attributes
+      options = model.ransackable_attributes.map { |a| [a.titleize, "#{preface}#{a}".to_sym] }
+    end
 
-    facet[:collection] = options[:collection]
+    options
+  end
 
-    if facet[:column].empty? # facet doesn't exist
+  class Facet
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::FormTagHelper
+    include ActionView::Helpers::FormOptionsHelper
+    include ActionView::Helpers::CaptureHelper
+    include ActionView::Helpers::AssetTagHelper
 
-      # Is it an association?
-      #
-      # We check for :singular_name, :plural_name and :singular_id
+    attr_accessor :facet
 
-      if association = associations_for(facet[:model]).select { |x|
-          x.plural_name == column.to_s or
-          x.plural_name.singularize == column.to_s or
-          x.primary_key_name == column.to_s }.uniq
+    def initialize(facet = {})
+      @facet = facet
 
-        if association.first.macro == :has_many
+      # If they didn't provide a model, try and use the search object
 
-          # For a has_many relationship, we want the plural name with _id.
-          # Ransack will then look at the _id column for the associated model.
-          # This won't work properly on models with nonstandard id column
-          # names. That's a problem, but whatevs for the time being.
+      if @facet[:object] && @facet[:model].nil?
+        @facet[:model] = @facet[:object].klass
+      end
 
-          facet[:column_name] = "#{association.first.plural_name}_id"
+      @facet[:column] = @facet[:model].content_columns.select {                                      |x| x.name == @facet[:column_name].to_s }
 
-        elsif association.first.macro == :belongs_to
+      if @facet[:column].empty? # facet doesn't exist
 
-          # If we're dealing with belongs_to, we can assume we just want
-          # to look at the foreign key on the current model. Much simpler.
+        # Is it an association?
+        #
+        # We check for :singular_name, :plural_name and :singular_id
 
-          facet[:column_name] = association.first.foreign_key
+        if association = associations.select { |x|
+          x.plural_name == @facet[:column_name].to_s or
+          x.plural_name.singularize == @facet[:column_name].to_s or
+          x.primary_key_name == @facet[:column_name].to_s }.uniq and association.count > 0
 
-        end
+          if association.first.macro == :has_many
 
-        # By default, we want to use a select box with a collection of
-        # what this model has_many of. If the user has specified something,
-        # we'll run with what they specified.
+            # For a has_many relationship, we want the plural name with _id.
+            # Ransack will then look at the _id column for the associated model.
+            # This won't work properly on models with nonstandard id column
+            # names. That's a problem, but whatevs for the time being.
 
-        facet[:type] = facet[:type] || :collection
+            @facet[:column_name] = "#{association.first.plural_name}_id"
 
-        # If the user hasn't specified a collection, we'll provide one now
-        # based on this association
+          elsif association.first.macro == :belongs_to
 
-        facet[:collection] = facet[:collection] || association.first.klass.all
+            # If we're dealing with belongs_to, we can assume we just want
+            # to look at the foreign key on the current model. Much simpler.
 
+            @facet[:column_name] = association.first.foreign_key
+
+          end
+
+          # By default, we want to use a select box with a collection of
+          # what this model has_many of. If the user has specified something,
+          # we'll run with what they specified.
+
+          @facet[:type] = @facet[:type] || :collection
+
+          # If the user hasn't specified a collection, we'll provide one now
+          # based on this association
+
+          @facet[:collection] = @facet[:collection] || association.first.klass.all
+        end
       else
-        return # nothing found
+
+        # We found a column. Let's yank some useful information out of it
+        @facet[:column] = @facet[:column].first
+        @facet[:column_name] = @facet[:column].name
+        @facet[:column_type] = @facet[:column_type] || @facet[:column].type
       end
-    else
 
-      # We found a column. Let's yank some useful information out of it
+      @facet[:type] = @facet[:type] || default_facet_type
 
-      facet[:column] = facet[:column].first
-      facet[:column_name] = facet[:column].name
-      facet[:column_type] = facet[:column_type] || facet[:column].type
     end
 
-    facet[:type] = facet[:type] || default_facet_type(facet)
+    def associations
+      @facet[:model].reflections.values
+    end
 
+    # If the user doesn't pass options[:label], we'll build a default label
+    # based on the type of facet we're rendering.
+
+    def default_label_for_facet
+      case @facet[:type]
+      when :true, :false
+        return ''
+      when :null
+        return label("#{@facet[:column_name]}_null",
+                     "#{@facet[:column_name].to_s.humanize} Is Null?")
+      when :not_null
+        return label("#{@facet[:column_name]}_not_null",
+                     "#{@facet[:column_name].to_s.humanize} Is Not Null?")
+      when :cont
+        return label("#{@facet[:column_name]}_cont",
+                     "#{@facet[:column_name].to_s.humanize} Contains")
+      when :not_cont
+        return label("#{@facet[:column_name]}_not_cont",
+                     "#{@facet[:column_name].to_s.humanize} Doesn't Contain")
+      when :start
+        return label("#{@facet[:column_name]}_start",
+                     "#{@facet[:column_name].to_s.humanize} Starts With")
+      when :not_start
+        return label("#{@facet[:column_name]}_not_start",
+                     "#{@facet[:column_name].to_s.humanize} Doesn't Start With")
+      when :end
+        return label("#{@facet[:column_name]}_end",
+                     "#{@facet[:column_name].to_s.humanize} Ends With")
+      when :not_end
+        return label("#{@facet[:column_name]}_not_end",
+                     "#{@facet[:column_name].to_s.humanize} Doesn't End With")
+      when :between
+        return label("#{@facet[:column_name]}",
+                     "#{@facet[:column_name].to_s.humanize} Between")
+      when :gte
+        return label("#{@facet[:column_name]}_gte",
+                     "#{@facet[:column_name].to_s.humanize} Greater Than")
+      when :lte
+        return label("#{@facet[:column_name]}_lte",
+                     "#{@facet[:column_name].to_s.humanize} Less Than")
+      else
+        return label("#{@facet[:column_name]}")
+      end
+    end
 
-    # Insert our label first
+    # Now that we have our type, we can render the actual form field for
+    # Ransack
 
-    facet_html = "<div class=\"label #{additional_classes(facet)}\">"
+    def render_facet
 
-    if options[:label]
-      facet_html << self.label(column, options[:label])
-    else
-      facet_html << default_label_for_facet(facet)
-    end
+      # Insert our label first
+
+      facet_html = "<div class=\"facet_label #{additional_classes}\">"
 
-    facet_html << "</div>"
+      if @facet[:label]
+        facet_html << label("#{@facet[:column_name]}", @facet[:label])
+      else
+        facet_html << default_label_for_facet
+      end
 
-    # And now the fields
+      facet_html << "</div>"
 
-    facet_html << render_facet_for(facet)
+      # And now the fields
 
-    facet_html.html_safe
-  end
+      facet_html << "<div class=\"facet_input #{additional_classes}\">"
 
-  # If the user doesn't pass options[:label], we'll build a default label
-  # based on the type of facet we're rendering.
+      case @facet[:type]
+      when :cont, :not_cont, :start, :not_start, :end, :not_end, :gteq, :lteq
+        facet_html << text_field
+      when :collection
+        facet_html << facet_collection
+      when :null, :not_null, :true, :false
+        facet_html << check_box
+      when :between
+        facet_html << text_field(:predicate => :gteq)
+        facet_html << "<span class=\"facet_divider\">&mdash;</span>"
+        facet_html << text_field(:predicate => :lteq)
+      end
 
-  def default_label_for_facet(facet)
-    case facet[:type]
-    when :cont
-      return self.label("#{facet[:column_name]}_cont".to_sym)
-    else
-      return self.label("#{facet[:column_name]}")
+      facet_html << "</div>"
+      facet_html
     end
-  end
 
-  # Now that we have our type, we can render the actual form field for
-  # Ransack
-
-  def render_facet_for(facet)
-
-    facet_html = "<div class=\"input #{additional_classes(facet)}\">"
-
-    case facet[:type]
-    when :cont
-      facet_html << self.text_field("#{facet[:column_name]}_cont".to_sym)
-    when :collection
-      facet_html << self.collection_select("#{facet[:column_name]}_eq".to_sym, facet[:collection], :id, :to_s, :include_blank => true)
-    when :between
-      facet_html << "From "
-      facet_html << self.text_field("#{facet[:column_name]}_gteq".to_sym, :size => 11)
-      facet_html << "To "
-      facet_html << self.text_field("#{facet[:column_name]}_lteq".to_sym, :size => 11)
-    when :gteq
-      facet_html << self.text_field("#{facet[:column_name]}_gteq".to_sym, :size => 5)
-    when :lteq
-      facet_html << self.text_field("#{facet[:column_name]}_gteq".to_sym, :size => 5)
+    # If no options[:type] is specified, we'll look at the column type for
+    # the column in the model and make an educated guess.
+
+    def default_facet_type
+
+      case @facet[:column_type]
+      when :string, :text
+        return :cont
+      when :datetime, :date, :float, :integer, :double
+        return :between
+      end
     end
 
-    facet_html << "</div>"
-    facet_html
-  end
+    def additional_classes
+      additional_class = "#{@facet[:type]} #{@facet[:column_type]}"
+    end
 
-  # If no options[:type] is specified, we'll look at the column type for
-  # the column in the model and make an educated guess.
+    def text_field(options = {})
+      predicate = options[:predicate] || @facet[:type]
+      name = "#{@facet[:column_name]}_#{predicate.to_s}"
 
-  def default_facet_type(facet)
+      if @facet[:params] and @facet[:params][:q]
+        value = @facet[:params][:q][name.to_sym]
+      end
 
-    case facet[:column_type]
-    when :string, :text
-      return :cont
-    when :datetime, :date, :float, :integer, :double
-      return :between
+      text_field_tag self.name_for(name), value
     end
-  end
 
-  def additional_classes(facet)
-    additional_class = "#{facet[:type]} #{facet[:column_type]}"
-  end
+    def check_box
+      check_box_tag self.name_for("#{@facet[:column_name]}_#{@facet[:type].to_s}")
+    end
 
-  # We can use reflections to determine has_many and belongs_to associations
+    def facet_collection
+      collection_select @facet[:object_name].to_sym,
+        "#{@facet[:column_name]}_eq".to_sym, @facet[:collection],
+        :id, :to_s, :include_blank => true
+    end
 
-  def associations_for(model)
-    model.reflections.values
-  end
+    def label(string_name, string_label = nil)
+      display_label = string_label || string_name.humanize
+      label_tag self.name_for(string_name), display_label
+    end
 
+    def name_for(string_name)
+      "#{@facet[:object_name]}[#{string_name}]".to_sym
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: facet_for
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-19 00:00:00.000000000Z
+date: 2011-10-28 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ransack
-  requirement: &84397210 !ruby/object:Gem::Requirement
+  requirement: &79711100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *84397210
+  version_requirements: *79711100
 description: Provides helpers for creating search forms with Ransack
 email:
 - jbarket@sleepunit.com
@@ -31,9 +31,12 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- README.textile
 - Rakefile
 - facet_for.gemspec
 - lib/facet_for.rb
+- lib/facet_for/facet_helper.rb
+- lib/facet_for/form_builder.rb
 - lib/facet_for/version.rb
 homepage: ''
 licenses: []