active_scaffold_vho 3.0.6

data/lib/active_scaffold.rb

@@ -0,0 +1,345 @@
+unless Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR >= 0
+  raise "This version of ActiveScaffold requires Rails 3.0 or higher.  Please use an earlier version."
+end
+
+begin
+  require 'render_component'
+rescue LoadError
+end
+begin
+  require 'verification'
+rescue LoadError
+end
+
+require 'active_record_permissions'
+require 'dhtml_confirm'
+require 'paginator'
+require 'responds_to_parent'
+
+require 'active_scaffold/version'
+
+module ActiveScaffold
+  autoload :AttributeParams, 'active_scaffold/attribute_params'
+  autoload :Configurable, 'active_scaffold/configurable'
+  autoload :Constraints, 'active_scaffold/constraints'
+  autoload :Finder, 'active_scaffold/finder'
+  autoload :MarkedModel, 'active_scaffold/marked_model'
+
+  def self.active_scaffold_autoload_subdir(dir, mod=self)
+    Dir["#{File.dirname(__FILE__)}/active_scaffold/#{dir}/*.rb"].each { |file|
+      basename = File.basename(file, ".rb")
+      mod.module_eval {
+        autoload basename.camelcase.to_sym, "active_scaffold/#{dir}/#{basename}"
+      }
+    }
+  end
+
+  module Actions
+    ActiveScaffold.active_scaffold_autoload_subdir('actions', self)
+  end
+
+  module Bridges
+    autoload :Bridge, 'active_scaffold/bridges/bridge'
+  end
+
+  module Config
+    ActiveScaffold.active_scaffold_autoload_subdir('config', self)
+  end
+
+  module DataStructures
+    ActiveScaffold.active_scaffold_autoload_subdir('data_structures', self)
+  end
+
+  module Helpers
+    ActiveScaffold.active_scaffold_autoload_subdir('helpers', self)
+  end
+
+  class ControllerNotFound < RuntimeError; end
+  class DependencyFailure < RuntimeError; end
+  class MalformedConstraint < RuntimeError; end
+  class RecordNotAllowed < SecurityError; end
+  class ActionNotAllowed < SecurityError; end
+  class ReverseAssociationRequired < RuntimeError; end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.module_eval do
+      # TODO: these should be in actions/core
+      before_filter :handle_user_settings
+    end
+  end
+
+  def self.set_defaults(&block)
+    ActiveScaffold::Config::Core.configure &block
+  end
+  
+  def active_scaffold_config
+    self.class.active_scaffold_config
+  end
+
+  def active_scaffold_config_for(klass)
+    self.class.active_scaffold_config_for(klass)
+  end
+
+  def active_scaffold_session_storage
+    id = params[:eid] || params[:controller]
+    session_index = "as:#{id}"
+    session[session_index] ||= {}
+    session[session_index]
+  end
+
+  # at some point we need to pass the session and params into config. we'll just take care of that before any particular action occurs by passing those hashes off to the UserSettings class of each action.
+  def handle_user_settings
+    if self.class.uses_active_scaffold?
+      active_scaffold_config.actions.each do |action_name|
+        conf_instance = active_scaffold_config.send(action_name) rescue next
+        next if conf_instance.class::UserSettings == ActiveScaffold::Config::Base::UserSettings # if it hasn't been extended, skip it
+        active_scaffold_session_storage[action_name] ||= {}
+        conf_instance.user = conf_instance.class::UserSettings.new(conf_instance, active_scaffold_session_storage[action_name], params)
+      end
+    end
+  end
+  
+  def self.js_framework=(framework)
+    @@js_framework = framework
+  end
+  
+  def self.js_framework
+    @@js_framework ||= :prototype
+  end
+
+  def self.root
+    File.dirname(__FILE__) + "/.."
+  end
+
+  module ClassMethods
+    def active_scaffold(model_id = nil, &block)
+      # initialize bridges here
+      ActiveScaffold::Bridges::Bridge.run_all
+
+      # converts Foo::BarController to 'bar' and FooBarsController to 'foo_bar' and AddressController to 'address'
+      model_id = self.to_s.split('::').last.sub(/Controller$/, '').pluralize.singularize.underscore unless model_id
+
+      # run the configuration
+      @active_scaffold_config = ActiveScaffold::Config::Core.new(model_id)
+      @active_scaffold_config_block = block
+      self.links_for_associations
+
+      @active_scaffold_overrides = []
+      ActionController::Base.view_paths.each do |dir|
+        active_scaffold_overrides_dir = File.join(dir.to_s,"active_scaffold_overrides")
+        @active_scaffold_overrides << active_scaffold_overrides_dir if File.exists?(active_scaffold_overrides_dir)
+      end
+      @active_scaffold_overrides.uniq! # Fix rails duplicating some view_paths
+      @active_scaffold_frontends = []
+      if active_scaffold_config.frontend.to_sym != :default
+        active_scaffold_custom_frontend_path = File.join(ActiveScaffold::Config::Core.plugin_directory, 'frontends', active_scaffold_config.frontend.to_s , 'views')
+        @active_scaffold_frontends << active_scaffold_custom_frontend_path
+      end
+      active_scaffold_default_frontend_path = File.join(ActiveScaffold::Config::Core.plugin_directory, 'frontends', 'default' , 'views')
+      @active_scaffold_frontends << active_scaffold_default_frontend_path
+      @active_scaffold_custom_paths = []
+
+      self.active_scaffold_superclasses_blocks.each {|superblock| self.active_scaffold_config.configure &superblock}
+      self.active_scaffold_config.sti_children = nil # reset sti_children if set in parent block
+      self.active_scaffold_config.configure &block if block_given?
+      self.active_scaffold_config._configure_sti unless self.active_scaffold_config.sti_children.nil?
+      self.active_scaffold_config._load_action_columns
+
+      # defines the attribute read methods on the model, so record.send() doesn't find protected/private methods instead
+      klass = self.active_scaffold_config.model
+      klass.define_attribute_methods unless klass.attribute_methods_generated?
+      # include the rest of the code into the controller: the action core and the included actions
+      module_eval do
+        include ActiveScaffold::Finder
+        include ActiveScaffold::Constraints
+        include ActiveScaffold::AttributeParams
+        include ActiveScaffold::Actions::Core
+        active_scaffold_config.actions.each do |mod|
+          name = mod.to_s.camelize
+          include "ActiveScaffold::Actions::#{name}".constantize
+
+          # sneak the action links from the actions into the main set
+          if link = active_scaffold_config.send(mod).link rescue nil
+            if link.is_a? Array
+              link.each {|current| active_scaffold_config.action_links.add_to_group(current, active_scaffold_config.send(mod).action_group)}
+            elsif link.is_a? ActiveScaffold::DataStructures::ActionLink
+              active_scaffold_config.action_links.add_to_group(link, active_scaffold_config.send(mod).action_group)
+            end
+          end
+        end
+      end
+      active_scaffold_paths.each do |path|
+        self.append_view_path(ActionView::ActiveScaffoldResolver.new(path))
+      end
+      self._add_sti_create_links if self.active_scaffold_config.add_sti_create_links?
+    end
+
+    # To be called after include action modules
+    def _add_sti_create_links
+      new_action_link = active_scaffold_config.action_links.collection['new']
+      unless new_action_link.nil? || active_scaffold_config.sti_children.empty?
+        active_scaffold_config.action_links.collection.delete('new')
+        active_scaffold_config.sti_children.each do |child|
+          new_sti_link = Marshal.load(Marshal.dump(new_action_link)) # deep clone
+          new_sti_link.label = child.to_s.camelize.constantize.model_name.human
+          new_sti_link.parameters = {:parent_sti => controller_path}
+          new_sti_link.controller = Proc.new { active_scaffold_controller_for(child.to_s.camelize.constantize).controller_path }
+          active_scaffold_config.action_links.collection.create.add(new_sti_link)
+        end
+      end
+    end
+
+    # Create the automatic column links. Note that this has to happen when configuration is *done*, because otherwise the Nested module could be disabled. Actually, it could still be disabled later, couldn't it?
+    def links_for_associations
+      return unless active_scaffold_config.actions.include? :list and active_scaffold_config.actions.include? :nested
+      active_scaffold_config.columns.each do |column|
+        next unless column.link.nil? and column.autolink?
+        #lazy load of action_link, cause it was really slowing down app in dev mode
+        #and might lead to trouble cause of cyclic constantization of controllers
+        #and might be unnecessary cause it is done before columns are configured
+        column.set_link(Proc.new {|col| link_for_association(col)})
+      end
+    end
+    
+    def link_for_association(column, options = {})
+      begin
+        controller = if column.polymorphic_association?
+          :polymorph
+        elsif options.include?(:controller)
+          "#{options[:controller].to_s.camelize}Controller".constantize
+        else
+          active_scaffold_controller_for(column.association.klass)
+        end
+      rescue ActiveScaffold::ControllerNotFound
+        controller = nil        
+      end
+      
+      unless controller.nil?
+        options.reverse_merge! :label => column.label, :position => :after, :type => :member, :controller => (controller == :polymorph ? controller : controller.controller_path), :column => column
+        options[:parameters] ||= {}
+        options[:parameters].reverse_merge! :parent_scaffold => controller_path, :association => column.association.name
+        if column.plural_association?
+          # note: we can't create nested scaffolds on :through associations because there's no reverse association.
+          
+          ActiveScaffold::DataStructures::ActionLink.new('index', options) #unless column.through_association?
+        else
+          actions = [:create, :update, :show] 
+          actions = controller.active_scaffold_config.actions unless controller == :polymorph
+          column.actions_for_association_links.delete :new unless actions.include? :create
+          column.actions_for_association_links.delete :edit unless actions.include? :update
+          column.actions_for_association_links.delete :show unless actions.include? :show
+          ActiveScaffold::DataStructures::ActionLink.new(:none, options.merge({:crud_type => nil, :html_options => {:class => column.name}}))
+        end 
+      end
+    end
+    
+    def link_for_association_as_scope(scope, options = {})
+      options.reverse_merge! :label => scope, :position => :after, :type => :member, :controller => controller_path
+      options[:parameters] ||= {}
+      options[:parameters].reverse_merge! :parent_scaffold => controller_path, :named_scope => scope
+      ActiveScaffold::DataStructures::ActionLink.new('index', options)
+    end
+
+    def add_active_scaffold_path(path)
+      @active_scaffold_paths = nil # Force active_scaffold_paths to rebuild
+      @active_scaffold_custom_paths << path
+    end
+
+    def add_active_scaffold_override_path(path)
+      @active_scaffold_paths = nil # Force active_scaffold_paths to rebuild
+      @active_scaffold_overrides.unshift path
+    end
+
+    def active_scaffold_paths
+      return @active_scaffold_paths unless @active_scaffold_paths.nil?
+
+      #@active_scaffold_paths = ActionView::PathSet.new
+      @active_scaffold_paths = []
+      @active_scaffold_paths.concat @active_scaffold_overrides unless @active_scaffold_overrides.nil?
+      @active_scaffold_paths.concat @active_scaffold_custom_paths unless @active_scaffold_custom_paths.nil?
+      @active_scaffold_paths.concat @active_scaffold_frontends unless @active_scaffold_frontends.nil?
+      @active_scaffold_paths
+    end
+
+    def active_scaffold_config
+      if @active_scaffold_config.nil?
+        self.superclass.active_scaffold_config if self.superclass.respond_to? :active_scaffold_config
+      else
+        @active_scaffold_config
+      end
+    end
+
+    def active_scaffold_config_block
+      @active_scaffold_config_block
+    end
+
+    def active_scaffold_superclasses_blocks
+      blocks = []
+      klass = self.superclass
+      while klass.respond_to? :active_scaffold_superclasses_blocks
+        blocks << klass.active_scaffold_config_block
+        klass = klass.superclass
+      end
+      blocks.compact.reverse
+    end
+
+    def active_scaffold_config_for(klass)
+      begin
+        controller = active_scaffold_controller_for(klass)
+      rescue ActiveScaffold::ControllerNotFound
+        config = ActiveScaffold::Config::Core.new(klass)
+        config._load_action_columns
+        config
+      else
+        controller.active_scaffold_config
+      end
+    end
+
+    # Tries to find a controller for the given ActiveRecord model.
+    # Searches in the namespace of the current controller for singular and plural versions of the conventional "#{model}Controller" syntax.
+    # You may override this method to customize the search routine.
+    def active_scaffold_controller_for(klass)
+      controller_namespace = self.to_s.split('::')[0...-1].join('::') + '::'
+      error_message = []
+      [controller_namespace, ''].each do |namespace|
+        ["#{klass.to_s.underscore.pluralize}", "#{klass.to_s.underscore.pluralize.singularize}"].each do |controller_name|
+          begin
+            controller = "#{namespace}#{controller_name.camelize}Controller".constantize
+          rescue NameError => error
+            # Only rescue NameError associated with the controller constant not existing - not other compile errors
+            if error.message["uninitialized constant #{controller}"]
+              error_message << "#{namespace}#{controller_name.camelize}Controller"
+              next
+            else
+              raise
+            end
+          end
+          raise ActiveScaffold::ControllerNotFound, "#{controller} missing ActiveScaffold", caller unless controller.uses_active_scaffold?
+          raise ActiveScaffold::ControllerNotFound, "ActiveScaffold on #{controller} is not for #{klass} model.", caller unless controller.active_scaffold_config.model == klass
+          return controller
+        end
+      end
+      raise ActiveScaffold::ControllerNotFound, "Could not find " + error_message.join(" or "), caller
+    end
+
+    def uses_active_scaffold?
+      !active_scaffold_config.nil?
+    end
+  end
+end
+
+require 'environment'
+
+##
+## Run the install assets script, too, just to make sure
+## But at least rescue the action in production
+##
+Rails::Application.initializer("active_scaffold.install_assets") do
+  begin
+    ActiveScaffoldAssets.copy_to_public(ActiveScaffold.root, {:clean_up_destination => true})
+  rescue
+    raise $! unless Rails.env == 'production'
+  end
+end unless defined?(ACTIVE_SCAFFOLD_PLUGIN) && ACTIVE_SCAFFOLD_PLUGIN == true
+

