active_scaffold-sequel 0.3.0

data/lib/active_scaffold/helpers/show_column_helpers.rb

@@ -0,0 +1,50 @@
+module ActiveScaffold
+  module Helpers
+    # Helpers that assist with the rendering of a List Column
+    module ShowColumnHelpers
+      def show_column_value(record, column)
+        # check for an override helper
+        if show_column_override? column
+          # we only pass the record as the argument. we previously also passed the formatted_value,
+          # but mike perham pointed out that prohibited the usage of overrides to improve on the
+          # performance of our default formatting. see issue #138.
+          send(show_column_override(column), record)
+        # second, check if the dev has specified a valid list_ui for this column
+        elsif column.list_ui and override_show_column_ui?(column.list_ui)
+          send(override_show_column_ui(column.list_ui), column, record)
+        else
+          if column.column and override_show_column_ui?(column.column[:type])
+            send(override_show_column_ui(column.column[:type]), column, record)
+          else
+            get_column_value(record, column)
+          end
+        end
+      end
+
+      def active_scaffold_show_text(column, record)
+        simple_format(clean_column_value(record.send(column.name)))
+      end
+
+      def show_column_override_name(column, class_prefix = false)
+        "#{clean_class_name(column.active_record_class.name) + '_' if class_prefix}#{clean_column_name(column.name)}_show_column"
+      end
+
+      def show_column_override(column)
+        method_with_class = show_column_override_name(column, true)
+        return method_with_class if respond_to?(method_with_class)
+        method = show_column_override_name(column)
+        method if respond_to?(method)
+      end
+      alias_method :show_column_override?, :show_column_override
+
+      def override_show_column_ui?(list_ui)
+        respond_to?(override_show_column_ui(list_ui))
+      end
+
+      # the naming convention for overriding show types with helpers
+      def override_show_column_ui(list_ui)
+        "active_scaffold_show_#{list_ui}"
+      end
+    end
+  end
+end

data/lib/active_scaffold/helpers/view_helpers.rb

