active_scaffold-sequel 0.3.0

data/lib/active_scaffold/data_structures/sorting.rb

@@ -0,0 +1,172 @@
+module ActiveScaffold::DataStructures
+  # encapsulates the column sorting configuration for the List view
+  class Sorting
+    def initialize(columns)
+      # a ActiveScaffold::DataStructures::Columns instance
+      @columns = columns
+
+      # @clauses is an array of pairs: [[column, params], ...]
+      # where 'column' is a ActiveScaffold::DataStructures::Column instance and
+      # 'params' is a hash with :table, :column, :descending keys
+      @clauses = []
+
+      # hash: 'column name'.to_sym => 'index to @clauses array'.to_i
+      @cindex = {}
+
+      # synchronize access to @cindex and @clauses
+      @mutex = Mutex.new
+    end
+    
+    def set_default_sorting(model)
+      order_clauses = model.dataset.opts[:order]
+
+      # If an ORDER BY clause is found set default sorting according to it, else
+      # fallback to setting primary key ordering
+      if order_clauses
+        # we are going to return nil from 'self.clause', but the @clauses need to be set for determining the sorting properties for view
+        set_sorting_from_order_clause(order_clauses, model.table_name)
+        @default_sorting = true
+      else
+        set(model.primary_key) if model.primary_key
+      end
+    end
+
+    def set_nested_sorting(table_name, order_clause)
+      clear
+      set_sorting_from_order_clause(order_clause, table_name)
+    end
+    
+    # add a clause to the sorting, assuming the column is sortable
+    def add(order, params = nil)
+      params = extract_order_params(order) unless params
+      column = get_column(params[:column])
+      raise ArgumentError, "Could not find column #{params[:column]} for #{order.inspect}" if column.nil?
+      if column.sortable?
+        @mutex.synchronize do
+          @clauses << [column, params]
+          @cindex[params[:column]] = @clauses.count - 1
+        end
+      end
+      raise ArgumentError, "Can't mix :method- and :sql-based sorting" if mixed_sorting?
+    end
+
+    def set(*args)
+      clear
+      args.each {|a| add(a)}
+    end
+
+    # clears the sorting
+    def clear
+      @mutex.synchronize do
+        @default_sorting = false
+        @clauses = []
+        @cindex = {}
+      end
+    end
+
+    # checks whether the given column (a Column object or a column name) is in the sorting
+    def sorts_on?(column)
+      !get_clause(column).nil?
+    end
+
+    def direction_of(column)
+      c = @mutex.synchronize do
+        i = @cindex[(column.respond_to?(:name) ? column.name : column)]
+        @clauses[i] if i
+      end
+      if c
+        c[1][:descending] ? 'DESC' : 'ASC'
+      end
+    end
+
+    # checks whether any column is configured to sort by method (using a proc)
+    def sorts_by_method?
+      @clauses.any? { |sorting| sorting[0].sort.is_a? Hash and sorting[0].sort.has_key? :method }
+    end
+
+    def sorts_by_sql?
+      @clauses.any? { |sorting| sorting[0].sort.is_a? Hash and sorting[0].sort.has_key? :sql }
+    end
+
+    # provides quick access to the first (and sometimes only) clause
+    def first
+      @clauses.first
+    end
+
+    # builds an order-by clause
+    def clause
+      return nil if sorts_by_method? || default_sorting?
+      @clauses.collect do |column,params|
+        if column.sort[:sql]
+          order = *column.sort[:sql]
+          order = order.collect {|o| o.respond_to?(:invert) ? o.invert : o.desc} if params[:descending]
+          order
+        end
+      end.flatten.compact
+    end
+
+    protected
+
+    # retrieves the sorting clause for the given column
+    def get_clause(column)
+      @mutex.synchronize do
+        i = @cindex[(column.respond_to?(:name) ? column.name : column)]
+        @clauses[i] if i
+      end
+    end
+
+    # possibly converts the given argument into a column object from @columns (if it's not already)
+    def get_column(name_or_column)
+      # it's a column
+      return name_or_column if name_or_column.is_a? ActiveScaffold::DataStructures::Column
+      # it's a name
+      return @columns[name_or_column]
+    end
+
+    def mixed_sorting?
+      sorts_by_method? and sorts_by_sql?
+    end
+    
+    def default_sorting?
+      @default_sorting
+    end
+
+    def set_sorting_from_order_clause(order_clauses, model_table_name = nil)
+      clear
+      order_clauses.each do |criterion|
+        params = extract_order_params(criterion)
+        add(criterion, params) unless different_table?(model_table_name, params[:table])
+      end
+    end
+    
+    def get_table_column(tcol)
+      table, column = tcol.to_s.split('__')
+      if column
+        [table.to_sym, column.to_sym]
+      else
+        [nil, table.to_sym]
+      end
+    end
+
+    def extract_order_params(criterion)
+      if criterion.respond_to?(:expression) and criterion.respond_to?(:descending)  # Sequel::SQL::OrderedExpression
+        expression = criterion.expression
+        if expression.respond_to?(:table) and expression.respond_to?(:column)  # Sequel::SQL::QualifiedIdentifier
+          table = expression.table
+          column = expression.column
+        else
+          table, column = get_table_column(expression)
+        end
+        descending = criterion.descending
+      else
+        table, column = get_table_column(criterion)
+        descending = false
+      end
+      {:table => table, :column => column, :descending => descending}
+    end
+    
+    def different_table?(model_table_name, order_table_name)
+      model_table_name and order_table_name and model_table_name != order_table_name
+    end
+  end
+end

