recordselect 3.2.5 → 3.2.6

data/app/views/record_select/_browse.html.erb

@@ -0,0 +1,8 @@
+<%
+controller ||= params[:controller]
+record_select_id = record_select_id(controller)
+-%>
+<div class="record-select" id="<%= record_select_id -%>">
+  <%= render_record_select :partial => 'search', :locals => {:controller => controller, :record_select_id => record_select_id} %>
+  <%= render_record_select :partial => 'list', :locals => {:controller => controller, :page => @page, :record_select_id => record_select_id} %>
+</div>

data/app/views/record_select/_list.html.erb

@@ -0,0 +1,31 @@
+<%
+controller ||= params[:controller]
+
+pagination_url_params = params.merge(:controller => controller, :action => :browse, :search => params[:search], :update => 1)
+prev_url = url_for(pagination_url_params.merge(:page => page.prev.number, :escape => false)) if page.prev?
+next_url = url_for(pagination_url_params.merge(:page => page.next.number, :escape => false)) if page.next?
+-%>
+<ol>
+  <li class="found"><%= rs_(:records_found, :count => page.pager.count,
+:model => record_select_config.model.model_name.human(:count => page.pager.count).downcase) %></li>
+  <% if page.prev? -%>
+  <li class="pagination previous">
+    <%= link_to image_tag('record_select/previous.gif', :alt => rs_(:previous)) + " " + rs_(:previous_items,
+:count => page.pager.per_page),
+                      {:url => prev_url},
+                      {:href => prev_url, :method => :get, :remote => true} %>
+  </li>
+  <% end -%>
+  <% page.items.each do |record| -%>
+  <li class="record <%= cycle 'odd', 'even' %>" id="rs<%= record.id -%>">
+    <%= render_record_in_list(record, controller) %>
+  </li>
+  <% end -%>
+  <% if page.next? -%>
+  <li class="pagination next">
+  <%= link_to (rs_(:next_items, :count => page.pager.per_page) + " " + image_tag('record_select/next.gif', :alt => rs_(:next))).html_safe,
+                        {:url => next_url},
+                        {:href => next_url, :method => :get, :remote => true} %>
+  </li>
+  <% end -%>
+</ol>

data/app/views/record_select/_search.html.erb

@@ -0,0 +1,20 @@
+<% url_options = params.merge(:controller => controller, :action => :browse, :page => 1, :update => 1, :escape => false) -%>
+<%= form_tag url_options, {:method => :get, :remote => true, :id => record_select_search_id}  -%>
+  <%= text_field_tag 'search', params[:search], :autocomplete => 'off', :class => 'text-input' %>
+  <%= submit_tag 'search', :class => "search_submit" %>
+</form>
+
+<script type="text/javascript">
+  //<![CDATA[
+<% if RecordSelect::Config.js_framework == :prototype %>
+  var i = $(<%= record_select_search_id.to_json.html_safe %>).down('input.text-input');
+  Form.Element.AfterActivity(i, function() {
+      $(<%= record_select_search_id.to_json.html_safe -%>).down('input.search_submit').click();
+  }, 0.35);
+<% elsif RecordSelect::Config.js_framework == :jquery %>
+  jQuery(<%= "##{record_select_search_id}".to_json.html_safe %>).find('input.text-input').delayedObserver(0.35, function() {
+     jQuery(<%= "##{record_select_search_id}".to_json.html_safe %>).trigger("submit");});
+<% end %>
+  //]]>
+</script>
+  

data/app/views/record_select/browse.js.erb

@@ -0,0 +1 @@
+RecordSelect.render_page('<%= record_select_id %>', '<%= escape_javascript(render_record_select(:partial => 'list', :locals => {:page => @page})) %>');

data/config/locales/en.yml

@@ -0,0 +1,9 @@
+en:
+  record_select:
+    next: "Next"
+    next_items: "Next %{count}"
+    previous: "Previous"
+    previous_items: "Previous %{count}"
+    records_found:
+      one: "1 %{model} found"
+      other: "%{count} %{model} found"