@@ -0,0 +1,342 @@
+module ActiveScaffold
+  module Helpers
+    # All extra helpers that should be included in the View.
+    # Also a dumping ground for uncategorized helpers.
+    module ViewHelpers
+      include ActiveScaffold::Helpers::IdHelpers
+      include ActiveScaffold::Helpers::AssociationHelpers
+      include ActiveScaffold::Helpers::PaginationHelpers
+      include ActiveScaffold::Helpers::ListColumnHelpers
+      include ActiveScaffold::Helpers::ShowColumnHelpers
+      include ActiveScaffold::Helpers::FormColumnHelpers
+      include ActiveScaffold::Helpers::SearchColumnHelpers
+      include ActiveScaffold::Helpers::HumanConditionHelpers
+
+      ##
+      ## Delegates
+      ##
+
+      # access to the configuration variable
+      def active_scaffold_config
+        controller.class.active_scaffold_config
+      end
+
+      def active_scaffold_config_for(*args)
+        controller.class.active_scaffold_config_for(*args)
+      end
+
+      def active_scaffold_controller_for(*args)
+        controller.class.active_scaffold_controller_for(*args)
+      end
+
+      ##
+      ## Uncategorized
+      ##
+
+      def controller_path_for_activerecord(klass)
+        begin
+          controller = active_scaffold_controller_for(klass)
+          controller.controller_path
+        rescue ActiveScaffold::ControllerNotFound
+          controller = nil
+        end
+      end
+
+      # This is the template finder logic, keep it updated with however we find stuff in rails
+      # currently this very similar to the logic in ActionBase::Base.render for options file
+      def template_exists?(template_name, partial = false)
+        lookup_context.exists? template_name, '', partial
+      end
+
+      def generate_temporary_id
+        (Time.now.to_f*1000).to_i.to_s
+      end
+
+      # Turns [[label, value]] into <option> tags
+      # Takes optional parameter of :include_blank
+      def option_tags_for(select_options, options = {})
+        select_options.insert(0,[as_(:_select_),nil]) if options[:include_blank]
+        select_options.collect do |option|
+          label, value = option[0], option[1]
+          value.nil? ? "<option value="">#{label}</option>" : "<option value=\"#{value}\">#{label}</option>"
+        end
+      end
+
+      # Should this column be displayed in the subform?
+      def in_subform?(column, parent_record)
+        # A column shouldn't be in the subform if it's the reverse association to the parent
+        not (column.association and column.association.associated_class == parent_record.class)
+      end
+
+      def form_remote_upload_tag(url_for_options = {}, options = {})
+        options[:target] = action_iframe_id(url_for_options)
+        options[:multipart] ||= true
+        options[:class] = "#{options[:class]} as_remote_upload".strip 
+        output=""
+        output << form_tag(url_for_options, options)
+        (output << "<iframe id='#{action_iframe_id(url_for_options)}' name='#{action_iframe_id(url_for_options)}' style='display:none'></iframe>").html_safe
+      end
+
+      # a general-use loading indicator (the "stuff is happening, please wait" feedback)
+      def loading_indicator_tag(options)
+        image_tag(active_scaffold_config.class.asset_path('indicator.gif'), :style => "visibility:hidden;", :id => loading_indicator_id(options), :alt => "loading indicator", :class => "loading-indicator")
+      end
+
+      # Creates a javascript-based link that toggles the visibility of some element on the page.
+      # By default, it toggles the visibility of the sibling after the one it's nested in. You may pass custom javascript logic in options[:of] to change that, though. For example, you could say :of => '$("my_div_id")'.
+      # You may also flag whether the other element is visible by default or not, and the initial text will adjust accordingly.
+      def link_to_visibility_toggle(id, options = {})
+        options[:default_visible] = true if options[:default_visible].nil?
+        options[:hide_label] = as_(:hide) 
+        options[:show_label] = as_(:show)
+        javascript_tag("ActiveScaffold.create_visibility_toggle('#{id}', #{options.to_json});")
+      end
+
+      def skip_action_link(link, *args)
+        (!link.ignore_method.nil? && controller.respond_to?(link.ignore_method) && controller.send(link.ignore_method, *args)) || ((link.security_method_set? or controller.respond_to? link.security_method) and !controller.send(link.security_method, *args))
+      end
+
+      def render_action_link(link, url_options, record = nil, html_options = {})
+        url_options = action_link_url_options(link, url_options, record)
+        html_options = action_link_html_options(link, url_options, record, html_options)
+        action_link_html(link, url_options, html_options, record)
+      end
+
+      def render_group_action_link(link, url_options, options, record = nil)
+        if link.type == :member && !options[:authorized]
+          action_link_html(link, nil, {:class => "disabled #{link.action}#{link.html_options[:class].blank? ? '' : (' ' + link.html_options[:class])}"}, record)
+        else
+          render_action_link(link, url_options, record)
+        end
+      end
+      
+      def action_link_url_options(link, url_options, record, options = {})
+        url_options = url_options.clone
+        url_options[:action] = link.action
+        url_options[:controller] = link.controller.to_s if link.controller
+        url_options.delete(:search) if link.controller and link.controller.to_s != params[:controller]
+        url_options.merge! link.parameters if link.parameters
+        @link_record = record
+        url_options.merge! self.instance_eval(&(link.dynamic_parameters)) if link.dynamic_parameters.is_a?(Proc)
+        @link_record = nil
+        url_options_for_nested_link(link.column, record, link, url_options, options) if link.nested_link?
+        url_options_for_sti_link(link.column, record, link, url_options, options) unless record.nil? || active_scaffold_config.sti_children.nil?
+        url_options[:_method] = link.method if !link.confirm? && link.inline? && link.method != :get
+        url_options
+      end
+      
+      def action_link_html_options(link, url_options, record, html_options)
+        link_id = get_action_link_id(url_options, record, link.column)
+        html_options.reverse_merge! link.html_options.merge(:class => link.action.to_s)
+
+        # Needs to be in html_options to as the adding _method to the url is no longer supported by Rails        
+        html_options[:method] = link.method if link.method != :get
+
+        html_options[:class] += ' as_action' if link.inline?
+        html_options[:data] = {}
+        html_options[:data][:confirm] = link.confirm(record.try(:to_label)) if link.confirm?
+        html_options[:data][:position] = link.position if link.position and link.inline?
+        html_options[:data][:action] = link.action if link.inline?
+        if link.popup?
+          html_options[:data][:popup] = true
+          html_options[:target] = '_blank'
+        end
+        html_options[:id] = link_id
+        html_options[:remote] = true unless link.page? || link.popup?
+        if link.dhtml_confirm?
+          html_options[:class] += ' as_action' if !link.inline?
+          html_options[:page_link] = 'true' if !link.inline?
+          html_options[:dhtml_confirm] = link.dhtml_confirm.value
+          html_options[:onclick] = link.dhtml_confirm.onclick_function(controller, link_id)
+        end
+        html_options[:class] += " #{link.html_options[:class]}" unless link.html_options[:class].blank?
+        html_options
+      end
+
+      def get_action_link_id(url_options, record = nil, column = nil)
+        id = url_options[:id] || url_options[:parent_id]
+        id = "#{column.association[:name]}-#{record.id}" if column && column.plural_association?
+        if record.try(column.association[:name]).present?
+          id = "#{column.association[:name]}-#{record.send(column.association[:name]).id}-#{record.id}"
+        else
+          id = "#{column.association[:name]}-#{record.id}" unless record.nil?
+        end if column && column.singular_association?
+        id = "#{id}-#{url_options[:batch_scope].downcase}" if url_options[:batch_scope]
+        action_id = "#{id_from_controller(url_options[:controller]) + '-' if url_options[:parent_controller]}#{url_options[:action].to_s}"
+        action_link_id(action_id, id)
+      end
+      
+      def action_link_html(link, url, html_options, record)
+        # issue 260, use url_options[:link] if it exists. This prevents DB data from being localized.
+        label = url.delete(:link) if url.is_a?(Hash) 
+        label ||= link.label
+        if link.image.nil?
+          html = link_to(label, url, html_options)
+        else
+          html = link_to(image_tag(link.image[:name] , :size => link.image[:size], :alt => label), url, html_options)
+        end
+        # if url is nil we would like to generate an anchor without href attribute
+        url.nil? ? html.sub(/href=".*?"/, '').html_safe : html.html_safe
+      end
+      
+      def url_options_for_nested_link(column, record, link, url_options, options = {})
+        if column && column.association 
+          url_options[column.association[:model].name.foreign_key.to_sym] = url_options.delete(:id)
+          url_options[:id] = record.send(column.association[:name]).id if column.singular_association? && record.send(column.association[:name]).present?
+        elsif link.parameters && link.parameters[:named_scope]
+          url_options[active_scaffold_config.model.name.foreign_key.to_sym] = url_options.delete(:id)
+        end
+      end
+
+      def url_options_for_sti_link(column, record, link, url_options, options = {})
+        #need to find out controller of current record type
+        #and set parameters
+        # its quite difficult to detect an sti link
+        # if link.column.nil? we are sure that it is nt an singular association inline autolink
+        # howver that will not work if a sti parent is an singular association inline autolink
+        if link.column.nil?
+          sti_controller_path = controller_path_for_activerecord(record.class)
+          if sti_controller_path
+            url_options[:controller] = sti_controller_path
+            url_options[:parent_sti] = controller_path
+          end
+        end
+      end
+
+      def column_class(column, column_value, record)
+        classes = []
+        classes << "#{column.name}-column"
+        if column.css_class.is_a?(Proc)
+          css_class = column.css_class.call(column_value, record)
+          classes << css_class unless css_class.nil?
+        else
+          classes << column.css_class
+        end unless column.css_class.nil?
+         
+        classes << 'empty' if column_empty? column_value
+        classes << 'sorted' if active_scaffold_config.list.user.sorting.sorts_on?(column)
+        classes << 'numeric' if column.number?
+        classes.join(' ').rstrip
+      end
+      
+      def column_heading_class(column, sorting)
+        classes = []
+        classes << "#{column.name}-column_heading"
+        classes << "sorted #{sorting.direction_of(column).downcase}" if sorting.sorts_on? column
+        classes << column.css_class unless column.css_class.nil? || column.css_class.is_a?(Proc)
+        classes.join(' ')
+      end
+
+      def as_main_div_class
+        classes = ["active-scaffold", "active-scaffold-#{controller_id}", "#{id_from_controller params[:controller]}-view", "#{active_scaffold_config.theme}-theme"]
+        classes << "as_touch" if touch_device?
+        classes.join(' ')
+      end
+
+      def column_empty?(column_value)
+        empty = column_value.nil?
+        empty ||= column_value.blank? if column_value.respond_to? :blank?
+        empty ||= ['&nbsp;', active_scaffold_config.list.empty_field_text].include? column_value if String === column_value
+        return empty
+      end
+
+      def column_calculation(column)
+        unless column.calculate.instance_of? Proc
+          conditions = controller.send(:all_conditions)
+          includes = active_scaffold_config.list.count_includes
+          includes ||= controller.send(:active_scaffold_includes) unless conditions.nil?
+          calculation = beginning_of_chain.calculate(column.calculate, column.name, :conditions => conditions,
+           :joins => controller.send(:joins_for_collection), :include => includes)
+        else
+          column.calculate.call(@records)
+        end
+      end
+
+      def render_column_calculation(column)
+        calculation = column_calculation(column)
+        override_formatter = "render_#{column.name}_#{column.calculate.is_a?(Proc) ? :calculate : column.calculate}"
+        calculation = send(override_formatter, calculation) if respond_to? override_formatter
+
+        "#{"#{as_(column.calculate)}: " unless column.calculate.is_a? Proc}#{format_column_value nil, column, calculation}"
+      end
+
+      def column_show_add_existing(column)
+        (column.allow_add_existing and options_for_association_count(column.association) > 0)
+      end
+
+      def column_show_add_new(column, associated, record)
+        value = column.plural_association? || (column.singular_association? and associated.empty?)
+        value = false unless column.association.associated_class.authorized_for?(:crud_type => :create)
+        value
+      end
+ 
+      def clean_column_name(name)
+        name.to_s.gsub('?', '')
+      end
+
+      def clean_class_name(name)
+        name.underscore.gsub('/', '_')
+      end
+     
+      def active_scaffold_error_messages_for(*params)
+        options = params.extract_options!.symbolize_keys
+        options.reverse_merge!(:container_tag => :div, :list_type => :ul)
+
+        objects = Array.wrap(options.delete(:object) || params).map do |object|
+          object = instance_variable_get("@#{object}") unless object.respond_to?(:to_model)
+          object = convert_to_model(object)
+
+          if object.class.respond_to?(:model_name)
+            options[:object_name] ||= object.class.model_name.human.downcase
+          end
+
+          object
+        end
+
+        objects.compact!
+        count = objects.inject(0) {|sum, object| sum + object.errors.count }
+
+        unless count.zero?
+          html = {}
+          [:id, :class].each do |key|
+            if options.include?(key)
+              value = options[key]
+              html[key] = value unless value.blank?
+            else
+              html[key] = 'errorExplanation'
+            end
+          end
+          options[:object_name] ||= params.first
+
+          header_message = if options.include?(:header_message)
+            options[:header_message]
+          else
+            as_('errors.template.header', :count => count, :model => options[:object_name].to_s.gsub('_', ' '))
+          end
+
+          message = options.include?(:message) ? options[:message] : as_('errors.template.body')
+
+          error_messages = objects.sum do |object|
+            object.errors.full_messages.map do |msg|
+              options[:list_type] != :br ? content_tag(:li, msg) : msg
+            end
+          end
+          error_messages = if options[:list_type] == :br
+            error_messages.join('<br/>').html_safe
+          else
+            content_tag(options[:list_type], error_messages.join.html_safe)
+          end
+
+          contents = []
+          contents << content_tag(options[:header_tag] || :h2, header_message) unless header_message.blank?
+          contents << content_tag(:p, message) unless message.blank?
+          contents << error_messages
+          contents = contents.join.html_safe
+          options[:container_tag] ? content_tag(options[:container_tag], contents, html) : contents
+        else
+          ''
+        end
+      end
+    end
+  end
+end