data/lib/active_scaffold/engine.rb

@@ -0,0 +1,4 @@
+module ActiveScaffold
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/active_scaffold/extensions/action_controller_rendering.rb

@@ -0,0 +1,22 @@
+# wrap the action rendering for ActiveScaffold controllers
+module ActionController #:nodoc:
+  class Base
+    def render_with_active_scaffold(*args, &block)
+      if self.class.uses_active_scaffold? and params[:adapter] and @rendering_adapter.nil?
+        @rendering_adapter = true # recursion control
+        # if we need an adapter, then we render the actual stuff to a string and insert it into the adapter template
+        opts = args.blank? ? Hash.new : args.first
+        render :partial => params[:adapter][1..-1],
+        :locals => {:payload => render_to_string(opts.merge(:layout => false), &block).html_safe},
+               :use_full_path => true, :layout => false, :content_type => :html
+        @rendering_adapter = nil # recursion control
+      else
+        render_without_active_scaffold(*args, &block)
+      end
+    end
+    alias_method_chain :render, :active_scaffold
+
+    # Rails 2.x implementation is post-initialization on :active_scaffold method
+  end
+end
+

data/lib/active_scaffold/extensions/action_view_rendering.rb

@@ -0,0 +1,115 @@
+module ActionView
+  class LookupContext
+    module ViewPaths
+      def find_all_templates(name, partial = false, locals = {})
+        prefixes.collect do |prefix|
+          view_paths.collect do |resolver|
+            if Rails.version < '3.2.0' # FIXME: remove when rails 3.1 support is dropped
+              temp_args = *args_for_lookup(name, [prefix], partial, locals)
+            else
+              temp_args = *args_for_lookup(name, [prefix], partial, locals, {})
+            end
+            temp_args[1] = temp_args[1][0]
+            resolver.find_all(*temp_args)
+          end
+        end.flatten!
+      end
+    end
+  end
+end
+
+# wrap the action rendering for ActiveScaffold views
+module ActionView::Helpers #:nodoc:
+  module RenderingHelper
+    #
+    # Adds two rendering options.
+    #
+    # ==render :super
+    #
+    # This syntax skips all template overrides and goes directly to the provided ActiveScaffold templates.
+    # Useful if you want to wrap an existing template. Just call super!
+    #
+    # ==render :active_scaffold => #{controller.to_s}, options = {}+
+    #
+    # Lets you embed an ActiveScaffold by referencing the controller where it's configured.
+    #
+    # You may specify options[:constraints] for the embedded scaffold. These constraints have three effects:
+    #   * the scaffold's only displays records matching the constraint
+    #   * all new records created will be assigned the constrained values
+    #   * constrained columns will be hidden (they're pretty boring at this point)
+    #
+    # You may also specify options[:conditions] for the embedded scaffold. These only do 1/3 of what
+    # constraints do (they only limit search results). Any format accepted by Sequel::Model.find is valid.
+    #
+    # Defining options[:label] lets you completely customize the list title for the embedded scaffold.
+    #
+    def render_with_active_scaffold(*args, &block)
+      if args.first == :super
+        last_view = view_stack.last || {:view => instance_variable_get(:@virtual_path).split('/').last}
+        options = args[1] || {}
+        options[:locals] ||= {}
+        options[:locals].reverse_merge!(last_view[:locals] || {})
+        if last_view[:templates].nil?
+          last_view[:templates] = lookup_context.find_all_templates(last_view[:view], last_view[:partial], options[:locals].keys)
+          last_view[:templates].shift
+        end
+        options[:template] = last_view[:templates].shift
+        view_stack << last_view
+        result = render_without_active_scaffold options
+        view_stack.pop
+        result
+      elsif args.first.is_a? Hash and args.first[:active_scaffold]
+        require 'digest/md5'
+        options = args.first
+
+        remote_controller = options[:active_scaffold]
+        constraints = options[:constraints]
+        conditions = options[:conditions]
+        eid = Digest::MD5.hexdigest(params[:controller] + remote_controller.to_s + constraints.to_s + conditions.to_s)
+        session["as:#{eid}"] = {:constraints => constraints, :conditions => conditions, :list => {:label => args.first[:label]}}
+        options[:params] ||= {}
+        options[:params].merge! :eid => eid, :embedded => true
+
+        id = "as_#{eid}-embedded"
+        url_options = {:controller => remote_controller.to_s, :action => 'index'}.merge(options[:params])
+
+        if controller.respond_to?(:render_component_into_view)
+          controller.send(:render_component_into_view, url_options)
+        else
+          content_tag(:div, :id => id, :class => 'active-scaffold-component') do
+            url = url_for(url_options)
+            # parse the ActiveRecord model name from the controller path, which
+            # might be a namespaced controller (e.g., 'admin/admins')
+            model = remote_controller.to_s.sub(/.*\//, '').singularize
+            content_tag(:div, :class => 'active-scaffold-header') do
+              content_tag :h2, link_to(args.first[:label] || active_scaffold_config_for(model).list.label, url, :remote => true)
+            end <<
+            if ActiveScaffold.js_framework == :prototype
+              javascript_tag("new Ajax.Updater('#{id}', '#{url}', {method: 'get', evalScripts: true});")
+            elsif ActiveScaffold.js_framework == :jquery
+              javascript_tag("jQuery('##{id}').load('#{url}');")
+            end
+          end
+        end
+
+      else
+        options = args.first
+        if options.is_a?(Hash)
+          current_view = {:view => options[:partial], :partial => true} if options[:partial]
+          current_view = {:view => options[:template], :partial => false} if current_view.nil? && options[:template]
+          current_view[:locals] = options[:locals] if !current_view.nil? && options[:locals]
+          view_stack << current_view if current_view.present?
+        end
+        result = render_without_active_scaffold(*args, &block)
+        view_stack.pop if current_view.present?
+        result
+      end
+    end
+    alias_method_chain :render, :active_scaffold
+    
+    def view_stack
+      @_view_stack ||= []
+    end
+
+  end
+end

data/lib/active_scaffold/extensions/active_record_offset.rb

@@ -0,0 +1,12 @@
+# Bugfix: Team.offset(1).limit(1) throws an error
+Sequel::Model.instance_eval do
+  def offset(*args, &block) 
+    scoped.__send__(:offset, *args, &block)
+  rescue NoMethodError       
+    if scoped.nil?           
+      'depends on :allow_nil'
+    else                     
+      raise                  
+    end                      
+  end       
+end

data/lib/active_scaffold/extensions/array.rb

@@ -0,0 +1,7 @@
+class Array
+  # returns the value after the given value. wraps around. defaults to first element in array.
+  def after(value)
+    return nil unless include? value
+    self[(index(value).to_i + 1) % length]
+  end
+end

data/lib/active_scaffold/extensions/cache_association.rb

@@ -0,0 +1,16 @@
+module ActiveRecord
+  class Relation
+    def target=(records)
+      @loaded = true
+      @records = records
+      @records
+    end
+  end
+end
+module ActiveRecord
+  module Associations
+    class CollectionProxy
+      delegate :target=, :to => :@association
+    end
+  end
+end

data/lib/active_scaffold/extensions/localize.rb

@@ -0,0 +1,10 @@
+class Object
+  def as_(key, options = {})
+    unless key.blank?
+      text = I18n.translate "#{key}", {:scope => [:active_scaffold], :default => key.is_a?(String) ? key : key.to_s.titleize}.merge(options)
+      # text = nil if text.include?('translation missing:')
+    end
+    text ||= key 
+    text
+  end
+end

data/lib/active_scaffold/extensions/name_option_for_datetime.rb

@@ -0,0 +1,12 @@
+module ActionView
+  module Helpers
+    class InstanceTag
+      private
+      def datetime_selector_with_name(options, html_options)
+        options.merge!(:prefix => options[:name].gsub(/\[[^\[]*\]$/,'')) if options[:name]
+        datetime_selector_without_name(options, html_options)        
+      end
+      alias_method_chain :datetime_selector, :name
+    end
+  end
+end

data/lib/active_scaffold/extensions/nil_id_in_url_params.rb

@@ -0,0 +1,7 @@
+class ActionController::Routing::RouteSet
+  def generate_with_nil_id_awareness(*args)
+    args[0].delete(:id) if args[0][:id].nil?
+    generate_without_nil_id_awareness(*args)
+  end
+  alias_method_chain :generate, :nil_id_awareness
+end

data/lib/active_scaffold/extensions/paginator_extensions.rb

@@ -0,0 +1,26 @@
+require 'active_scaffold/paginator'
+
+class ActiveScaffold::Paginator
+
+  # Total number of pages
+  def number_of_pages_with_infinite
+    number_of_pages_without_infinite unless infinite?
+  end
+  alias_method_chain :number_of_pages, :infinite
+  
+  # Is this an "infinite" paginator
+  def infinite?
+    @count.nil?
+  end
+  
+  class Page
+    # Checks to see if there's a page after this one
+    def next_with_infinite?
+      return true if @pager.infinite?
+      next_without_infinite?
+    end
+    alias_method_chain :next?, :infinite
+  end
+
+end
+

data/lib/active_scaffold/extensions/routing_mapper.rb

@@ -0,0 +1,48 @@
+module ActionDispatch
+  module Routing
+    ACTIVE_SCAFFOLD_CORE_ROUTING = {
+        :collection => {:show_search => :get, :render_field => :get},
+        :member => {:row => :get, :update_column => :post, :render_field => :get}
+    }
+    ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING = {
+        :collection => {:edit_associated => :get, :new_existing => :get, :add_existing => :post},
+        :member => {:edit_associated => :get, :add_association => :get, :destroy_existing => :delete}
+    }
+    class Mapper
+      module Base
+        def as_routes(options = {:association => true})
+          collection do
+            ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection].each {|name, type| send(type, name)}
+          end
+          member do
+            ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:member].each {|name, type| send(type, name)}
+          end
+          as_association_routes if options[:association]
+        end
+        
+        def as_association_routes
+          collection do 
+            ActionDispatch::Routing::ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING[:collection].each {|name, type| send(type, name)}
+          end
+          member do
+            ActionDispatch::Routing::ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING[:member].each {|name, type| send(type, name)}
+          end
+        end
+        
+        def as_nested_resources(*resources)
+          options = resources.extract_options!
+          resources.each do |resource|
+            resources(resource, options.merge(:parent_scaffold => merge_module_scope(@scope[:module], parent_resource.plural), :association => resource)) { yield if block_given? }
+          end
+        end
+        
+        def as_scoped_routes(*scopes)
+          options = scopes.extract_options!
+          scopes.each do |scope|
+            resources(scope, options.merge(:parent_scaffold => merge_module_scope(@scope[:module], parent_resource.plural), :named_scope => scope, :controller => parent_resource.plural)) { yield if block_given? }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_scaffold/extensions/to_label.rb

