activeadministration 0.0.1

data/lib/active_admin/batch_actions/views/batch_action_form.rb

@@ -0,0 +1,38 @@
+require 'active_admin/component'
+
+module ActiveAdmin
+  module BatchActions
+
+    # Build a BatchActionForm
+    class BatchActionForm < ActiveAdmin::Component
+      builder_method :batch_action_form
+
+      attr_reader :prefix_html
+
+      def build(options = {}, &block)
+        options[:id] ||= "collection_selection"
+
+        # Open a form with two hidden input fields:
+        # batch_action        => name of the specific action called
+        # batch_action_inputs => a JSON string of any requested confirmation values
+        text_node form_tag active_admin_config.batch_action_path(params), id: options[:id]
+        input name: :batch_action,        id: :batch_action,        type: :hidden
+        input name: :batch_action_inputs, id: :batch_action_inputs, type: :hidden
+
+        super(options)
+      end
+
+      # Override the default to_s to include a closing form tag
+      def to_s
+        content + closing_form_tag
+      end
+
+      private
+
+      def closing_form_tag
+        '</form>'.html_safe
+      end
+
+    end
+  end
+end

data/lib/active_admin/batch_actions/views/batch_action_popover.rb

@@ -0,0 +1,28 @@
+require 'active_admin/views/components/action_list_popover'
+
+module ActiveAdmin
+  module BatchActions
+    # Build an BatchActionPopover
+    class BatchActionPopover < ActiveAdmin::Views::ActionListPopover
+      builder_method :batch_action_popover
+
+      def build(options = {}, &block)
+        options[:id] ||= "batch_actions_popover"
+        super(options)
+      end
+
+      def action(batch_action, options = {})
+        options[:class] ||= []
+        options[:class] += %w(batch_action)
+        options.merge! "data-action" => batch_action.sym,
+                       "data-confirm" => batch_action.confirm
+
+        title = I18n.t("active_admin.batch_actions.labels.#{batch_action.sym}", default: batch_action.title)
+        label = I18n.t("active_admin.batch_actions.action_label", title: title)
+
+        super(label, "#", options)
+      end
+
+    end
+  end
+end

data/lib/active_admin/batch_actions/views/batch_action_selector.rb

@@ -0,0 +1,57 @@
+require 'active_admin/component'
+
+module ActiveAdmin
+  module BatchActions
+
+    class BatchActionSelector < ActiveAdmin::Component
+      builder_method :batch_action_selector
+
+      # Build a new batch actions selector
+      #
+      # @param [Array] batch_actions An array of batch actions
+      def build(batch_actions)
+        @batch_actions = Array(batch_actions)
+        @drop_down = build_drop_down
+      end
+
+      # We don't want to wrap the action list (or any other children) in
+      # an unecessary div, so instead we just return the children
+      def to_s
+        children.to_s
+      end
+
+      private
+
+      def build_drop_down
+        dropdown_menu I18n.t("active_admin.batch_actions.button_label"),
+                      class: "batch_actions_selector dropdown_menu",
+                      button: { class: "disabled" } do
+          batch_actions_to_display.each do |batch_action|
+            confirmation_text = render_or_call_method_or_proc_on(self, batch_action.confirm)
+
+            options = {
+              :class         => "batch_action",
+              "data-action"  => batch_action.sym,
+              "data-confirm" => confirmation_text,
+              "data-inputs"  => batch_action.inputs.to_json
+            }
+
+            default_title = render_or_call_method_or_proc_on(self, batch_action.title)
+            title = I18n.t("active_admin.batch_actions.labels.#{batch_action.sym}", default: default_title)
+            label = I18n.t("active_admin.batch_actions.action_label", title: title)
+
+            item label, "#", options
+          end
+        end
+      end
+
+      # Return the set of batch actions that should be displayed
+      def batch_actions_to_display
+        @batch_actions.select do |batch_action|
+          call_method_or_proc_on(self, batch_action.display_if_block)
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/batch_actions/views/selection_cells.rb

