six-updater-web 0.10.8 → 0.11.1

data/lib/vendor/plugins/active_scaffold/lib/active_scaffold/helpers/number_helpers.rb

@@ -0,0 +1,143 @@
+module ActiveScaffold
+  module Helpers
+    # Provides methods for converting a number into a formatted string that currently represents
+    # one of the following forms: phone number, percentage, money, or precision level.
+    module NumberHelpers
+      # Formats a +number+ into a US ssn number string. The +options+ can be a hash used to customize the format of the output.
+      # The delimiter can be set using +:delimiter+; default is "-"
+      # Examples:
+      #   usa_number_to_ssn(123551234)   => 123-55-1234
+      def usa_number_to_ssn(number, options = {})
+        return "" if number.nil?
+        delimiter = options[:delimiter] || "-"
+        begin
+          str = number.to_s.gsub(/([0-9]{3})([0-9]{2})([0-9]{4})/,"\\1#{delimiter}\\2#{delimiter}\\3")
+        rescue
+          number
+        end
+      end
+
+      # Formats a +number+ into a US zip code string. The +options+ can be a hash used to customize the format of the output.
+      # The delimiter can be set using +:delimiter+; default is "-"
+      # Examples:
+      #   usa_number_to_zip(123551234)   => 12355-1234
+      def usa_number_to_zip(number, options = {})
+        return "" if number.nil?
+        delimiter = options[:delimiter] || "-"
+        begin
+          str = number.to_s.gsub(/([0-9]{5})([0-9]{4})/,"\\1#{delimiter}\\2")
+        rescue
+          number
+        end
+      end
+
+      # Formats a +number+ into a US phone number string. The +options+ can be a hash used to customize the format of the output.
+      # The area code can be surrounded by parentheses by setting +:area_code+ to true; default is false
+      # The delimiter can be set using +:delimiter+; default is "-"
+      # Examples:
+      #   usa_number_to_phone(1235551234)   => 123-555-1234
+      #   usa_number_to_phone(1235551234, {:area_code => true})   => (123) 555-1234
+      #   usa_number_to_phone(1235551234, {:delimiter => " "})    => 123 555 1234
+      #   usa_number_to_phone(1235551234, {:area_code => true, :extension => 555})  => (123) 555-1234 x 555
+      def usa_number_to_phone(number, options = {})
+        return "" if number.nil?
+        options[:area_code] ||= false
+        options[:delimiter] ||= "-"
+        options[:extension] ||= ""
+        begin
+          str = options[:area_code] == true ? number.to_s.gsub(/([0-9]{3})([0-9]{3})([0-9]{4})/,"(\\1) \\2#{options[:delimiter]}\\3") : number.to_s.gsub(/([0-9]{3})([0-9]{3})([0-9]{4})/,"\\1#{options[:delimiter]}\\2#{options[:delimiter]}\\3")
+          options[:extension].to_s.strip.empty? ? str : "#{str} x #{options[:extension].to_s.strip}"
+        rescue
+          number
+        end
+      end
+
+# User Rails versions
+    #   # Formats a +number+ into a currency string. The +options+ hash can be used to customize the format of the output.
+    #   # The +number+ can contain a level of precision using the +precision+ key; default is 2
+    #   # The currency type can be set using the +unit+ key; default is "$"
+    #   # The unit separator can be set using the +separator+ key; default is "."
+    #   # The delimiter can be set using the +delimiter+ key; default is ","
+    #   # Examples:
+    #   #    number_to_currency(1234567890.50)     => $1,234,567,890.50
+    #   #    number_to_currency(1234567890.506)    => $1,234,567,890.51
+    #   #    number_to_currency(1234567890.50, {:unit => "£", :separator => ",", :delimiter => ""}) => £1234567890,50
+    #   def number_to_currency(number, options = {})
+    #     return "" if number.nil?
+    #     options[:precision] ||= 2
+    #     options[:unit] ||= "$"
+    #     options[:separator] ||= "."
+    #     options[:delimiter] ||= ","
+    #     options[:separator] = "" unless options[:precision] > 0
+    #     begin
+    #       parts = number_with_precision(number, options[:precision]).split('.')
+    #       options[:unit] + number_with_delimiter(parts[0], options[:delimiter]) + options[:separator] + parts[1].to_s
+    #     rescue
+    #       number
+    #     end
+    #   end
+    # 
+    #   # Formats a +number+ as into a percentage string. The +options+ hash can be used to customize the format of the output.
+    #   # The +number+ can contain a level of precision using the +precision+ key; default is 3
+    #   # The unit separator can be set using the +separator+ key; default is "."
+    #   # Examples:
+    #   #   number_to_percentage(100)    => 100.000%
+    #   #   number_to_percentage(100, {:precision => 0}) => 100%
+    #   #   number_to_percentage(302.0574, {:precision => 2})  => 302.06%
+    #   def number_to_percentage(number, options = {})
+    #     return "" if number.nil?
+    #     options[:precision] ||= 2
+    #     options[:separator] ||= "."
+    #     begin
+    #       number = number_with_precision(number, options[:precision])
+    #       parts = number.split('.')
+    #       if parts.at(1).nil?
+    #         parts[0] + "%"
+    #       else
+    #         parts[0] + options[:separator] + parts[1].to_s + "%"
+    #       end
+    #     rescue
+    #       number
+    #     end
+    #   end
+    # 
+    #   # Formats a +number+ with a +delimiter+.
+    #   # Example:
+    #   #    number_with_delimiter(12345678) => 12,345,678
+    #   def number_with_delimiter(number, delimiter=",")
+    #     return "" if number.nil?
+    #     number.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+    #   end
+    # 
+    #   # Returns a formatted-for-humans file size.
+    #   # 
+    #   # Examples:
+    #   #   human_size(123)          => 123 Bytes
+    #   #   human_size(1234)         => 1.2 KB
+    #   #   human_size(12345)        => 12.1 KB
+    #   #   human_size(1234567)      => 1.2 MB
+    #   #   human_size(1234567890)   => 1.1 GB
+    #   def number_to_human_size(size)
+    #     return "" if size.nil?
+    #     case 
+    #       when size < 1.kilobyte: '%d Bytes' % size
+    #       when size < 1.megabyte: '%.1f KB'  % (size / 1.0.kilobyte)
+    #       when size < 1.gigabyte: '%.1f MB'  % (size / 1.0.megabyte)
+    #       when size < 1.terabyte: '%.1f GB'  % (size / 1.0.gigabyte)
+    #       else                    '%.1f TB'  % (size / 1.0.terabyte)
+    #     end.sub('.0', '')
+    #   rescue
+    #     ""
+    #   end
+    # 
+    #   alias_method :human_size, :number_to_human_size # deprecated alias
+    # 
+    #   # Formats a +number+ with a level of +precision+.
+    #   # Example:
+    #   #    number_with_precision(111.2345) => 111.235
+    #   def number_with_precision(number, precision=3)
+    #     sprintf("%01.#{precision}f", number)
+    #   end
+    end
+  end
+end