data/config/locales/es.yml

@@ -0,0 +1,13 @@
+es:
+  record_select:
+    next: "Siguiente"
+    next_items:
+      one: "Siguente"
+      other: "%{count} siguentes"
+    previous: "Anterior"
+    previous_items:
+      one: "Anterior"
+      other: "%{count} anteriores"
+    records_found:
+      one: "1 %{model} encontrado"
+      other: "%{count} %{model} encontrados"

data/lib/record_select.rb

@@ -0,0 +1,36 @@
+module RecordSelect
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+  module ClassMethods
+    # Enables and configures RecordSelect on your controller.
+    #
+    # *Options*
+    # +model+::     defaults based on the name of the controller
+    # +per_page+::  records to show per page when browsing
+    # +notify+::    a method name to invoke when a record has been selected.
+    # +order_by+::  a SQL string to order the search results
+    # +search_on+:: an array of searchable fields
+    # +full_text_search+::  a boolean for whether to use a %?% search pattern or not. default is false.
+    # +label+::     a proc that accepts a record as argument and returns an option label. default is to call record.to_label instead.
+    # +include+::   as for ActiveRecord::Base#find. can help with search conditions or just help optimize rendering the results.
+    # +link+::      a boolean for whether wrap the text returned by label in a link or not. default is true. set to false when
+    #               label returns html code which can't be inside a tag. You can use record_select_link_to_select in your proc
+    #               or partial to add a link to select action
+    #
+    # You may also pass a block, which will be used as options[:notify].
+    def record_select(options = {})
+      options[:model] ||= self.to_s.split('::').last.sub(/Controller$/, '').pluralize.singularize.underscore
+      @record_select_config = RecordSelect::Config.new(options.delete(:model), options)
+      self.send :include, RecordSelect::Actions
+      self.send :include, RecordSelect::Conditions
+    end
+
+    attr_reader :record_select_config
+
+    def uses_record_select?
+      !record_select_config.nil?
+    end
+  end
+end

data/lib/record_select/actions.rb

@@ -0,0 +1,68 @@
+module RecordSelect
+  module Actions
+    # :method => :get
+    # params => [:page, :search]
+    def browse
+      conditions = record_select_conditions
+      klass = record_select_model.where(conditions).includes(record_select_includes)
+      @count = klass.count
+      @count = @count.length if @count.is_a? ActiveSupport::OrderedHash
+      pager = ::Paginator.new(@count, record_select_config.per_page) do |offset, per_page|
+        klass.select(record_select_select).includes(record_select_config.include).order(record_select_config.order_by).limit(per_page).offset(offset).all
+      end
+      @page = pager.page(params[:page] || 1)
+
+      respond_to do |wants|
+        wants.html { render_record_select :partial => 'browse'}
+        wants.js {
+          if params[:update]
+            render_record_select :template => 'browse.js', :layout => false
+          else
+            render_record_select :partial => 'browse'
+          end
+        }
+        wants.yaml {}
+        wants.xml {}
+        wants.json {}
+      end
+    end
+
+    # :method => :post
+    # params => [:id]
+    def select
+      klass = record_select_model
+      record = klass.find(params[:id])
+      if record_select_config.notify.is_a? Proc
+        record_select_config.notify.call(record)
+      elsif record_select_config.notify
+        send(record_select_config.notify, record)
+      end
+      render :nothing => true
+    end
+
+    protected
+
+    def record_select_config #:nodoc:
+      self.class.record_select_config
+    end
+
+    def render_record_select(options = {}) #:nodoc:
+      [:template,:partial].each do |template_name|
+        if options[template_name] then
+          options[template_name] = File.join(record_select_views_path, options[template_name])
+        end
+      end
+      if block_given? then yield options else render options end
+    end
+
+    private
+
+    def record_select_views_path
+      "record_select"
+    end
+  end
+
+  def record_select_model
+    record_select_config.model
+  end
+end

data/lib/record_select/conditions.rb

