active_scaffold 3.2.18 → 3.2.19

data/lib/active_scaffold/tableless.rb

@@ -0,0 +1,83 @@
+class ActiveScaffold::Tableless < ActiveRecord::Base
+  class Relation < ActiveRecord::Relation
+    attr_reader :conditions
+    def initialize(klass, table)
+      super
+      @conditions ||= []
+    end
+
+    def initialize_copy(other)
+      @conditions = @conditions.dup
+      super
+    end
+
+    def where(opts, *rest)
+      unless opts.blank?
+        opts = opts.with_indifferent_access if opts.is_a? Hash
+        @conditions << (rest.empty? ? opts : [opts, *rest])
+      end
+      self
+    end
+
+    def merge(r)
+      super.tap do |merged|
+        merged.conditions.concat r.conditions unless r.nil? || r.is_a?(Array)
+      end
+    end
+
+    def except(*skips)
+      super.tap do |new_relation|
+        new_relation.conditions = conditions unless skips.include? :where
+      end
+    end
+
+    def to_a
+      @klass.find_all(self)
+    end
+
+    def find_one(id)
+      @klass.find_one(id, self)
+    end
+
+    def execute_simple_calculation(operation, column_name, distinct)
+      @klass.execute_simple_calculation(self, operation, column_name, distinct)
+    end
+  end
+
+  def self.columns; @columns ||= []; end
+  def self.table_name; @table_name ||= ActiveModel::Naming.plural(self); end
+  def self.table_exists?; true; end
+  self.abstract_class = true
+  class << self
+    private
+    def relation
+      @relation ||= ActiveScaffold::Tableless::Relation.new(self, arel_table)
+      super
+    end
+  end
+
+  def self.column(name, sql_type = nil, options = {})
+    column = ActiveRecord::ConnectionAdapters::Column.new(name.to_s, options[:default], sql_type.to_s, options.has_key?(:null) ? options[:null] : true)
+    column.tap { columns << column }
+  end
+
+  def self.find_all(relation)
+    raise 'self.find_all must be implemented in a Tableless model'
+  end
+
+  def self.find_one(id, relation)
+    raise 'self.find_one must be implemented in a Tableless model'
+  end
+
+  def self.execute_simple_calculation(relation, operation, column_name, distinct)
+    if operation == 'count' && column_name == :all && !distinct
+      find_all(relation).size
+    else
+      raise "self.execute_simple_calculation must be implemented in a Tableless model to support #{operation} #{column_name} #{' distinct' if distinct} columns"
+    end
+  end
+
+  def destroy
+    raise 'destroy must be implemented in a Tableless model'
+  end
+end

data/lib/active_scaffold/version.rb

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

data/lib/active_scaffold.rb