data/lib/active_scaffold_assets.rb

@@ -0,0 +1,45 @@
+class ActiveScaffoldAssets
+
+  def self.copy_to_public(from, options = {})
+    unless defined?(ACTIVE_SCAFFOLD_INSTALL_ASSETS) && ACTIVE_SCAFFOLD_INSTALL_ASSETS == false
+      copy_files("/public", "/public", from)
+      available_frontends = Dir[File.join(from, 'frontends', '*')].collect { |d| File.basename d }
+      [:stylesheets, :javascripts, :images].each do |asset_type|
+        copy_asset_type(from, available_frontends, asset_type, options)
+      end
+    end
+  end
+
+protected
+
+  def self.copy_asset_type(from, available_frontends, asset_type, options = {})
+    path = "/public/#{asset_type}/active_scaffold"
+    copy_files(path, path, from)
+
+    File.open(File.join(Rails.root, path, 'DO_NOT_EDIT'), 'w') do |f|
+      f.puts "Any changes made to files in sub-folders will be lost."
+      f.puts "See http://activescaffold.com/tutorials/faq#custom-css."
+    end
+
+    available_frontends.each do |frontend|
+      if asset_type == :javascripts
+        file_mask = '*.js'
+        source = "/frontends/#{frontend}/#{asset_type}/#{ActiveScaffold.js_framework}"
+      else
+        file_mask = '*.*'
+        source = "/frontends/#{frontend}/#{asset_type}"
+      end
+      destination = "/public/#{asset_type}/active_scaffold/#{frontend}"
+      copy_files(source, destination, from, file_mask, options)
+    end
+  end
+
+  def self.copy_files(source_path, destination_path, directory, file_mask = '*.*', options = {})
+    source, destination = File.join(directory, source_path), File.join(Rails.root, destination_path)
+    FileUtils.mkdir_p(destination) unless File.exist?(destination)
+    Dir.glob('*.so')
+
+    FileUtils.rm Dir.glob("#{destination}/*") if options[:clean_up_destination]
+    FileUtils.cp_r(Dir.glob("#{source}/#{file_mask}"), destination)
+  end
+end