@@ -0,0 +1,37 @@
+require 'active_admin/component'
+
+module ActiveAdmin
+  module BatchActions
+
+    # Creates the toggle checkbox used to toggle the collection selection on/off
+    class ResourceSelectionToggleCell < ActiveAdmin::Component
+      builder_method :resource_selection_toggle_cell
+
+      def build
+        input type: "checkbox", id: "collection_selection_toggle_all", name: "collection_selection_toggle_all", class: "toggle_all"
+      end
+    end
+
+    # Creates the checkbox used to select a resource in the collection selection
+    class ResourceSelectionCell < ActiveAdmin::Component
+      builder_method :resource_selection_cell
+
+      def build(resource)
+        input type: "checkbox", id: "batch_action_item_#{resource.id}", value: resource.id, class: "collection_selection", name: "collection_selection[]"
+      end
+    end
+
+    # Creates a wrapper panel for all index pages, except for the table, as the table has the checkbox in the thead
+    class ResourceSelectionTogglePanel < ActiveAdmin::Component
+      builder_method :resource_selection_toggle_panel
+
+      def build
+        super(id: "collection_selection_toggle_panel")
+        resource_selection_toggle_cell
+        div(id: "collection_selection_toggle_explaination" ) { I18n.t('active_admin.batch_actions.selection_toggle_explanation', default: "(Toggle Selection)") }
+      end
+
+    end
+
+  end
+end

data/lib/active_admin/callbacks.rb

@@ -0,0 +1,84 @@
+module ActiveAdmin
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    protected
+
+    # Simple callback system. Implements before and after callbacks for
+    # use within the controllers.
+    #
+    # We didn't use the ActiveSupport callbacks becuase they do not support
+    # passing in any arbitrary object into the callback method (which we
+    # need to do)
+
+    def run_callback(method, *args)
+      case method
+      when Symbol
+        send(method, *args)
+      when Proc
+        instance_exec(*args, &method)
+      else
+        raise "Please register with callbacks using a symbol or a block/proc."
+      end
+    end
+
+    module ClassMethods
+
+      # Define a new callback.
+      #
+      # Example:
+      #
+      #   class MyClassWithCallbacks
+      #     include ActiveAdmin::Callbacks
+      #
+      #     define_active_admin_callbacks :save
+      #
+      #     before_save do |arg1, arg2|
+      #       # runs before save
+      #     end
+      #
+      #     after_save :call_after_save
+      #
+      #     def save
+      #       # Will run before, yield, then after
+      #       run_save_callbacks :arg1, :arg2 do
+      #         save!
+      #       end
+      #     end
+      #
+      #     protected
+      #
+      #     def call_after_save(arg1, arg2)
+      #       # runs after save
+      #     end
+      #   end
+      #
+      def define_active_admin_callbacks(*names)
+        names.each do |name|
+          [:before, :after].each do |type|
+            callback_name = "#{type}_#{name}_callbacks"
+            callback_ivar = "@#{callback_name}"
+
+            # def self.before_create_callbacks
+            singleton_class.send :define_method, callback_name do
+              instance_variable_get(callback_ivar) || instance_variable_set(callback_ivar, [])
+            end
+
+            # def self.before_create
+            singleton_class.send :define_method, "#{type}_#{name}" do |method = nil, &block|
+              send(callback_name).push method || block
+            end
+          end
+
+          # def run_create_callbacks
+          define_method "run_#{name}_callbacks" do |*args, &block|
+            self.class.send("before_#{name}_callbacks").each{ |cbk| run_callback(cbk, *args) }
+            value = block.try :call
+            self.class.send("after_#{name}_callbacks").each { |cbk| run_callback(cbk, *args) }
+            return value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/cancan_adapter.rb

@@ -0,0 +1,40 @@
+require 'cancan'
+
+# Add a setting to the application to configure the ability
+ActiveAdmin::Application.inheritable_setting :cancan_ability_class, "Ability"
+
+module ActiveAdmin
+
+  class CanCanAdapter < AuthorizationAdapter
+
+    def authorized?(action, subject = nil)
+      cancan_ability.can?(action, subject)
+    end
+
+    def cancan_ability
+      @cancan_ability ||= initialize_cancan_ability
+    end
+
+    def scope_collection(collection, action = ActiveAdmin::Auth::READ)
+      collection.accessible_by(cancan_ability, action)
+    end
+
+    private
+
+    # The setting allows the class to be stored as a string
+    # to enable reloading in development.
+    def initialize_cancan_ability
+      ability_class_name = resource.namespace.cancan_ability_class
+
+      if ability_class_name.is_a?(String)
+        ability_class = ActiveSupport::Dependencies.constantize(ability_class_name)
+      else
+        ability_class = ability_class_name
+      end
+
+      ability_class.new(user)
+    end
+
+  end
+
+end

data/lib/active_admin/component.rb

@@ -0,0 +1,5 @@
+module ActiveAdmin
+  class Component < Arbre::Component
+
+  end
+end

data/lib/active_admin/controller_action.rb

