recordselect-custom 0.0.1

data/assets/stylesheets/record_select.css

@@ -0,0 +1,129 @@
+.record-select {
+  width: 300px;
+  border: 1px solid #afd0f5;
+  font-family: sans-serif;
+  background-color: #fff;
+  font-size: 11px;
+}
+
+.record-select img {
+  border-width: 0px;
+}
+
+.record-select form {
+  display: inline;
+}
+
+.record-select form .text-input {
+  width: 294px;
+  margin: 2px auto 1px auto;
+  display: block;
+  border: 1px solid #999;
+}
+
+.record-select form input.example {
+  color: #999;
+  text-align: center;
+}
+
+.record-select ol,
+.record-select li {
+  margin: 0px;
+  padding: 0px;
+  list-style: none;
+  clear: both;
+}
+
+.record-select a {
+  color: #0066cc;
+  text-decoration: none;
+}
+
+.record-select ol a {
+  display: block;
+  zoom: 1;
+  background-color: #e6f2ff;
+  padding: 2px 4px;
+}
+
+.record-select ol .even a {
+  background-color: #ffffff;
+}
+
+.record-select ol .pagination a {
+  background-color: #eee;
+}
+
+.record-select ol .previous a {
+  border-bottom: 1px solid #afd0f5;
+}
+
+.record-select ol .next a {
+  border-top: 1px solid #afd0f5;
+}
+
+.record-select ol .pagination a img {
+  vertical-align: middle;
+}
+
+.record-select ol .found {
+  text-align: center;
+  font-style: italic;
+  color: #999;
+  padding: 1px 4px;
+  border-bottom: 1px solid #afd0f5;
+}
+
+.record-select ol .current a,
+.record-select ol a:hover {
+  background-color: #ffff88;
+}
+
+.record-select ol a.selected {
+  background-color: #666;
+  color: #fff;
+}
+
+.record-select-container {
+  position: absolute;
+  z-index: 100;
+}
+
+iframe.record-select-mask {
+  /* to mask windowed elements in IE6 */
+  position: absolute;
+  z-index: 99;
+  filter: progid:DXImageTransform.Microsoft.Alpha(style=0,opacity=0);
+}
+
+.record-select-autocomplete form .text-input {
+  display: none;
+}
+
+.record-select-list {
+  padding: 0px;
+  margin: 0px;
+  list-style: none;
+}
+
+.record-select-list li {
+  overflow: auto;
+  zoom: 1;
+  margin-left: 10px;
+  font-size: 80%;
+}
+
+.record-select-list label {
+  float: left;
+}
+
+.record-select-list a.remove {
+  display: block;
+  width: 0px;
+  height: 16px;
+  padding-left: 16px;
+  background: url('../../images/record_select/cross.gif') no-repeat 0 0;
+  overflow: hidden;
+  float: left;
+  margin-right: 5px;
+}

data/config/locales/en.yml

@@ -0,0 +1,5 @@
+en:
+  recordselect:
+    found: Found
+    next: Next
+    previous: Previous

data/config/locales/zh.yml

@@ -0,0 +1,5 @@
+zh:
+  recordselect:
+    found: 找到
+    next: 下页
+    previous: 上页

data/init.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/lib/localization'
+require File.dirname(__FILE__) + '/lib/extensions/active_record'
+
+ActionController::Base.send(:include, RecordSelect)
+ActionView::Base.send(:include, RecordSelect::Helpers)
+ActionView::Helpers::FormBuilder.send(:include, RecordSelect::FormBuilder)
+
+['stylesheets', 'images', 'javascripts'].each do |asset_type|
+  public_dir = File.join(RAILS_ROOT, 'public', asset_type, 'record_select')
+  local_dir = File.join(File.dirname(__FILE__), 'assets', asset_type)
+  FileUtils.mkdir public_dir unless File.exists? public_dir
+  Dir.entries(local_dir).each do |file|
+    next if file =~ /^\./
+    FileUtils.cp File.join(local_dir, file), public_dir
+  end
+end

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/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/localization.rb

@@ -0,0 +1,8 @@
+# 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_(string_to_localize, *args)
+    args.empty? ? string_to_localize : (sprintf string_to_localize, *args)
+  end
+end

data/lib/record_select.rb

@@ -0,0 +1,33 @@
+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.
+    #
+    # 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,60 @@
+module RecordSelect
+  module Actions
+    # :method => :get
+    # params => [:page, :search]
+    def browse
+      conditions = record_select_conditions
+      klass = record_select_config.model
+      count = klass.count(:conditions => conditions, :include => record_select_includes)
+      pager = ::Paginator.new(count, (params[:per_page] || record_select_config.per_page).to_i) do |offset, per_page|
+        klass.find(:all,
+          :offset => offset,
+          :include => [record_select_includes, record_select_config.include].flatten.compact,
+          :limit => per_page,
+          :conditions => conditions,
+          :order => record_select_config.order_by
+        )
+      end
+      @page = pager.page(params[:page] || 1)
+
+      render_record_select((params[:update] ? 'browse.rjs' : '_browse.rhtml')) and return if params[:format] == "js"
+      render_record_select '_browse.rhtml', :layout => true
+    end
+
+    # :method => :post
+    # params => [:id]
+    def select
+      klass = record_select_config.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(file, options = {}) #:nodoc:
+      options[:layout] ||= false
+      options[:file] = record_select_path_of(file)
+      options[:use_full_path] = false
+      render options
+    end
+
+    private
+
+    def record_select_views_path
+      @record_select_views_path ||= "vendor/plugins/#{File.expand_path(__FILE__).match(/vendor\/plugins\/(\w*)/)[1]}/lib/views"
+    end
+
+    def record_select_path_of(template)
+      File.join(RAILS_ROOT, record_select_views_path, template)
+    end
+  end
+end

data/lib/record_select/conditions.rb

@@ -0,0 +1,88 @@
+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
+
+    # 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?
+        tokens = params[:search].strip.split(' ')
+
+        where_clauses = record_select_config.search_on.collect { |sql| "#{sql} LIKE ?" }
+        phrase = "(#{where_clauses.join(' OR ')})"
+
+        sql = ([phrase] * tokens.length).join(' AND ')
+        tokens = tokens.collect{ |value| [search_pattern.sub('?', value.downcase)] * 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 value.is_a?(Array)
+        ["#{column.name} IN (?)", value.map{|v| column.type_cast(v)}]
+      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,84 @@
+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
+
+      @order_by = options[:order_by]
+
+      @full_text_search = options[:full_text_search]
+
+      @label = options[:label]
+
+      @include = options[:include]
+    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.primary_key} ASC"
+    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
+
+    protected
+
+    # A singularized underscored version of the model we're browsing
+    def klass
+      @klass
+    end
+  end
+end