@@ -0,0 +1,100 @@
+module RecordSelect
+  module Conditions
+    protected
+    # returns the combination of all conditions.
+    # conditions come from:
+    # * current search (params[:search])
+    # * intelligent url params (e.g. params[:first_name] if first_name is a model column)
+    # * specific conditions supplied by the developer
+    def record_select_conditions
+      conditions = []
+
+      merge_conditions(
+        record_select_conditions_from_search,
+        record_select_conditions_from_params,
+        record_select_conditions_from_controller
+      )
+    end
+
+    # an override method.
+    # here you can provide custom conditions to define the selectable records. useful for situational restrictions.
+    def record_select_conditions_from_controller; end
+
+    # another override method.
+    # define any association includes you want for the finder search.
+    def record_select_includes; end
+
+    def record_select_like_operator
+      @like_operator ||= ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" ? "ILIKE" : "LIKE"
+    end
+
+    # define special list of selected fields,
+    # mainly to define extra fields that can be used for 
+    # specialized sorting.
+    def record_select_select; end
+
+    # generate conditions from params[:search]
+    # override this if you want to customize the search routine
+    def record_select_conditions_from_search
+      search_pattern = record_select_config.full_text_search? ? '%?%' : '?%'
+
+      if params[:search] and !params[:search].strip.empty?
+        if record_select_config.full_text_search?
+          tokens = params[:search].strip.split(' ')
+        else
+          tokens = []
+          tokens << params[:search].strip
+        end
+
+        where_clauses = record_select_config.search_on.collect { |sql| "#{sql} #{record_select_like_operator} ?" }
+        phrase = "(#{where_clauses.join(' OR ')})"
+
+        sql = ([phrase] * tokens.length).join(' AND ')
+        tokens = tokens.collect{ |value| [search_pattern.sub('?', value)] * record_select_config.search_on.length }.flatten
+
+        conditions = [sql, *tokens]
+      end
+    end
+
+    # instead of a shotgun approach, this assumes the user is
+    # searching vs some SQL field (possibly built with CONCAT())
+    # similar to the record labels.
+#    def record_select_simple_conditions_from_search
+#      return unless params[:search] and not params[:search].empty?
+#
+#      search_pattern = record_select_config.full_text_search? ? '%?%' : '?%'
+#      search_string = search_pattern.sub('?', value.downcase)
+#
+#      ["LOWER(#{record_select_config.search_on})", search_pattern.sub('?', value.downcase)]
+#    end
+
+    # generate conditions from the url parameters (e.g. users/browse?group_id=5)
+    def record_select_conditions_from_params
+      conditions = nil
+      params.each do |field, value|
+        next unless column = record_select_config.model.columns_hash[field]
+        conditions = merge_conditions(
+          conditions,
+          record_select_condition_for_column(column, value)
+        )
+      end
+      conditions
+    end
+
+    # generates an SQL condition for the given column/value
+    def record_select_condition_for_column(column, value)
+      if value.blank? and column.null
+        "#{column.name} IS NULL"
+      elsif column.text?
+        ["LOWER(#{column.name}) LIKE ?", value]
+      else
+        ["#{column.name} = ?", column.type_cast(value)]
+      end
+    end
+
+    def merge_conditions(*conditions) #:nodoc:
+      c = conditions.find_all {|c| not c.nil? and not c.empty? }
+      c.empty? ? nil : c.collect{|c| record_select_config.model.send(:sanitize_sql, c)}.join(' AND ')
+    end
+  end
+end

data/lib/record_select/config.rb

