lockbox_middleware 1.2.0 → 1.2.1

data/vendor/plugins/active_scaffold/frontends/default/views/on_create.js.rjs

@@ -0,0 +1,25 @@
+cancel_selector = "##{element_form_id(:action => :create)} a.cancel".to_json
+
+if controller.send :successful?
+  if @insert_row
+    page.insert_html :top, active_scaffold_tbody_id, :partial => 'list_record', :locals => {:record => @record}
+    page << "ActiveScaffold.stripe($('#{active_scaffold_tbody_id}'))"
+    page << "ActiveScaffold.hide_empty_message('#{active_scaffold_tbody_id}','#{empty_message_id}');"
+    page << "ActiveScaffold.increment_record_count('#{active_scaffold_id}');"
+  end
+
+  if (active_scaffold_config.create.persistent)
+    page << "$$(#{cancel_selector}).first().link.reload();"
+  else
+    page << "$$(#{cancel_selector}).first().link.close#{'_with_refresh' unless @insert_row}();"
+  end
+  if (active_scaffold_config.create.edit_after_create)
+    page << "var link = $('#{action_link_id 'edit', @record.id}');"
+    page << "if (link) (function() { link.action_link.open() }).defer();"
+  end
+else
+  page << "l = $$(#{cancel_selector}).first().link;"
+  page.replace element_form_id(:action => :create), :partial => 'create_form'
+  page << "l.register_cancel_hooks();"
+end
+page.replace_html active_scaffold_messages_id, :partial => 'messages'

data/vendor/plugins/active_scaffold/frontends/default/views/on_update.js.rjs

@@ -0,0 +1,11 @@
+cancel_selector = "##{element_form_id(:action => :update)} a.cancel".to_json
+
+if controller.send :successful?
+  page << "$$(#{cancel_selector}).first().link.close_with_refresh();"
+  page.replace active_scaffold_calculations_id, :partial => 'list_calculations' if active_scaffold_config.list.columns.any? {|c| c.calculation?}
+else
+  page << "l = $$(#{cancel_selector}).first().link;"
+  page.replace element_form_id(:action => :update), :partial => 'update_form'
+  page << "l.register_cancel_hooks();"
+end
+page.replace_html active_scaffold_messages_id, :partial => 'messages'

data/vendor/plugins/active_scaffold/frontends/default/views/render_field.js.rjs

@@ -0,0 +1,9 @@
+@update_columns.each do |update_column|
+  column = update_column
+  while column
+    field_id = active_scaffold_input_options(column, params[:scope])[:id]
+    page[field_id].up('dl').replace :partial => form_partial_for_column(column), :locals => { :column => column, :scope => params[:scope] }
+    column = Hash === column.options ? column.options[:update_column] : nil
+    column = active_scaffold_config.columns[column] if column
+  end
+end

data/vendor/plugins/active_scaffold/frontends/default/views/search.html.erb

@@ -0,0 +1,5 @@
+<div class="active-scaffold">
+  <div class="search-view <%= "#{params[:controller]}-view" %> view">
+    <%= render :partial => 'search' -%>
+  </div>
+</div>

data/vendor/plugins/active_scaffold/frontends/default/views/show.html.erb

@@ -0,0 +1,5 @@
+<div class="active-scaffold">
+  <div class="show-view <%= "#{params[:controller]}-view" %> view">
+    <%= render :partial => 'show' -%>
+  </div>
+</div>

data/vendor/plugins/active_scaffold/frontends/default/views/update.html.erb

@@ -0,0 +1,8 @@
+<div class="active-scaffold">
+  <div class="update-view <%= "#{params[:controller]}-view" %> view">
+    <% if active_scaffold_config.update.nested_links and active_scaffold_config.action_links.any? {|link| link.type == :record } -%>
+    <%= render :partial => 'update_actions', :locals => {:record => @record, :url_options => params_for(:action => :list, :id => @record.id)} %>
+    <% end -%>
+    <%= render :partial => 'update_form' -%>
+  </div>
+</div>

data/vendor/plugins/active_scaffold/frontends/default/views/update_column.js.rjs

@@ -0,0 +1,12 @@
+column_span_id = element_cell_id(:id => @record.id.to_s, :action => 'update_column', :name => params[:column])
+unless controller.send :successful?
+  page.alert(@record.errors.full_messages(active_scaffold_config).join("\n"))
+  @record.reload
+end
+column = active_scaffold_config.columns[params[:column]]
+if column.inplace_edit
+  page.replace_html(column_span_id,format_inplace_edit_column(@record, column))
+else
+  formatted_value = get_column_value(@record, column)
+  page.replace_html(column_span_id,  formatted_value)
+end

data/vendor/plugins/active_scaffold/init.rb