@@ -0,0 +1,8 @@
+# the ever-useful to_label method
+class Sequel::Model
+  def to_label
+    [:name, :label, :title, :to_s].each do |attribute|
+      return send(attribute).to_s if respond_to?(attribute)
+    end
+  end
+end

data/lib/active_scaffold/extensions/unsaved_associated.rb

@@ -0,0 +1,60 @@
+# save and validation support for associations.
+class Sequel::Model
+  def associated_valid?(path = [])
+    return true if path.include?(self) # prevent recursion (if associated and parent are new records)
+    path << self
+    # using [].all? syntax to avoid a short-circuit
+    with_unsaved_associated { |a| [a.valid?, a.associated_valid?(path)].all? {|v| v == true} }
+  end
+
+  def save_associated
+    with_unsaved_associated { |a| a.save and a.save_associated }
+  end
+
+  def save_associated!
+    save_associated or raise(Sequel::Error)
+  end
+
+  def no_errors_in_associated?
+    with_unsaved_associated {|a| a.errors.count == 0 and a.no_errors_in_associated?}
+  end
+
+  protected
+
+  # Provide an override to allow the model to restrict which associations are considered
+  # by ActiveScaffolds update mechanism. This allows the model to restrict things like
+  # Acts-As-Versioned versions associations being traversed.
+  #
+  # By defining the method :scaffold_update_nofollow returning an array of associations
+  # these associations will not be traversed.
+  # By defining the method :scaffold_update_follow returning an array of associations,
+  # only those associations will be traversed.
+  #
+  # Otherwise the default behaviour of traversing all associations will be preserved.
+  def associations_for_update
+    if self.respond_to?( :scaffold_update_nofollow )
+      self.class.associations.reject {|association| self.scaffold_update_nofollow.include?(association)}
+    elsif self.respond_to?( :scaffold_update_follow )
+      self.class.associations.select {|association| self.scaffold_update_follow.include?(association)}
+    else
+      self.class.associations
+    end
+  end
+
+  private
+
+  # yields every associated object that has been instantiated and is flagged as unsaved.
+  # returns false if any yield returns false.
+  # returns true otherwise, even when none of the associations have been instantiated. build wrapper methods accordingly.
+  def with_unsaved_associated
+    associations_for_update.all? do |association|
+      records = send(association)
+      if records
+        records = [records] unless records.is_a? Array # convert singular associations into collections for ease of use
+        records.select {|r| r.unsaved?}.all? {|r| yield r} # must use select instead of find_all, which Rails overrides on association proxies for db access
+      else
+        true
+      end
+    end
+  end
+end