data/lib/vendor/plugins/active_scaffold/lib/active_scaffold/helpers/pagination_helpers.rb

@@ -0,0 +1,39 @@
+module ActiveScaffold
+  module Helpers
+    module PaginationHelpers
+      def pagination_ajax_link(page_number, params)
+        url = url_for params.merge(:page => page_number)
+        page_link = link_to_remote(page_number,
+                  { :url => url,
+                    :before => "addActiveScaffoldPageToHistory('#{url}', '#{controller_id}');",
+                    :after => "$('#{loading_indicator_id(:action => :pagination)}').style.visibility = 'visible';",
+                    :complete => "$('#{loading_indicator_id(:action => :pagination)}').style.visibility = 'hidden';",
+                    :update => active_scaffold_content_id,
+                    :failure => "ActiveScaffold.report_500_response('#{active_scaffold_id}')",
+                    :method => :get },
+                  { :href => url_for(params.merge(:page => page_number)) })
+      end
+
+      def pagination_ajax_links(current_page, params)
+        start_number = current_page.number - 2
+        end_number = current_page.number + 2
+        start_number = 1 if start_number <= 0
+        end_number = current_page.pager.last.number if end_number > current_page.pager.last.number
+
+        html = []
+        html << pagination_ajax_link(1, params) unless current_page.number <= 3
+        html << ".." unless current_page.number <= 4
+        start_number.upto(end_number) do |num|
+          if current_page.number == num
+            html << num
+          else
+            html << pagination_ajax_link(num, params)
+          end
+        end
+        html << ".." unless current_page.number >= current_page.pager.last.number - 3
+        html << pagination_ajax_link(current_page.pager.last.number, params) unless current_page.number >= current_page.pager.last.number - 2
+        html.join(' ')
+      end
+    end
+  end
+end

