six-updater-web 0.10.8 → 0.11.1

data/lib/vendor/plugins/recordselect/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, RecordSelectHelper)
+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/lib/vendor/plugins/recordselect/install.rb

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

data/lib/vendor/plugins/recordselect/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/vendor/plugins/recordselect/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/vendor/plugins/recordselect/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/vendor/plugins/recordselect/lib/record_select/actions.rb

@@ -0,0 +1,67 @@
+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, record_select_config.per_page) 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)
+
+      respond_to do |wants|
+        wants.html { render_record_select :partial => 'browse'}
+        wants.js {
+          if params[:update]
+            render_record_select :template => 'browse', :format => :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_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(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
+end

data/lib/vendor/plugins/recordselect/lib/record_select/conditions.rb

@@ -0,0 +1,86 @@
+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 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/vendor/plugins/recordselect/lib/record_select/config.rb

@@ -0,0 +1,91 @@
+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]
+
+      @link = options[:link]
+    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
+
+    # 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/vendor/plugins/recordselect/lib/record_select/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/vendor/plugins/recordselect/test/recordselect_test.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+
+class RecordselectTest < Test::Unit::TestCase
+  # Replace this with your real tests.
+  def test_this_plugin
+    flunk
+  end
+end

data/lib/vendor/plugins/recordselect/uninstall.rb

@@ -0,0 +1,4 @@
+['stylesheets', 'images', 'javascripts'].each do |asset_type|
+  public_dir = File.join(RAILS_ROOT, 'public', asset_type, 'record_select')
+  FileUtils.rm_r public_dir
+end

data/lib/vendor/plugins/render_component/README

@@ -0,0 +1,37 @@
+Components allow you to call other actions for their rendered response while executing another action. You can either delegate
+the entire response rendering or you can mix a partial response in with your other content.
+
+  class WeblogController < ActionController::Base
+    # Performs a method and then lets hello_world output its render
+    def delegate_action
+      do_other_stuff_before_hello_world
+      render_component :controller => "greeter",  :action => "hello_world", :params => { :person => "david" }
+    end
+  end
+
+  class GreeterController < ActionController::Base
+    def hello_world
+      render :text => "#{params[:person]} says, Hello World!"
+    end
+  end
+
+The same can be done in a view to do a partial rendering:
+
+  Let's see a greeting:
+  <%= render_component :controller => "greeter", :action => "hello_world" %>
+
+It is also possible to specify the controller as a class constant, bypassing the inflector
+code to compute the controller class at runtime:
+
+<%= render_component :controller => GreeterController, :action => "hello_world" %>
+
+== When to use components
+
+Components should be used with care. They're significantly slower than simply splitting reusable parts into partials and
+conceptually more complicated. Don't use components as a way of separating concerns inside a single application. Instead,
+reserve components to those rare cases where you truly have reusable view and controller elements that can be employed
+across many applications at once.
+
+So to repeat: Components are a special-purpose approach that can often be replaced with better use of partials and filters.
+
+Copyright (c) 2007 David Heinemeier Hansson, released under the MIT license

data/lib/vendor/plugins/render_component/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+ 
+desc 'Default: run unit tests.'
+task :default => :test
+ 
+desc 'Test the components plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+ 
+desc 'Generate documentation for the components plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'Components'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/vendor/plugins/render_component/init.rb

@@ -0,0 +1,2 @@
+require 'components'
+ActionController::Base.send :include, Components

data/lib/vendor/plugins/render_component/lib/components.rb

@@ -0,0 +1,142 @@
+module Components
+  def self.included(base) #:nodoc:
+    base.class_eval do
+      include InstanceMethods
+      extend ClassMethods
+      helper HelperMethods
+
+      # If this controller was instantiated to process a component request,
+      # +parent_controller+ points to the instantiator of this controller.
+      attr_accessor :parent_controller
+
+      alias_method_chain :process_cleanup, :render_component
+      alias_method_chain :session=, :render_component
+      alias_method_chain :flash, :render_component
+      alias_method_chain :assign_shortcuts, :render_component
+      alias_method_chain :send_response, :render_component
+
+      alias_method :component_request?, :parent_controller
+    end
+  end
+
+  module ClassMethods
+    # Track parent controller to identify component requests
+    def process_with_components(request, response, parent_controller = nil) #:nodoc:
+      controller = new
+      controller.parent_controller = parent_controller
+      controller.process(request, response)
+    end
+  end
+
+  module HelperMethods
+    def render_component(options)
+      @controller.__send__(:render_component_as_string, options)
+    end
+  end
+
+  module InstanceMethods
+    # Extracts the action_name from the request parameters and performs that action.
+    def process_with_components(request, response, method = :perform_action, *arguments) #:nodoc:
+      flash.discard if component_request?
+      process_without_components(request, response, method, *arguments)
+    end
+    
+    def send_response_with_render_component
+      response.prepare! unless component_request?
+      response
+    end
+
+    protected
+      # Renders the component specified as the response for the current method
+      def render_component(options) #:doc:
+        component_logging(options) do
+          render_for_text(component_response(options, true).body, response.headers["Status"])
+        end
+      end
+
+      # Returns the component response as a string
+      def render_component_as_string(options) #:doc:
+        component_logging(options) do
+          response = component_response(options, false)
+
+          if redirected = response.redirected_to
+            render_component_as_string(redirected)
+          else
+            response.body
+          end
+        end
+      end
+
+      def flash_with_render_component(refresh = false) #:nodoc:
+        if !defined?(@_flash) || refresh
+          @_flash =
+            if defined?(@parent_controller)
+              @parent_controller.flash
+            else
+              flash_without_render_component
+            end
+        end
+        @_flash
+      end
+
+    private
+      def component_response(options, reuse_response)
+        klass    = component_class(options)
+        request  = request_for_component(klass.controller_path, options)
+        new_response = reuse_response ? response : response.dup
+
+        klass.process_with_components(request, new_response, self)
+      end
+
+      # determine the controller class for the component request
+      def component_class(options)
+        if controller = options[:controller]
+          controller.is_a?(Class) ? controller : "#{controller.camelize}Controller".constantize
+        else
+          self.class
+        end
+      end
+
+      # Create a new request object based on the current request.
+      # The new request inherits the session from the current request,
+      # bypassing any session options set for the component controller's class
+      def request_for_component(controller_path, options)
+        new_request         = request.dup
+        new_request.session = request.session
+
+        new_request.instance_variable_set(
+          :@parameters,
+          (options[:params] || {}).with_indifferent_access.update(
+            "controller" => controller_path, "action" => options[:action], "id" => options[:id]
+          )
+        )
+
+        new_request
+      end
+
+      def component_logging(options)
+        if logger
+          logger.info "Start rendering component (#{options.inspect}): "
+          result = yield
+          logger.info "\n\nEnd of component rendering"
+          result
+        else
+          yield
+        end
+      end
+
+      def session_with_render_component=(options = {})
+        session_without_render_component=(options) unless component_request?
+      end
+
+      def process_cleanup_with_render_component
+        process_cleanup_without_render_component unless component_request?
+      end
+      
+      def assign_shortcuts_with_render_component(request, response)
+        assign_shortcuts_without_render_component(request, response)
+        flash(:refresh)
+        flash.sweep if @_session && !component_request?
+      end
+  end
+end