@@ -0,0 +1,18 @@
+##
+## Initialize the environment
+##
+unless Rails::VERSION::MAJOR == 2 && Rails::VERSION::MINOR >= 3
+  raise "This version of ActiveScaffold requires Rails 2.3 or higher.  Please use an earlier version."
+end
+
+require File.dirname(__FILE__) + '/environment'
+
+##
+## Run the install assets script, too, just to make sure
+## But at least rescue the action in production
+##
+begin
+  require File.dirname(__FILE__) + '/install_assets'
+rescue
+  raise $! unless Rails.env == 'production'
+end

data/vendor/plugins/active_scaffold/install.rb

@@ -0,0 +1,39 @@
+##
+## Install ActiveScaffold assets into /public 
+##
+
+require File.dirname(__FILE__) + '/install_assets'
+
+##
+## Install Counter
+##
+#
+# What's going on here? 
+#   We're incrementing a web counter so we can track SVN installs of ActiveScaffold 
+# 
+# How? 
+#   We're making a GET request to errcount.com to update a simple counter. No data is transmitted.
+# 
+# Why?
+#   So we can know how many people are using ActiveScaffold and modulate our level of effort accordingly.
+#   Despite numerous pleas our Googly overlords still only provide us with download stats for the zip distro.
+# 
+# *Thanks for your understanding* 
+#
+
+class ErrCounter # using errcount.com
+  require "net/http"
+  
+  @@ACCOUNT_ID = 341
+  @@SITE_DOMAIN = 'installs.activescaffold.com'
+  
+  def self.increment
+    @http = Net::HTTP.new("errcount.com")
+    resp, data = @http.get2("/ctr/#{@@ACCOUNT_ID}.js", {'Referer' => @@SITE_DOMAIN})
+  end  
+end
+
+begin
+  ErrCounter.increment
+rescue
+end

data/vendor/plugins/active_scaffold/install_assets.rb

@@ -0,0 +1,36 @@
+# Workaround a problem with script/plugin and http-based repos.
+# See http://dev.rubyonrails.org/ticket/8189
+Dir.chdir(Dir.getwd.sub(/vendor.*/, '')) do
+
+##
+## Copy over asset files (javascript/css/images) from the plugin directory to public/
+##
+
+def copy_files(source_path, destination_path, directory)
+  source, destination = File.join(directory, source_path), File.join(Rails.root, destination_path)
+  FileUtils.mkdir_p(destination) unless File.exist?(destination)
+  FileUtils.cp_r(Dir.glob(source+'/*.*'), destination)
+end
+
+directory = File.dirname(__FILE__)
+
+copy_files("/public", "/public", directory)
+
+available_frontends = Dir[File.join(directory, 'frontends', '*')].collect { |d| File.basename d }
+[ :stylesheets, :javascripts, :images].each do |asset_type|
+  path = "/public/#{asset_type}/active_scaffold"
+  copy_files(path, path, directory)
+  
+  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|
+    source = "/frontends/#{frontend}/#{asset_type}/"
+    destination = "/public/#{asset_type}/active_scaffold/#{frontend}"
+    copy_files(source, destination, directory)
+  end
+end
+
+end

data/vendor/plugins/active_scaffold/lib/active_record_permissions.rb