data/lib/vendor/plugins/active_scaffold/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -0,0 +1,279 @@
+module ActiveScaffold
+  module Helpers
+    # Helpers that assist with the rendering of a Form Column
+    module SearchColumnHelpers
+      # This method decides which input to use for the given column.
+      # It does not do any rendering. It only decides which method is responsible for rendering.
+      def active_scaffold_search_for(column)
+        options = active_scaffold_search_options(column)
+
+        # check if the dev has created an override for this specific field for search
+        if override_search_field?(column)
+          # AST - I like column and options as params
+          send(override_search_field(column), @record, column, options)
+
+        # check if the dev has specified a valid search_ui for this column, using specific ui for searches
+        elsif column.search_ui and override_search?(column.search_ui)
+          send(override_search(column.search_ui), column, options)
+
+        # check if the dev has specified a valid search_ui for this column, using generic ui for forms
+        elsif column.search_ui and override_input?(column.search_ui)
+          send(override_input(column.search_ui), column, options)
+
+        # AST - my prefered order
+        # check if the dev has created an override for this specific field
+        elsif override_form_field?(column)
+          # AST - I like column and options as params
+          send(override_form_field(column), @record, column, options)
+        # AST End 
+        
+        # fallback: we get to make the decision
+        else
+          if column.association or column.virtual?
+            active_scaffold_search_text(column, options)
+
+          else # regular model attribute column
+            # if we (or someone else) have created a custom render option for the column type, use that
+            if override_search?(column.column.type)
+              send(override_search(column.column.type), column, options)
+            # if we (or someone else) have created a custom render option for the column type, use that
+            elsif override_input?(column.column.type)
+              send(override_input(column.column.type), column, options)
+            # final ultimate fallback: use rails' generic input method
+            else
+              # for textual fields we pass different options
+              text_types = [:text, :string, :integer, :float, :decimal]
+              options = active_scaffold_input_text_options(options) if text_types.include?(column.column.type)
+              input(:record, column.name, options.merge(column.options))
+            end
+          end
+        end
+      end
+
+      # the standard active scaffold options used for class, name and scope
+      def active_scaffold_search_options(column)
+        { :name => "search[#{column.name}]", :class => "#{column.name}-input", :id => "search_#{column.name}"}
+      end
+
+      ##
+      ## Search input methods
+      ##
+
+      def active_scaffold_search_multi_select(column, options)
+        # AST not a big fan of checkboxes
+        return active_scaffold_search_select(column, options.merge(:multiple => true), select_options)
+        # AST End
+        associated_options = @record.send(column.association.name).collect {|r| [r.to_label, r.id]}
+        select_options = associated_options | options_for_association(column.association, true)
+        return as_(:no_options) if select_options.empty?
+
+        html = "<ul class=\"checkbox-list\" id=\"#{options[:id]}\">"
+
+        associated_ids = associated_options.collect {|a| a[1]}
+        select_options.each_with_index do |option, i|
+          label, id = option
+          this_name = "#{options[:name]}[#{i}][id]"
+          this_id = "#{options[:id]}_#{i}_id"
+          html << "<li>"
+          html << check_box_tag(this_name, id, associated_ids.include?(id), :id => this_id)
+          html << "<label for='#{this_id}'>"
+          html << label
+          html << "</label>"
+          html << "</li>"
+        end
+
+        html << '</ul>'
+        html << javascript_tag("new DraggableLists('#{options[:id]}')") if column.options[:draggable_lists]
+        html
+      end
+
+      def active_scaffold_search_select(column, options)
+        if column.association
+          associated = @record.send(column.association.name)
+          associated = associated.first if associated.is_a?(Array) # for columns with plural association
+
+          select_options = options_for_association(column.association, true)
+          select_options.unshift([ associated.to_label, associated.id ]) unless associated.nil? or select_options.find {|label, id| id == associated.id}
+
+          selected = associated.nil? ? nil : associated.id
+          method = column.association.macro == :belongs_to ? column.association.primary_key_name : column.name
+          options[:name] += '[id]'
+          select(:record, method, select_options.uniq, {:selected => selected, :include_blank => as_(:_select_)}, options)
+        else
+          select(:record, column.name, column.options, { :selected => @record.send(column.name) }, options)
+        end
+      end
+
+      def active_scaffold_search_text(column, options)
+        text_field :record, column.name, active_scaffold_input_text_options(options)
+      end
+
+      # we can't use active_scaffold_input_boolean because we need to have a nil value even when column can't be null
+      # to decide whether search for this field or not
+      def active_scaffold_search_boolean(column, options)
+        select_options = []
+        select_options << [as_(:_select_), nil]
+        select_options << [as_(:true), true]
+        select_options << [as_(:false), false]
+
+        # AST Begin
+        value = @record.send(column.name)
+        value = value.blank? ? nil : (value ? 1 : 0)
+        select_tag(options[:name], options_for_select(select_options, value))
+        # AST End
+      end
+      # we can't use checkbox ui because it's not possible to decide whether search for this field or not
+      alias_method :active_scaffold_search_checkbox, :active_scaffold_search_boolean
+
+      def active_scaffold_search_integer(column, options)
+        html = []
+        html << select_tag("#{options[:name]}[opt]",
+              options_for_select(ActiveScaffold::Finder::NumericComparators.collect {|comp| [as_(comp.downcase.to_sym), comp]}),
+              :id => "#{options[:id]}_opt",
+              :onchange => "Element[this.value == 'BETWEEN' ? 'show' : 'hide']('#{options[:id]}_between');")
+        html << text_field_tag("#{options[:name]}[from]", nil, active_scaffold_input_text_options(:id => options[:id], :size => 10))
+        html << content_tag(:span, ' - ' + text_field_tag("#{options[:name]}[to]", nil,
+              active_scaffold_input_text_options(:id => "#{options[:id]}_to", :size => 10)),
+              :id => "#{options[:id]}_between", :style => "display:none")
+        html * ' '
+      end
+      alias_method :active_scaffold_search_decimal, :active_scaffold_search_integer
+      alias_method :active_scaffold_search_float, :active_scaffold_search_integer
+
+      # AST Begin
+      def search_session_column_range_values(column)
+        search_ui = column.search_ui || column.column.type
+        return nil if @search_session_info.nil? or search_ui.nil?
+        values = @search_session_info[column.name]
+        return nil, nil, nil if values.blank?
+        return nil, values, nil unless values.is_a?(Array)
+        return values[:opt], values[:from], values[:to]
+      end
+
+      def active_scaffold_search_range(column, options)
+        opt_value, from_value, to_value = search_session_column_range_values(column)
+        html = []
+        # AST - give StringComparators labels
+        select_options = [:string].include?(column.column.type) ? ActiveScaffold::Finder::StringComparators.collect {|title, comp| [as_(title), comp]} : ActiveScaffold::Finder::NumericComparators.collect {|comp| [as_(comp), comp]}
+        html << select_tag("#{options[:name]}[opt]",
+              options_for_select(select_options, opt_value),
+              :id => "#{options[:id]}_opt",
+              :onchange => "Element[this.value == 'BETWEEN' ? 'show' : 'hide']('#{options[:id]}_between');")
+        html << text_field_tag("#{options[:name]}[from]", from_value, active_scaffold_input_text_options(:id => options[:id], :size => 10))
+        html << content_tag(:span, ' - ' + text_field_tag("#{options[:name]}[to]", to_value,
+              active_scaffold_input_text_options(:id => "#{options[:id]}_to", :size => 10)),
+              :id => "#{options[:id]}_between", :style => to_value.blank? ? "display:none" : "")
+        html * ' '
+      end
+      alias_method :active_scaffold_search_integer, :active_scaffold_search_range
+      alias_method :active_scaffold_search_decimal, :active_scaffold_search_range
+      alias_method :active_scaffold_search_float, :active_scaffold_search_range
+      alias_method :active_scaffold_search_usa_money, :active_scaffold_search_range
+      alias_method :active_scaffold_search_string, :active_scaffold_search_range
+      alias_method :active_scaffold_search_text, :active_scaffold_search_range
+      
+      def active_scaffold_search_usa_state(column, options)
+        @record.send("#{column.name}=", search_session_column_multi_select_values(column))
+        select_options = options
+        select_options.delete(:size)
+        options.delete([:prompt, :priority])
+        usa_state_select(:record, column.name, column.options[:priority], select_options, column.options.merge!(options))
+      end
+
+      def active_scaffold_search_record_select(column, options)
+        begin
+          value = @search_session_info[column.name] unless @search_session_info.nil?
+          if column.plural_association?
+            value.collect! {|id|  Float(id) rescue nil ? id.to_i : id}.flatten if value
+            @record.send("#{column.name}=", column.association.klass.find(value)) if value
+          else
+            if value.blank?
+              value = nil
+            else
+              value = Float(value) rescue nil ? value.to_i : value
+              value = column.association.klass.find(value)
+            end
+            @record.send("#{column.name}=", value)
+          end
+        rescue   Exception => e
+          logger.error Time.now.to_s + "Sorry, we are not that smart yet. Attempted to restore search values to search fields but instead got -- #{e.inspect} -- on the ActiveScaffold column = :#{column.name} in #{@controller.class}"
+          raise e
+        end
+
+        unless column.association
+          raise ArgumentError, "record_select can only work against associations (and #{column.name} is not).  A common mistake is to specify the foreign key field (like :user_id), instead of the association (:user)."
+        end
+        remote_controller = File.join('/', active_scaffold_controller_for(column.association.klass).controller_path)
+
+        # if the opposite association is a :belongs_to, then only show records that have not been associated yet
+        params = {:parent_model => @record.class}
+
+        record_select_options = {:controller => remote_controller, :id => options[:id], :params => params}
+        record_select_options.merge!(active_scaffold_input_text_options)
+        record_select_options.merge!(column.options)
+
+        if column.singular_association?
+          record_select_field(options[:name], (@record.send(column.name) || column.association.klass.new), record_select_options)
+        elsif column.plural_association?
+          record_multi_select_field(options[:name], @record.send(column.name), record_select_options)
+        end   
+      end
+      
+      def search_session_column_multi_select_values(column)
+        begin
+          value = @search_session_info[column.name] unless @search_session_info.nil?
+          if value.is_a?(Hash)
+            value = Float(value[:id]) rescue nil ? value[:id].to_i : value[:id] if value.has_key?(:id)
+          else
+            value.collect! {|id|  Float(id) rescue nil ? id.to_i : id}.flatten if value
+          end
+          value
+        rescue   Exception => e
+          logger.error Time.now.to_s + "Sorry, we are not that smart yet. Attempted to restore search values to search fields but instead got -- #{e.inspect} -- on the ActiveScaffold column = :#{column.name} in #{@controller.class}"
+          # raise e
+        end
+      end
+
+      # AST End
+
+      def active_scaffold_search_datetime(column, options)
+        options = column.options.merge(options)
+        helper = "select_#{'date' unless options[:discard_date]}#{'time' unless options[:discard_time]}"
+        html = []
+        html << send(helper, nil, {:include_blank => true, :prefix => "#{options[:name]}[from]"}.merge(options))
+        html << send(helper, nil, {:include_blank => true, :prefix => "#{options[:name]}[to]"}.merge(options))
+        html * ' - '
+      end
+
+      def active_scaffold_search_date(column, options)
+        active_scaffold_search_datetime(column, options.merge!(:discard_time => true))
+      end
+      def active_scaffold_search_time(column, options)
+        active_scaffold_search_datetime(column, options.merge!(:discard_date => true))
+      end
+      alias_method :active_scaffold_search_timestamp, :active_scaffold_search_datetime
+
+      ##
+      ## Search column override signatures
+      ##
+
+      def override_search_field?(column)
+        respond_to?(override_search_field(column))
+      end
+
+      # the naming convention for overriding form fields with helpers
+      def override_search_field(column)
+        "#{column.name}_search_column"
+      end
+
+      def override_search?(search_ui)
+        respond_to?(override_search(search_ui))
+      end
+
+      # the naming convention for overriding search input types with helpers
+      def override_search(form_ui)
+        "active_scaffold_search_#{form_ui}"
+      end
+    end
+  end
+end