data/lib/active_scaffold/extensions/unsaved_record.rb

@@ -0,0 +1,20 @@
+# a simple (manual) unsaved? flag and method. at least it automatically reverts after a save!
+class Sequel::Model
+  # acts like a dirty? flag, manually thrown during update_record_from_params.
+  def unsaved=(val)
+    @unsaved = (val) ? true : false
+  end
+
+  # whether the unsaved? flag has been thrown
+  def unsaved?
+    @unsaved
+  end
+
+  # automatically unsets the unsaved flag
+  def save_with_unsaved_flag(*args)
+    result = save_without_unsaved_flag(*args)
+    self.unsaved = false
+    return result
+  end
+  alias_method_chain :save, :unsaved_flag
+end

data/lib/active_scaffold/extensions/usa_state.rb

@@ -0,0 +1,46 @@
+module ActionView
+  module Helpers
+    module FormOptionsHelper
+
+      # Return a full select and option tags for the given object and method, using usa_state_options_for_select to generate the list of option <tags>.
+      def usa_state_select(object, method, priority_states = nil, options = {}, html_options = {})
+        InstanceTag.new(object, method, self, options.delete(:object)).to_usa_state_select_tag(priority_states, options, html_options)
+      end
+    
+
+      # Returns a string of option tags for the states in the United States. Supply a state name as +selected to
+      # have it marked as the selected option tag. Included also is the option to set a couple of +priority_states+ 
+      # in case you want to highligh a local area
+      # NOTE: Only the option tags are returned from this method, wrap it in a <select>
+      def usa_state_options_for_select(selected = nil, priority_states = nil)
+        state_options = ""
+        if priority_states
+          state_options += options_for_select(priority_states, selected)
+          state_options += "<option>-------------</option>\n"
+        end
+
+        if priority_states && priority_states.include?(selected)
+          state_options += options_for_select(USASTATES - priority_states, selected)
+        else
+          state_options += options_for_select(USASTATES, selected)
+        end
+
+        return state_options
+      end
+
+    	USASTATES = [["Alabama", "AL"], ["Alaska", "AK"], ["Arizona", "AZ"], ["Arkansas", "AR"], ["California", "CA"], ["Colorado", "CO"], ["Connecticut", "CT"], ["Delaware", "DE"], ["District of Columbia", "DC"], ["Florida", "FL"], ["Georgia", "GA"], ["Hawaii", "HI"], ["Idaho", "ID"], ["Illinois", "IL"], ["Indiana", "IN"], ["Iowa", "IA"], ["Kansas", "KS"], ["Kentucky", "KY"], ["Louisiana", "LA"], ["Maine", "ME"], ["Maryland", "MD"], ["Massachusetts", "MA"], ["Michigan", "MI"], ["Minnesota", "MN"], ["Mississippi", "MS"], ["Missouri", "MO"], ["Montana", "MT"], ["Nebraska", "NE"], ["Nevada", "NV"], ["New Hampshire", "NH"], ["New Jersey", "NJ"], ["New Mexico", "NM"], ["New York", "NY"], ["North Carolina", "NC"], ["North Dakota", "ND"], ["Ohio", "OH"], ["Oklahoma", "OK"], ["Oregon", "OR"], ["Pennsylvania", "PA"], ["Rhode Island", "RI"], ["South Carolina", "SC"], ["South Dakota", "SD"], ["Tennessee", "TN"], ["Texas", "TX"], ["Utah", "UT"], ["Vermont", "VT"], ["Virginia", "VA"], ["Washington", "WA"], ["Wisconsin", "WI"], ["West Virginia", "WV"], ["Wyoming", "WY"]] unless const_defined?("USASTATES")
+ 
+    end
+  
+    class InstanceTag #:nodoc:
+      include FormOptionsHelper
+ 
+      def to_usa_state_select_tag(priority_states, options, html_options)
+        html_options = html_options.stringify_keys
+        add_default_name_and_id(html_options)
+        value = value(object) if method(:value).arity > 0
+        content_tag("select", add_options(usa_state_options_for_select(value, priority_states), options, value), html_options)
+      end
+    end
+  end
+end