data/lib/dhtml_confirm.rb

@@ -0,0 +1,54 @@
+# Matt Mower <matt@cominded.com>
+# 
+# A base class for creating DHTML confirmation types.
+#
+# The real work is done by the onclick_function and onclick_handler methods. In
+# general it should only be required to override the default onclick_handler
+# method and provide the specific Javascript required to invoke the DHTML confirm
+# dialog of your choice.
+#
+# It is up to this dialog, if the user confirms the intended action, to invoke
+# the function window.gFireModalLink() to trigger the intended action of the link.
+# For example, using the Modalbox library, you would use something like:
+#
+#     Modalbox.hide( {
+#               afterHide: function() {
+#                 window.gFireModalLink();
+#               } } );
+#
+# By default the only action recognized is :value which is used to add a
+# dhtml_confirm attribute to the link <a> tag. This value is detected by the
+# ActiveScaffold link and triggers the DHTML confirmation logic.
+#
+class DHTMLConfirm
+  attr_accessor :value, :message, :options
+  
+  def initialize( options = {} )
+    @options = options
+    @value = @options.delete(:value) { |key| "yes" }
+    @message = @options.delete(:message) { |key| "Are you sure?" }
+  end
+  
+  def onclick_function( controller, link_id )
+    script = <<-END
+window.gFireModalLink = function() {
+  var link = $('#{link_id}').action_link;
+  link.open_action.call( link );
+};
+#{ensure_termination(onclick_handler(controller,link_id))}
+return false;
+END
+    # script = "window.gModalLink = $('#{link_id}').action_link;#{onclick_handler(controller,link_id)}return false;"
+  end
+  
+  def onclick_handler( controller, link_id )
+    ""
+  end
+  
+protected
+  def ensure_termination( expression )
+    expression =~ /;$/ ? expression : "#{expression};"
+  end
+  
+end
+

