record_select 0.0.3 → 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 56baa2b6997087a496daf01af6384627370a645e
+  data.tar.gz: 65185867eb2f412ba164039caccf350a682a8a69
+SHA512:
+  metadata.gz: 6797a1f891e0b7004c40bcd5ac67a66faf80a0b3b956de0d24f41d3c9856d59994f47d8f50c18a5876a50a5d77851119484808d6370f9e5f5c9e63d97ded3447
+  data.tar.gz: 670ce6a3107aacd640969f403f3bf9f5c762d6dcd73b6d3215ffe9fdbf50c5190a1cd3d62760536ff454ea5132896dce39e5d6d6ec716bb5660c13b850ba7fb0

data/lib/record_select/version.rb

@@ -0,0 +1,3 @@
+module RecordselectCustom
+  VERSION = "0.0.4"
+end

data/lib/recordselect_custom/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/recordselect_custom/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/recordselect_custom/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

data/lib/recordselect_custom/form_builder.rb

@@ -0,0 +1,25 @@
+module RecordSelect
+  module FormBuilder
+    def record_select(association, options = {})
+      reflection = @object.class.reflect_on_association(association)
+      form_name = form_name_for_association(reflection)
+      current = @object.send(association)
+      options[:id] ||= "#{@object_name.gsub(/[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")}_#{association}"
+
+      if [:has_one, :belongs_to].include? reflection.macro
+        @template.record_select_field(form_name, current || reflection.klass.new, options)
+      else
+        options[:controller] ||= reflection.klass.to_s.pluralize.underscore
+        @template.record_multi_select_field(form_name, current, options)
+      end
+    end
+
+    private
+
+    def form_name_for_association(reflection)
+      key_name = (reflection.options[:foreign_key] || reflection.association_foreign_key)
+      key_name += "s" unless [:has_one, :belongs_to].include? reflection.macro
+      form_name = "#{@object_name}[#{key_name}]"
+    end
+  end
+end

data/lib/recordselect_custom/helpers.rb