data/lib/active_scaffold/marked_model.rb

@@ -0,0 +1,38 @@
+module ActiveScaffold
+  module MarkedModel
+    # This is a module aimed at making the make session_stored marked_records available to ActiveRecord models
+    
+    def self.included(base)
+      base.extend ClassMethods
+      base.scope :marked, lambda {{:conditions => {:id => base.marked_records.to_a}}}
+    end
+    
+    def marked
+      marked_records.include?(self.id)
+    end
+    
+    def marked=(value)
+      value = [true, 'true', 1, '1', 'T', 't'].include?(value.class == String ? value.downcase : value)
+      if value == true
+        marked_records << self.id if !marked
+      else
+        marked_records.delete(self.id)
+      end
+    end
+  
+    module ClassMethods
+      def marked_records
+        Thread.current[:marked_records] ||= Set.new
+      end
+
+      def marked_records=(marked)
+        Thread.current[:marked_records] = marked 
+      end
+    end
+  
+    # Instance-level access to the marked_records
+    def marked_records
+      self.class.marked_records
+    end
+  end
+end

data/lib/active_scaffold/paginator.rb

@@ -0,0 +1,136 @@
+require 'forwardable'
+
+class ActiveScaffold::Paginator
+  
+  VERSION = '1.0.9'
+
+  class ArgumentError < ::ArgumentError; end
+  class MissingCountError < ArgumentError; end
+  class MissingSelectError < ArgumentError; end  
+  
+  attr_reader :per_page, :count 
+  
+  # Instantiate a new Paginator object
+  #
+  # Provide:
+  # * A total count of the number of objects to paginate
+  # * The number of objects in each page
+  # * A block that returns the array of items
+  #   * The block is passed the item offset 
+  #     (and the number of items to show per page, for
+  #     convenience, if the arity is 2)
+  def initialize(count, per_page, &select)
+    @count, @per_page = count, per_page
+    unless select
+      raise MissingSelectError, "Must provide block to select data for each page"
+    end
+    @select = select
+  end
+  
+  # Total number of pages
+  def number_of_pages
+     (@count / @per_page).to_i + (@count % @per_page > 0 ? 1 : 0)
+  end
+  
+  # First page object
+  def first
+    page 1
+  end
+  
+  # Last page object
+  def last
+    page number_of_pages
+  end
+  
+  # Iterate through pages
+  def each
+    each_with_index do |item, index|
+      yield item
+    end
+  end
+  
+  # Iterate through pages with indices
+  def each_with_index
+    1.upto(number_of_pages) do |number|
+      yield(page(number), number - 1)
+    end
+  end
+  
+  # Retrieve page object by number
+  def page(number)
+    number = (n = number.to_i) > 0 ? n : 1
+    Page.new(self, number, lambda { 
+      offset = (number - 1) * @per_page
+      args = [offset]
+      args << @per_page if @select.arity == 2
+      @select.call(*args)
+    })
+  end
+  
+  # Page object
+  #
+  # Retrieves items for a page and provides metadata about the position
+  # of the page in the paginator
+  class Page
+    
+    extend Forwardable
+    def_delegator :@pager, :first, :first
+    def_delegator :@pager, :last, :last
+    def_delegator :items, :each
+    def_delegator :items, :each_with_index    
+        
+    attr_reader :number, :pager
+    
+    def initialize(pager, number, select) #:nodoc:
+      @pager, @number = pager, number
+      @offset = (number - 1) * pager.per_page
+      @select = select
+    end
+    
+    # Retrieve the items for this page
+    # * Caches
+    def items
+      @items ||= @select.call
+    end
+    
+    # Checks to see if there's a page before this one
+    def prev?
+      @number > 1
+    end
+    
+    # Get previous page (if possible)
+    def prev
+      @pager.page(@number - 1) if prev?
+    end
+    
+    # Checks to see if there's a page after this one
+    def next?
+      @number < @pager.number_of_pages
+    end
+    
+    # Get next page (if possible)
+    def next
+      @pager.page(@number + 1) if next?
+    end
+    
+    # The "item number" of the first item on this page
+    def first_item_number
+      1 + @offset
+    end
+    
+    # The "item number" of the last item on this page
+    def last_item_number
+      if next?
+        @offset + @pager.per_page
+      else
+        @pager.count
+      end
+    end
+    
+    def ==(other) #:nodoc:
+      @pager == other.pager && self.number == other.number
+    end
+    
+  end
+  
+end