data/lib/environment.rb

@@ -0,0 +1,14 @@
+# TODO: clean up extensions. some could be organized for autoloading, and others could be removed entirely.
+Dir["#{File.dirname __FILE__}/extensions/*.rb"].each { |file| require file }
+
+ActionController::Base.send(:include, ActiveScaffold)
+ActionController::Base.send(:include, RespondsToParent)
+ActionController::Base.send(:include, ActiveScaffold::Helpers::ControllerHelpers)
+ActionView::Base.send(:include, ActiveScaffold::Helpers::ViewHelpers)
+
+ActionController::Base.class_eval {include ActiveRecordPermissions::ModelUserAccess::Controller}
+ActiveRecord::Base.class_eval     {include ActiveRecordPermissions::ModelUserAccess::Model}
+ActiveRecord::Base.class_eval     {include ActiveRecordPermissions::Permissions}
+
+I18n.load_path += Dir[File.join(File.dirname(__FILE__), 'active_scaffold', 'locale', '*.{rb,yml}')]
+#ActiveScaffold.js_framework = :jquery

data/lib/extensions/action_controller_rendering.rb

@@ -0,0 +1,20 @@
+# 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
+        render :partial => params[:adapter][1..-1],
+        :locals => {:payload => render_to_string(args.first.merge(:layout => false), &block)},
+               :use_full_path => true, :layout => false
+        @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/extensions/action_view_rendering.rb