@@ -0,0 +1,187 @@
+module RecordSelect
+  module Helpers
+    # Print this from your layout to include everything necessary for RecordSelect to work.
+    # Well, not everything. You need Prototype too.
+    def record_select_includes
+      includes = ''
+      includes << stylesheet_link_tag('record_select/record_select')
+      includes << javascript_include_tag('record_select/record_select')
+      includes
+    end
+
+    # Adds a link on the page that toggles a RecordSelect widget from the given controller.
+    #
+    # *Options*
+    # +onselect+::  JavaScript code to handle selections client-side. This code has access to two variables: id, label. If the code returns false, the dialog will *not* close automatically.
+    # +params+::    Extra URL parameters. If any parameter is a column name, the parameter will be used as a search term to filter the result set.
+    def link_to_record_select(name, controller, options = {})
+      options[:params] ||= {}
+      options[:params].merge!(:controller => controller, :action => :browse)
+      options[:onselect] = "function(id, label) {#{options[:onselect]}}" if options[:onselect]
+      options[:html] ||= {}
+      options[:html][:id] ||= "rs_#{rand(9999)}"
+
+      assert_controller_responds(options[:params][:controller])
+
+      html = link_to_function(name, '', options[:html])
+      html << javascript_tag("new RecordSelect.Dialog(#{options[:html][:id].to_json}, #{url_for(options[:params].merge(:escape => false)).to_json}, {onselect: #{options[:onselect] || ''}})")
+
+      return html
+    end
+
+    # Adds a RecordSelect-based form field. The field submits the record's id using a hidden input.
+    #
+    # *Arguments*
+    # +name+:: the input name that will be used to submit the selected record's id.
+    # +current+:: the currently selected object. provide a new record if there're none currently selected and you have not passed the optional :controller argument.
+    #
+    # *Options*
+    # +controller+::  The controller configured to provide the result set. Optional if you have standard resource controllers (e.g. UsersController for the User model), in which case the controller will be inferred from the class of +current+ (the second argument)
+    # +params+::      A hash of extra URL parameters
+    # +id+::          The id to use for the input. Defaults based on the input's name.
+    # +onchange+::    A JavaScript function that will be called whenever something new is selected. It should accept the new id as the first argument, and the new label as the second argument. For example, you could set onchange to be "function(id, label) {alert(id);}", or you could create a JavaScript function somewhere else and set onchange to be "my_function" (without the parantheses!).
+    def record_select_field(name, current, options = {})
+      options[:controller] ||= current.class.to_s.pluralize.underscore
+      options[:params] ||= {}
+      options[:id] ||= name.gsub(/[\[\]]/, '_')
+      options[:js_params] ||= "null"
+      options[:ass_value] = true if options[:ass_value].nil?
+
+      controller = assert_controller_responds(options[:controller])
+
+      id = label = ''
+      if options[:ass_value]
+        if current and not current.new_record?
+          id = current.id
+          label = label_for_field(current, controller)
+        end
+      else
+        id = current.object_id
+        label = current
+      end
+
+      url = url_for({:action => :browse, :controller => options[:controller], :escape => false, :format => :js}.merge(options[:params]))
+
+      html = text_field_tag(name, nil, :autocomplete => 'off', :id => options[:id], :class => options[:class],
+                            :onfocus => "this.focused=true", :onblur => "this.focused=false", :placeholder => options[:placeholder])
+      html << javascript_tag("jQuery(#{("#"+options[:id]).to_json}).recordSelectSingle(#{url.to_json}, {
+                               id: #{id.to_json},
+                               label: #{label.to_json},
+                               ass_value: #{options[:ass_value]},
+                               openEvents: #{options[:open_events].try(:to_json) || 'null'},
+                               onchange: #{options[:onchange] || ''.to_json},
+                               js_params: #{options[:js_params]}
+                             });")
+
+      return html
+    end
+
+    # Assists with the creation of an observer for the :onchange option of the record_select_field method.
+    # Currently only supports building an Ajax.Request based on the id of the selected record.
+    #
+    # options[:url] should be a hash with all the necessary options *except* :id. that parameter
+    # will be provided based on the selected record.
+    #
+    # Question: if selecting users, what's more likely?
+    #   /users/5/categories
+    #   /categories?user_id=5
+    def record_select_observer(options = {})
+      fn =  "function(id, value) {"
+      fn <<   "var url = #{url_for(options[:url].merge(:id => ":id:")).to_json}.replace(/:id:/, id);"
+      fn <<   "jQuery.get(url);"
+      fn << "}"
+    end
+
+    # Adds a RecordSelect-based form field for multiple selections. The values submit using a list of hidden inputs.
+    #
+    # *Arguments*
+    # +name+:: the input name that will be used to submit the selected records' ids. empty brackets will be appended to the name.
+    # +current+:: pass a collection of existing associated records
+    #
+    # *Options*
+    # +controller+::  The controller configured to provide the result set.
+    # +params+::      A hash of extra URL parameters
+    # +id+::          The id to use for the input. Defaults based on the input's name.
+    def record_multi_select_field(name, current, options = {})
+      options[:controller] ||= current.first.class.to_s.pluralize.underscore
+      options[:params] ||= {}
+      options[:id] ||= name.gsub(/[\[\]]/, '_')
+
+      controller = assert_controller_responds(options[:controller])
+
+      current = current.inject([]) { |memo, record| memo.push({:id => record.id, :label => label_for_field(record, controller)}) }
+
+      url = url_for({:action => :browse, :controller => options[:controller], :escape => false}.merge(options[:params]))
+
+      html = text_field_tag("#{name}[]", nil, :autocomplete => 'off', :id => options[:id], :class => options[:class], :onfocus => "this.focused=true", :onblur => "this.focused=false")
+      html << content_tag('ul', '', :class => 'record-select-list');
+      html << javascript_tag("new RecordSelect.Multiple(#{options[:id].to_json}, #{url.to_json}, {current: #{current.to_json}});")
+
+      return html
+    end
+
+    # A helper to render RecordSelect partials
+    def render_record_select(file, options = {}) #:nodoc:
+      options[:file] = controller.send(:record_select_path_of, file)
+      options[:use_full_path] = false
+      render options
+    end
+
+    # Provides view access to the RecordSelect configuration
+    def record_select_config #:nodoc:
+      controller.send :record_select_config
+    end
+
+    # The id of the RecordSelect widget for the given controller.
+    def record_select_id(controller = nil) #:nodoc:
+      controller ||= params[:controller]
+      "record-select-#{controller.gsub('/', '_')}"
+    end
+
+    def record_select_search_id(controller = nil) #:nodoc:
+      "#{record_select_id(controller)}-search"
+    end
+
+    private
+
+    # uses renderer (defaults to record_select_config.label) to determine how the given record renders.
+    def render_record_from_config(record, renderer = record_select_config.label)
+      case renderer
+        when Symbol, String
+        # return full-html from the named partial
+        render :partial => renderer.to_s, :locals => {:record => record}
+
+        when Proc
+        # return an html-cleaned descriptive string
+        h renderer.call(record)
+      end
+    end
+
+    # uses the result of render_record_from_config to snag an appropriate record label
+    # to display in a field.
+    #
+    # if given a controller, searches for a partial in its views path
+    def label_for_field(record, controller = self.controller)
+      renderer = controller.record_select_config.label
+      case renderer
+        when Symbol, String
+        # find the <label> element and grab its innerHTML
+        description = render_record_from_config(record, File.join(controller.controller_path, renderer.to_s))
+        description.match(/<label[^>]*>(.*)<\/label>/)[1]
+
+        when Proc
+        # just return the string
+        render_record_from_config(record, renderer)
+      end
+    end
+
+    def assert_controller_responds(controller_name)
+      controller_name = "#{controller_name.camelize}Controller"
+      controller = controller_name.constantize
+      unless controller.uses_record_select?
+        raise "#{controller_name} has not been configured to use RecordSelect."
+      end
+      controller
+    end
+  end
+end