@@ -0,0 +1,12 @@
+module ActiveAdmin
+  class ControllerAction
+    attr_reader :name
+    def initialize(name, options = {})
+      @name, @options = name, options
+    end
+
+    def http_verb
+      @options[:method] ||= :get
+    end
+  end
+end

data/lib/active_admin/csv_builder.rb

@@ -0,0 +1,70 @@
+module ActiveAdmin
+  # CSVBuilder stores CSV configuration
+  #
+  # Usage example:
+  #
+  #   csv_builder = CSVBuilder.new
+  #   csv_builder.column :id
+  #   csv_builder.column("Name") { |resource| resource.full_name }
+  #
+  #   csv_builder = CSVBuilder.new col_sep: ";"
+  #   csv_builder.column :id
+  #
+  #
+  class CSVBuilder
+
+    # Return a default CSVBuilder for a resource
+    # The CSVBuilder's columns would be Id followed by this
+    # resource's content columns
+    def self.default_for_resource(resource)
+      new(resource: resource) do
+        column(:id)
+        resource.content_columns.each do |content_column|
+          column(content_column.name.to_sym)
+        end
+      end
+    end
+
+    attr_reader :columns, :options, :view_context
+
+    def initialize(options={}, &block)
+      @resource = options.delete(:resource)
+      @columns, @options, @block = [], options, block
+    end
+
+    # Add a column
+    def column(name, &block)
+      @columns << Column.new(name, @resource, block)
+    end
+
+    # Runs the `csv` dsl block and render our columns
+    # Called from `index.csv.erb`, which passes in the current view context.
+    # This provides methods that could be called in the views to be called within
+    # the CSV block. Any method not defined on the CSV builder will instead be
+    # sent to the view context in order to emulate the capabilities of the `index`
+    # DSL.
+    def render_columns(view_context = nil)
+      @view_context = view_context
+      @columns = [] # we want to re-render these every instance
+      instance_eval &@block if @block.present?
+      columns
+    end
+
+    def method_missing(method, *args, &block)
+      if @view_context.respond_to?(method)
+        @view_context.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    class Column
+      attr_reader :name, :data
+
+      def initialize(name, resource = nil, block = nil)
+        @name = name.is_a?(Symbol) && resource.present? ? resource.human_attribute_name(name) : name.to_s.humanize
+        @data = block || name.to_sym
+      end
+    end
+  end
+end

data/lib/active_admin/dependencies.rb

@@ -0,0 +1,38 @@
+module ActiveAdmin
+  module Dependencies
+
+    # Provides a simple query interface to check for gem dependencies
+    #
+    # ActiveAdmin::Dependencies.draper
+    # => #<Gem::Specification:0x3ffb89c49ae0 draper-1.2.1>
+    #
+    # ActiveAdmin::Dependencies.draper?
+    # => true
+    #
+    # ActiveAdmin::Dependencies.draper? :<=, '1.1.0'
+    # => false
+    #
+    # ActiveAdmin::Dependencies.draper? :==, '1.2.1'
+    # => true
+    #
+    def self.check_for(gem_name)
+      gem_name = gem_name.to_s
+
+      singleton_class.send :define_method, gem_name do
+        Gem.loaded_specs[gem_name]
+      end
+
+      singleton_class.send :define_method, gem_name+'?' do |verb = nil, version = nil|
+        spec = send gem_name
+        if verb && version
+          !!spec && spec.version.send(verb, Gem::Version.create(version))
+        else
+          !!spec
+        end
+      end
+    end
+
+    check_for :draper
+
+  end
+end

data/lib/active_admin/deprecation.rb

@@ -0,0 +1,35 @@
+module ActiveAdmin
+  module Deprecation
+    module_function
+
+    def warn(message, callstack = caller)
+      ActiveSupport::Deprecation.warn "Active Admin: #{message}", callstack
+    end
+
+    # Deprecate a method.
+    #
+    # @param [Module] klass the Class or Module to deprecate the method on
+    # @param [Symbol] method the method to deprecate
+    # @param [String] message the message to display to the end user
+    #
+    # Example:
+    #
+    #     class MyClass
+    #       def my_method
+    #         # ...
+    #       end
+    #       ActiveAdmin::Deprecation.deprecate self, :my_method,
+    #         "MyClass#my_method is being removed in the next release"
+    #     end
+    #
+    def deprecate(klass, method, message)
+      klass.send :define_method, "deprecated_#{method}", klass.instance_method(method)
+
+      klass.send :define_method, method do |*args|
+        ActiveAdmin::Deprecation.warn "#{message}", caller
+        send "deprecated_#{method}", *args
+      end
+    end
+
+  end
+end