@@ -0,0 +1,103 @@
+module RecordSelect
+  # a write-once configuration object
+  class Config
+    def initialize(klass, options = {})
+      @klass = klass
+
+      @notify = block_given? ? proc : options[:notify]
+
+      @per_page = options[:per_page]
+
+      @search_on = [options[:search_on]].flatten unless options[:search_on].nil?
+
+      @order_by = options[:order_by]
+
+      @full_text_search = options[:full_text_search]
+
+      @label = options[:label]
+
+      @include = options[:include]
+
+      @link = options[:link]
+    end
+    
+    def self.js_framework=(framework)
+      @@js_framework = framework
+    end
+    
+    def self.js_framework
+      @@js_framework ||= if defined? Jquery
+        :jquery
+      elsif defined? PrototypeRails
+        :prototype
+      end
+    end
+
+    # The model object we're browsing
+    def model
+      @model ||= klass.to_s.camelcase.constantize
+    end
+
+    # Records to show on a page
+    def per_page
+      @per_page ||= 10
+    end
+
+    # The method name or proc to notify of a selection event.
+    # May not matter if the selection event is intercepted client-side.
+    def notify
+      @notify
+    end
+
+    # A collection of fields to search. This is essentially raw SQL, so you could search on "CONCAT(first_name, ' ', last_name)" if you wanted to.
+    # NOTE: this does *NO* default transforms (such as LOWER()), that's left entirely up to you.
+    def search_on
+      @search_on ||= self.model.columns.collect{|c| c.name if [:text, :string].include? c.type}.compact
+    end
+
+    def order_by
+      @order_by ||= "#{model.table_name}.#{model.primary_key} ASC" unless @order_by == false
+    end
+
+    def full_text_search?
+      @full_text_search ? true : false
+    end
+
+    def include
+      @include
+    end
+
+    # If a proc, must accept the record as an argument and return a descriptive string.
+    #
+    # If a symbol or string, must name a partial that renders a representation of the
+    # record. The partial should assume a local "record" variable, and should include a
+    # <label> tag, even if it's not visible. The contents of the <label> tag will be used
+    # to represent the record once it has been selected. For example:
+    #
+    #   record_select_config.label = :user_description
+    #
+    # > app/views/users/_user_description.erb
+    #
+    #   <div class="user_description">
+    #     <%= image_tag url_for_file_column(record, 'avatar') %>
+    #     <label><%= record.username %></label>
+    #     <p><%= record.quote %></p>
+    #   </div>
+    #
+    def label
+      @label ||= proc {|r| r.to_label}
+    end
+
+    # whether wrap the text returned by label in a link or not
+    def link?
+      @link.nil? ? true : @link
+    end
+
+    protected
+
+    # A singularized underscored version of the model we're browsing
+    def klass
+      @klass
+    end
+  end
+end

data/lib/record_select/engine.rb

@@ -0,0 +1,4 @@
+module RecordSelect
+  class Engine < Rails::Engine
+  end
+end

data/lib/record_select/extensions/active_record.rb

@@ -0,0 +1,9 @@
+module ActiveRecord # :nodoc:
+  class Base # :nodoc:
+    unless method_defined? :to_label
+    def to_label
+      self.to_s
+    end
+    end
+  end
+end

data/lib/record_select/extensions/localization.rb

@@ -0,0 +1,13 @@
+# Provides a simple pass-through localizer for RecordSelect. If you want
+# to localize RS, you need to override this method and route it to your
+# own system.
+class Object
+  def rs_(key, options = {})
+    unless key.blank?
+      text = I18n.translate "#{key}", {:scope => [:record_select], :default => key.is_a?(String) ? key : key.to_s.titleize}.merge(options)
+      # text = nil if text.include?('translation missing:')
+    end
+    text ||= key 
+    text
+  end
+end

data/lib/record_select/extensions/routing_mapper.rb

@@ -0,0 +1,20 @@
+module ActionDispatch
+  module Routing
+    RECORD_SELECT_ROUTING = {
+        :collection => {:browse => :get},
+        :member => {:select => :post}
+    }
+    class Mapper
+      module Base
+        def record_select_routes
+          collection do
+            ActionDispatch::Routing::RECORD_SELECT_ROUTING[:collection].each {|name, type| send(type, name)}
+          end
+          member do
+            ActionDispatch::Routing::RECORD_SELECT_ROUTING[:member].each {|name, type| send(type, name)}
+          end
+        end
+      end
+    end
+  end
+end