@@ -0,0 +1,128 @@
+# This module attempts to create permissions conventions for your ActiveRecord models. It supports english-based
+# methods that let you restrict access per-model, per-record, per-column, per-action, and per-user. All at once.
+#
+# You may define instance methods in the following formats:
+#  def #{column}_authorized_for_#{action}?
+#  def #{column}_authorized?
+#  def authorized_for_#{action}?
+#
+# Your methods should allow for the following special cases:
+#   * cron scripts
+#   * guest users (or nil current_user objects)
+module ActiveRecordPermissions
+  # ActiveRecordPermissions needs to know what method on your ApplicationController will return the current user,
+  # if available. This defaults to the :current_user method. You may configure this in your environment.rb if you
+  # have a different setup.
+  def self.current_user_method=(v); @@current_user_method = v; end
+  def self.current_user_method; @@current_user_method; end
+  @@current_user_method = :current_user
+
+  # Whether the default permission is permissive or not
+  # If set to true, then everything's allowed until configured otherwise
+  def self.default_permission=(v); @@default_permission = v; end
+  def self.default_permission; @@default_permission; end
+  @@default_permission = true
+
+  # This is a module aimed at making the current_user available to ActiveRecord models for permissions.
+  module ModelUserAccess
+    module Controller
+      def self.included(base)
+        base.prepend_before_filter :assign_current_user_to_models
+      end
+
+      # We need to give the ActiveRecord classes a handle to the current user. We don't want to just pass the object,
+      # because the object may change (someone may log in or out). So we give ActiveRecord a proc that ties to the
+      # current_user_method on this ApplicationController.
+      def assign_current_user_to_models
+        ActiveRecord::Base.current_user_proc = proc {send(ActiveRecordPermissions.current_user_method)}
+      end
+    end
+
+    module Model
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        # The proc to call that retrieves the current_user from the ApplicationController.
+        attr_accessor :current_user_proc
+
+        # Class-level access to the current user
+        def current_user
+          ActiveRecord::Base.current_user_proc.call if ActiveRecord::Base.current_user_proc
+        end
+      end
+
+      # Instance-level access to the current user
+      def current_user
+        self.class.current_user
+      end
+    end
+  end
+
+  module Permissions
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # A generic authorization query. This is what will be called programatically, since
+    # the actual permission methods can't be guaranteed to exist. And because we want to
+    # intelligently combine multiple applicable methods.
+    #
+    # options[:action] should be a CRUD verb (:create, :read, :update, :destroy)
+    # options[:column] should be the name of a model attribute
+    def authorized_for?(options = {})
+      raise ArgumentError, "unknown action #{options[:action]}" if options[:action] and ![:create, :read, :update, :destroy].include?(options[:action])
+
+      # column_authorized_for_action? has priority over other methods,
+      # you can disable an action and enable that action for a column
+      # (for example, disable update and enable inplace_edit in a column)
+      method = column_and_action_security_method(options[:column], options[:action])
+      return send(method) if method and respond_to?(method)
+
+      # collect the possibly-related methods that actually exist
+      methods = [
+        column_security_method(options[:column]),
+        action_security_method(options[:action]),
+      ].compact.select {|m| respond_to?(m)}
+
+      # if any method returns false, then return false
+      return false if methods.any? {|m| !send(m)}
+
+      # if any method actually exists then it must've returned true, so return true
+      return true unless methods.empty?
+
+      # if no method exists, return the default permission
+      return ActiveRecordPermissions.default_permission
+    end
+
+    # Because any class-level queries get delegated to the instance level via a new record,
+    # it's useful to know when the authorization query is meant for a specific record or not.
+    # But using new_record? is confusing, even though accurate. So this is basically just a wrapper.
+    def existing_record_check?
+      !new_record?
+    end
+
+    module ClassMethods
+      # Class level just delegates to instance level
+      def authorized_for?(*args)
+        @authorized_for_delegatee ||= self.new
+        @authorized_for_delegatee.authorized_for?(*args)
+      end
+    end
+
+    private
+
+    def column_security_method(column)
+      "#{column}_authorized?" if column
+    end
+
+    def action_security_method(action)
+      "authorized_for_#{action}?" if action
+    end
+
+    def column_and_action_security_method(column, action)
+      "#{column}_authorized_for_#{action}?" if column and action
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+module ActiveScaffold
+  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
+
+  module ClassMethods
+    def active_scaffold(model_id = nil, &block)
+      # initialize bridges here
+      ActiveScaffold::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
+      self.active_scaffold_superclasses_blocks.each {|superblock| self.active_scaffold_config.configure &superblock}
+      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.generated_methods?
+
+      @active_scaffold_overrides = []
+      ActionController::Base.view_paths.each do |dir|
+        active_scaffold_overrides_dir = File.join(dir,"active_scaffold_overrides")
+        @active_scaffold_overrides << active_scaffold_overrides_dir if File.exists?(active_scaffold_overrides_dir)
+      end
+      @active_scaffold_frontends = []
+      if active_scaffold_config.frontend.to_sym != :default
+        active_scaffold_custom_frontend_path = File.join(Rails.root, 'vendor', 'plugins', 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(Rails.root, 'vendor', 'plugins', ActiveScaffold::Config::Core.plugin_directory, 'frontends', 'default' , 'views')
+      @active_scaffold_frontends << active_scaffold_default_frontend_path
+      @active_scaffold_custom_paths = []
+
+      # 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
+            active_scaffold_config.action_links << link
+          end
+        end
+      end
+      self.active_scaffold_config._add_sti_create_links if self.active_scaffold_config.add_sti_create_links?
+    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?
+        if column.plural_association?
+          # note: we can't create nested scaffolds on :through associations because there's no reverse association.
+          column.set_link('nested', :parameters => {:associations => column.name.to_sym}, :html_options => {:class => column.name}) #unless column.through_association?
+        elsif column.polymorphic_association?
+          # note: we can't create inline forms on singular polymorphic associations
+          column.clear_link
+        else
+          model = column.association.klass
+          begin
+            controller = active_scaffold_controller_for(model)
+          rescue ActiveScaffold::ControllerNotFound
+            next
+          end
+
+          actions = controller.active_scaffold_config.actions
+          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
+          column.set_link(:none, :controller => controller.controller_path, :crud_type => nil, :html_options => {:class => column.name})
+        end
+      end
+    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.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)
+      namespace = self.to_s.split('::')[0...-1].join('::') + '::'
+      error_message = []
+      ["#{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
+      raise ActiveScaffold::ControllerNotFound, "Could not find " + error_message.join(" or "), caller
+    end
+
+    def uses_active_scaffold?
+      !active_scaffold_config.nil?
+    end
+  end
+end