data/lib/recordselect_custom/version.rb

@@ -1,3 +1,3 @@
 module RecordselectCustom
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,35 +1,23 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: record_select
-version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 3
-  version: 0.0.3
+version: !ruby/object:Gem::Version
+  version: 0.0.4
 platform: ruby
-authors: 
+authors:
 - lion
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2014-12-17 00:00:00 +08:00
-default_executable: 
+date: 2014-12-17 00:00:00.000000000 Z
 dependencies: []
-
 description: just for test
-email: 
+email:
 - lion3139@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
+files:
+- ".gitignore"
 - CHANGELOG
 - Gemfile
 - LICENSE.txt
@@ -59,7 +47,13 @@ files:
 - lib/record_select/config.rb
 - lib/record_select/form_builder.rb
 - lib/record_select/helpers.rb
+- lib/record_select/version.rb
 - lib/recordselect_custom.rb
+- lib/recordselect_custom/actions.rb
+- lib/recordselect_custom/conditions.rb
+- lib/recordselect_custom/config.rb
+- lib/recordselect_custom/form_builder.rb
+- lib/recordselect_custom/helpers.rb
 - lib/recordselect_custom/version.rb
 - lib/views/_browse.html
 - lib/views/_browse.rhtml
@@ -69,39 +63,28 @@ files:
 - recordselect_custom.gemspec
 - test/recordselect_test.rb
 - uninstall.rb
-has_rdoc: true
-homepage: ""
+homepage: ''
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.9.5
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: just for test
-test_files: 
+test_files:
 - test/recordselect_test.rb