@@ -0,0 +1,113 @@
+module ActionView
+  class LookupContext
+    module ViewPaths
+      def find_all_templates(name, prefix = nil, partial = false)
+        templates = []
+        @view_paths.each do |resolver|
+          template = resolver.find_all(*args_for_lookup(name, prefix, partial)).first
+          templates << template unless template.nil?
+        end
+        templates
+      end
+    end
+  end
+end
+
+# wrap the action rendering for ActiveScaffold views
+module ActionView::Rendering #:nodoc:
+  # 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 ActiveRecord::Base.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
+      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], controller_path, !@last_view[:is_template])
+        @last_view[:templates].shift
+      end
+      options[:template] = @last_view[:templates].shift
+      render_without_active_scaffold options
+    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}-content"
+      url_options = {:controller => remote_controller.to_s, :action => 'index'}.merge(options[:params])
+      
+      if respond_to? :render_component
+        render_component url_options
+      else
+        content_tag(:div, {:id => id}) do
+          url = url_for(url_options)
+          link_to(remote_controller.to_s, url, {:remote => true, :id => id}) <<
+            if ActiveScaffold.js_framework == :prototype
+            javascript_tag("new Ajax.Updater('#{id}', '#{url}', {method: 'get', evalScripts: true});")
+          elsif ActiveScaffold.js_framework == :jquery
+            javascript_tag("$('##{id}').load('#{url}');")
+          end
+        end
+      end
+      
+    else
+      options = args.first
+      if options.is_a?(Hash)
+        @last_view = {:view => options[:partial], :is_template => false} if options[:partial]
+        @last_view = {:view => options[:template], :is_template => !!options[:template]} if @last_view.nil? && options[:template]
+        @last_view[:locals] = options[:locals] if !@last_view.nil? && options[:locals]
+      end
+      render_without_active_scaffold(*args, &block)
+    end
+  end
+  alias_method_chain :render, :active_scaffold
+  
+
+  def partial_pieces(partial_path)
+    if partial_path.include?('/')
+      return File.dirname(partial_path), File.basename(partial_path)
+    else
+      return controller.class.controller_path, partial_path
+    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
+  # TODO: Work with rails core team to find a better way to check for this.
+  def template_exists?(template_name, lookup_overrides = false)
+    begin
+      method = 'find_template'
+      method << '_without_active_scaffold' unless lookup_overrides
+      self.view_paths.send(method, template_name, @template_format)
+      return true
+    rescue ActionView::MissingTemplate => e
+      return false
+    end
+  end
+end

data/lib/extensions/action_view_resolver.rb

@@ -0,0 +1,7 @@
+module ActionView
+  class ActiveScaffoldResolver < FileSystemResolver
+    def build_path(name, prefix, partial, details)
+      super(name, '', partial, details)
+    end
+  end
+end

data/lib/extensions/active_association_reflection.rb

@@ -0,0 +1,13 @@
+# Bugfix: building an sti model from an association fails
+# https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/6306-collection-associations-build-method-not-supported-for-sti
+ActiveRecord::Reflection::AssociationReflection.class_eval do
+  def build_association(*opts)
+    col = klass.inheritance_column.to_sym
+    if !col.nil? && opts.first.is_a?(Hash) && (opts.first.symbolize_keys[col])
+      sti_model = opts.first.delete(col)
+      sti_model.to_s.camelize.constantize.new(*opts)
+    else
+      klass.new(*opts)
+    end
+  end
+end

data/lib/extensions/active_record_offset.rb

@@ -0,0 +1,12 @@
+# Bugfix: Team.offset(1).limit(1) throws an error
+ActiveRecord::Base.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/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/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/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/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