data/lib/active_scaffold/responds_to_parent.rb

@@ -0,0 +1,70 @@
+#  Copyright (c) 2006 Sean Treadway
+#  
+#  Permission is hereby granted, free of charge, to any person obtaining
+#  a copy of this software and associated documentation files (the
+#  "Software"), to deal in the Software without restriction, including
+#  without limitation the rights to use, copy, modify, merge, publish,
+#  distribute, sublicense, and/or sell copies of the Software, and to
+#  permit persons to whom the Software is furnished to do so, subject to
+#  the following conditions:
+#  
+#  The above copyright notice and this permission notice shall be
+#  included in all copies or substantial portions of the Software.
+#  
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+#  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+#  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+# Module containing the methods useful for child IFRAME to parent window communication
+module ActiveScaffold::RespondsToParent
+  
+  # Executes the response body as JavaScript in the context of the parent window.
+  # Use this method of you are posting a form to a hidden IFRAME or if you would like
+  # to use IFRAME base RPC.
+  def responds_to_parent(&block)
+    yield
+    
+    if performed?
+      # We're returning HTML instead of JS or XML now
+      response.headers['Content-Type'] = 'text/html; charset=UTF-8'
+      
+      # Either pull out a redirect or the request body
+      script =  if response.headers['Location']
+                  #TODO: erase_redirect_results is missing in rails 3.0 has to be implemented
+                  #erase redirect
+                  "document.location.href = #{location.to_s.inspect}"
+                else
+                  response.body
+                end
+                
+      # Escape quotes, linebreaks and slashes, maintaining previously escaped slashes
+      # Suggestions for improvement?
+      script = (script || '').
+        gsub('\\', '\\\\\\').
+        gsub(/\r\n|\r|\n/, '\\n').
+        gsub(/['"]/, '\\\\\&').
+        gsub('</script>','</scr"+"ipt>')
+
+      # Clear out the previous render to prevent double render
+      response.request.env['action_controller.instance'].instance_variable_set(:@_response_body, nil)
+      
+      # Eval in parent scope and replace document location of this frame 
+      # so back button doesn't replay action on targeted forms
+      # loc = document.location to be set after parent is updated for IE
+      # with(window.parent) - pull in variables from parent window
+      # setTimeout - scope the execution in the windows parent for safari
+      # window.eval - legal eval for Opera
+      render :text => "<html><body><script type='text/javascript' charset='utf-8'>
+        var loc = document.location;
+        with(window.parent) { setTimeout(function() { window.eval('#{script}'); if (typeof(loc) !== 'undefined') loc.replace('about:blank'); }, 1) };
+        </script></body></html>".html_safe
+    end
+  end
+  alias respond_to_parent responds_to_parent
+end
+

data/lib/active_scaffold/version.rb

@@ -0,0 +1,9 @@
+module ActiveScaffold
+  module Version
+    MAJOR = 0
+    MINOR = 3
+    PATCH = 0
+
+    STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+  end
+end