@@ -0,0 +1,373 @@
+unless Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR >= 1
+  raise "This version of ActiveScaffold requires Rails 3.1 or higher.  Please use an earlier version."
+end
+
+begin
+  require 'render_component'
+rescue LoadError
+end
+
+require 'active_scaffold/active_record_permissions'
+require 'active_scaffold/paginator'
+require 'active_scaffold/responds_to_parent'
+
+require 'active_scaffold/version'
+require 'active_scaffold/engine' unless defined? ACTIVE_SCAFFOLD_PLUGIN
+require 'json'  # for js_config
+
+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'
+  autoload :Bridges, 'active_scaffold/bridges'
+
+  mattr_accessor :stylesheets
+  self.stylesheets = []
+  mattr_accessor :javascripts
+  self.javascripts = []
+
+  def self.autoload_subdir(dir, mod=self, root = File.dirname(__FILE__))
+    Dir["#{root}/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.autoload_subdir('actions', self)
+  end
+
+  module Config
+    ActiveScaffold.autoload_subdir('config', self)
+  end
+
+  module DataStructures
+    ActiveScaffold.autoload_subdir('data_structures', self)
+  end
+
+  module Helpers
+    ActiveScaffold.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
+      before_filter :check_input_device
+    end
+
+    base.helper_method :touch_device?
+    base.helper_method :hover_via_click?
+    base.helper_method :active_scaffold_constraints
+  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 = nil)
+    id ||= params[:eid] || "#{params[:controller]}#{"_#{nested.parent_id}" if nested?}"
+    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 check_input_device
+    if request.env["HTTP_USER_AGENT"] && request.env["HTTP_USER_AGENT"][/(iPhone|iPod|iPad)/i]
+      session[:input_device_type] = 'TOUCH'
+      session[:hover_supported] = false
+    else
+      session[:input_device_type] = 'MOUSE'
+      session[:hover_supported] = true
+    end if session[:input_device_type].nil?
+   end
+
+  def touch_device?
+    session[:input_device_type] == 'TOUCH'
+  end
+
+  def hover_via_click?
+    session[:hover_supported] == false
+  end
+  
+  def self.js_framework=(framework)
+    @@js_framework = framework
+  end
+  
+  def self.js_framework
+    @@js_framework ||= if defined? Jquery
+      :jquery
+    elsif defined? PrototypeRails
+      :prototype
+    end
+  end
+
+  def self.js_config=(config)
+    @@js_config = config
+  end
+
+  def self.js_config
+    @@js_config ||= {:scroll_on_close => :checkInViewport}
+  end
+
+  # exclude bridges you do not need
+  # name of bridge subdir should be used to exclude it
+  # eg
+  #   ActiveScaffold.exclude_bridges = [:cancan, :ancestry]
+  #   if you are using Activescaffold as a gem add to initializer
+  #   if you are using Activescaffold as a plugin add to active_scaffold_env.rb
+  def self.exclude_bridges=(bridges)
+    @@exclude_bridges = bridges
+  end
+
+  def self.exclude_bridges
+    @@exclude_bridges ||= []
+  end
+
+  def self.root
+    File.dirname(__FILE__) + "/.."
+  end
+
+  module ClassMethods
+    def active_scaffold(model_id = nil, &block)
+      # initialize bridges here
+      ActiveScaffold::Bridges.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_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
+      self.append_view_path active_scaffold_paths
+      self._add_sti_create_links if self.active_scaffold_config.add_sti_create_links?
+    end
+
+    def parent_prefixes
+      @parent_prefixes ||= super << 'active_scaffold_overrides' << ''
+    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 active_scaffold_controller_for_column(column, options = {})
+      begin
+        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
+        nil        
+      end
+    end
+    
+    def link_for_association(column, options = {})
+      controller = active_scaffold_controller_for_column(column, options)
+      
+      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! :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.merge(:refresh_on_close => true)) #unless column.through_association?
+        else
+          actions = controller.active_scaffold_config.actions unless controller == :polymorph
+          actions ||= [:create, :update, :show] 
+          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(nil, options.merge(: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! :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 active_scaffold_paths
+      return @active_scaffold_paths unless @active_scaffold_paths.nil?
+
+      @active_scaffold_paths = []
+      @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.to_s == klass.to_s
+          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 'active_scaffold_env'

data/lib/active_scaffold_env.rb

@@ -0,0 +1,13 @@
+# TODO: clean up extensions. some could be organized for autoloading, and others could be removed entirely.
+Dir["#{File.dirname __FILE__}/active_scaffold/extensions/*.rb"].each { |file| require file }
+module ActiveScaffold
+  autoload :Tableless, 'active_scaffold/tableless'
+end
+
+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}

data/lib/generators/active_scaffold/USAGE

@@ -0,0 +1,29 @@
+Description:
+    Scaffolds an entire resource, from model and migration to controller, 
+    along with a full test suite and configured to use active_scaffold. 
+    The resource is ready to use as a starting point for your RESTful,
+    resource-oriented application.
+
+    Pass the name of the model (in singular form), either CamelCased or
+    under_scored, as the first argument, and an optional list of attribute
+    pairs.
+
+    Attribute pairs are field:type arguments specifying the
+    model's attributes. Timestamps are added by default, so you don't have to
+    specify them by hand as 'created_at:datetime updated_at:datetime'.
+
+    You don't have to think up every attribute up front, but it helps to
+    sketch out a few so you can start working with the resource immediately.
+
+    For example, 'active_scaffold post title:string body:text published:boolean'
+    gives you a model with those three attributes, a controller configured to use active_scaffold, 
+    as well as a resources :posts with additional active_scaffold routes
+    declaration in config/routes.rb.
+
+    If you want to remove all the generated files, run
+    'rails destroy active_scaffold ModelName'.
+
+Examples:
+    `rails generate active_scaffold post`
+    `rails generate active_scaffold post title:string body:text published:boolean`
+    `rails generate active_scaffold purchase order_id:integer amount:decimal` 

data/lib/generators/active_scaffold/active_scaffold_generator.rb

@@ -0,0 +1,21 @@
+require 'rails/generators/rails/resource/resource_generator'
+#require 'generators/active_scaffold_controller/active_scaffold_controller_generator'
+
+module Rails
+  module Generators
+    class ActiveScaffoldGenerator < ResourceGenerator #metagenerator
+      remove_hook_for :resource_controller
+      remove_hook_for :resource_route
+      remove_class_option :actions
+      
+      def add_resource_route
+        route_config =  class_path.collect{|namespace| "namespace :#{namespace} do " }.join(" ") 
+        route_config << "resources :#{file_name.pluralize} do as_routes end"
+        route_config << " end" * class_path.size 
+        route route_config
+      end 
+     
+      invoke "active_scaffold_controller"
+    end
+  end
+end

data/lib/generators/active_scaffold_controller/USAGE

@@ -0,0 +1,19 @@
+Description:
+    Stubs out a active_scaffolded controller. Pass the model name,
+    either CamelCased or under_scored.
+    The controller name is retrieved as a pluralized version of the model
+    name.
+
+    To create a controller within a module, specify the model name as a
+    path like 'parent_module/controller_name'.
+
+    This generates a controller class in app/controllers and invokes helper,
+    template engine and test framework generators.
+
+Example:
+    `rails generate active_scaffold_controller CreditCard`
+
+    Credit card controller with URLs like /credit_card/debit.
+        Controller:      app/controllers/credit_cards_controller.rb
+        Functional Test: test/functional/credit_cards_controller_test.rb
+        Helper:          app/helpers/credit_cards_helper.rb 

data/lib/generators/active_scaffold_controller/active_scaffold_controller_generator.rb

@@ -0,0 +1,29 @@
+#require 'rails/generators/rails/scaffold_controller/scaffold_controller_generator'
+
+module Rails
+  module Generators
+    class ActiveScaffoldControllerGenerator < NamedBase #metagenerator
+      include ResourceHelpers
+
+      def self.source_root
+         @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+      end
+
+      check_class_collision :suffix => "Controller"
+
+      class_option :orm, :banner => "NAME", :type => :string, :required => true,
+                         :desc => "ORM to generate the controller for"
+
+      def create_controller_files
+        template 'controller.rb', File.join('app/controllers', class_path, "#{controller_file_name}_controller.rb")
+        template 'helper.rb', File.join('app/helpers', class_path, "#{controller_file_name}_helper.rb")
+      end
+
+      hook_for :test_framework, :as => :scaffold
+
+      def create_view_root_folder
+        empty_directory File.join("app/views", controller_file_path)
+      end 
+    end
+  end
+end

data/lib/generators/active_scaffold_controller/templates/controller.rb

@@ -0,0 +1,4 @@
+class <%= controller_class_name %>Controller < ApplicationController
+  active_scaffold :<%= class_name.demodulize.underscore %> do |conf|
+  end
+end 

data/lib/generators/active_scaffold_controller/templates/helper.rb

@@ -0,0 +1,2 @@
+module <%= controller_class_name %>Helper
+end

data/public/blank.html

@@ -0,0 +1,33 @@
+<!--    
+   Copyright (c) 2005, Brad Neuberg, bkn3@columbia.edu
+   http://codinginparadise.org
+   
+   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.
+-->
+
+<html>
+   <script language="JavaScript">
+            function pageLoaded() {
+               window.parent.dhtmlHistory.iframeLoaded(window.location);
+            }
+   </script>
+   <body onload="pageLoaded()">
+      <h1>blank.html - Needed for Internet Explorer's hidden IFrame</h1>
+   </body>
+</html>