recordselect 3.2.4 → 3.2.5

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

@@ -1,8 +0,0 @@
-<%
-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

@@ -1,31 +0,0 @@
-<%
-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

@@ -1,20 +0,0 @@
-<% 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

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

data/config/locales/en.yml

@@ -1,9 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

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

data/lib/record_select/extensions/active_record.rb

@@ -1,9 +0,0 @@
-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

@@ -1,13 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-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