brisk-bills 0.6.0

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/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,40 @@
+##
+## 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})
+    puts resp.body
+  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(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,123 @@
+# 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])
+
+      # collect the possibly-related methods that actually exist
+      methods = [
+        column_security_method(options[:column]),
+        action_security_method(options[:action]),
+        column_and_action_security_method(options[:column], 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,144 @@
+module ActiveScaffold
+  class ControllerNotFound < RuntimeError; end
+  class DependencyFailure < RuntimeError; end
+  class MalformedConstraint < RuntimeError; end
+  class RecordNotAllowed < 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)
+      self.active_scaffold_config.configure &block if block_given?
+      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
+
+      # 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 rescue nil
+
+          # 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
+    end
+
+    def active_scaffold_paths
+      @active_scaffold_paths ||= ActionView::PathSet.new(@active_scaffold_overrides + @active_scaffold_frontends) unless @active_scaffold_overrides.nil? || @active_scaffold_frontends.nil?
+    end
+
+    def active_scaffold_config
+       @active_scaffold_config || self.superclass.instance_variable_get('@active_scaffold_config')
+    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

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

@@ -0,0 +1,102 @@
+module ActiveScaffold::Actions
+  module Core
+    def self.included(base)
+      base.class_eval do
+        after_filter :clear_flashes
+      end
+    end
+
+    protected
+
+    def authorized_for?(*args)
+      active_scaffold_config.model.authorized_for?(*args)
+    end
+
+    def clear_flashes
+      if request.xhr?
+        flash.keys.each do |flash_key|
+          flash[flash_key] = nil
+        end
+      end
+    end
+
+    # Returns true if the client accepts one of the MIME types passed to it
+    # ex: accepts? :html, :xml
+    def accepts?(*types)
+      for priority in request.accepts.compact
+        if priority == Mime::ALL
+          # Because IE always sends */* in the accepts header and we assume
+          # that if you really wanted XML or something else you would say so
+          # explicitly, we will assume */* to only ask for :html
+          return types.include?(:html)
+        elsif types.include?(priority.to_sym)
+          return true
+        end
+      end
+      false
+    end
+
+    def response_status
+      successful? ? 200 : 500
+    end
+
+    # API response object that will be converted to XML/YAML/JSON using to_xxx
+    def response_object
+      @response_object = successful? ? (@record || @records) : @record.errors
+    end
+
+    # Success is the existence of certain variables and the absence of errors (when applicable).
+    # Success can also be defined.
+    def successful?
+      if @successful.nil?
+        @records or (@record and @record.errors.count == 0 and @record.no_errors_in_associated?)
+      else
+        @successful
+      end
+    end
+
+    def successful=(val)
+      @successful = (val) ? true : false
+    end
+
+    # Redirect to the main page (override if the ActiveScaffold is used as a component on another controllers page) for Javascript degradation
+    def return_to_main
+      unless params[:parent_controller].nil?
+        params[:controller] = params[:parent_controller]
+        params[:eid] = nil
+        params[:parent_model] = nil
+        params[:parent_column] = nil
+        params[:parent_id] = nil
+      end
+      redirect_to params_for(:action => "index")
+    end
+
+    # Override this method on your controller to define conditions to be used when querying a recordset (e.g. for List). The return of this method should be any format compatible with the :conditions clause of ActiveRecord::Base's find.
+    def conditions_for_collection
+    end
+  
+    # Override this method on your controller to define joins to be used when querying a recordset (e.g. for List).  The return of this method should be any format compatible with the :joins clause of ActiveRecord::Base's find.
+    def joins_for_collection
+    end
+  
+    # Override this method on your controller to provide custom finder options to the find() call. The return of this method should be a hash.
+    def custom_finder_options
+      {}
+    end
+  
+
+    # Builds search conditions by search params for column names. This allows urls like "contacts/list?company_id=5".
+    def conditions_from_params
+      conditions = nil
+      params.reject {|key, value| [:controller, :action, :id].include?(key.to_sym)}.each do |key, value|
+        next unless active_scaffold_config.model.column_names.include?(key)
+        if value.is_a?(Array)
+          conditions = merge_conditions(conditions, ["#{active_scaffold_config.model.table_name}.#{key.to_s} in (?)", value])
+        else
+          conditions = merge_conditions(conditions, ["#{active_scaffold_config.model.table_name}.#{key.to_s} = ?", value])
+        end
+      end
+      conditions
+    end
+  end
+end