activeadmin 0.6.6 → 1.0.0.pre1

data/lib/active_admin/inputs/filter_base/search_method_select.rb

@@ -1,73 +0,0 @@
-# This is a common set of Formtastic overrides needed to build a filter form
-# that lets you select from a set of search methods for a given attribute.
-#
-# Your class must declare available filters for this module to work.
-# Those filters must be recognizable by Metasearch. For example:
-#
-#   class FilterNumericInput < ::Formtastic::Inputs::NumberInput
-#     include FilterBase
-#     include FilterBase::SearchMethodSelect
-#
-#     filter :equals, :greater_than, :less_than
-#   end
-#
-module ActiveAdmin
-  module Inputs
-    module FilterBase
-      module SearchMethodSelect
-
-        def self.included(base)
-          base.extend ClassMethods
-        end
-
-        module ClassMethods
-          attr_reader :filters
-
-          def filter(*filters)
-            (@filters ||= []).push *filters
-          end
-        end
-
-        def wrapper_html_options
-          opts = super
-          (opts[:class] ||= '') << ' select_and_search'
-          opts
-        end
-
-        def to_html
-          input_wrapping do
-            label_html  << # your label
-            select_html << # the dropdown that holds the available search methods
-            input_html     # your input field
-          end
-        end
-
-        def input_html
-          builder.text_field current_filter, input_html_options
-        end
-
-        def select_html
-          template.select_tag '', template.options_for_select(filter_options, current_filter)
-        end
-
-        def filters
-          options[:filters] || self.class.filters
-        end
-
-        def current_filter
-          @current_filter ||= begin
-            methods = filters.map{ |f| "#{method}_#{f}" }
-            methods.detect{ |m| @object.send m } || methods.first
-          end
-        end
-
-        def filter_options
-          filters.collect do |filter|
-            [I18n.t("active_admin.filters.predicates.#{filter}"), "#{method}_#{filter}"]
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/active_admin/inputs/filter_boolean_input.rb

@@ -1,36 +0,0 @@
-module ActiveAdmin
-  module Inputs
-    class FilterBooleanInput < ::Formtastic::Inputs::BooleanInput
-      include FilterBase
-
-      def to_html
-        input_wrapping do
-          [ label_html,
-            check_box_html
-          ].join("\n").html_safe
-        end
-      end
-
-      def search_method
-        method.to_s.match(search_conditions) ? method : "#{method}_eq"
-      end
-
-      def checked?
-        object && boolean_checked?(object.send(search_method), checked_value)
-      end
-
-      def input_html_options
-        { :name => "q[#{ search_method }]" }
-      end
-
-      def search_conditions
-        /(is_true|is_false|is_present|is_blank|is_null|is_not_null)\z/
-      end
-
-      def boolean_checked?(value, checked_value)
-        defined?(super) ? super : ActionView::Helpers::InstanceTag.check_box_checked?(value, checked_value)
-      end
-
-    end
-  end
-end

data/lib/active_admin/inputs/filter_check_boxes_input.rb

@@ -1,40 +0,0 @@
-module ActiveAdmin
-  module Inputs
-    class FilterCheckBoxesInput < ::Formtastic::Inputs::CheckBoxesInput
-      include FilterBase
-
-      def input_name
-        "#{object_name}[#{association_primary_key || method}_in][]"
-      end
-
-      def selected_values
-        @object.send("#{association_primary_key || method}_in") || []
-      end
-
-      # Add whitespace before label
-      def choice_label(choice)
-        ' ' + super
-      end
-
-      # Don't wrap in UL tag
-      def choices_group_wrapping(&block)
-        template.capture(&block)
-      end
-
-      # Don't wrap in LI tag
-      def choice_wrapping(html_options, &block)
-        template.capture(&block)
-      end
-
-      # Don't render hidden fields
-      def hidden_field_for_all
-        ""
-      end
-
-      # Don't render hidden fields
-      def hidden_fields?
-        false
-      end
-    end
-  end
-end

data/lib/active_admin/inputs/filter_date_range_input.rb

@@ -1,34 +0,0 @@
-module ActiveAdmin
-  module Inputs
-    class FilterDateRangeInput < ::Formtastic::Inputs::StringInput
-      include FilterBase
-
-      def to_html
-        input_wrapping do
-          [ label_html,
-            builder.text_field(gt_input_name, input_html_options(gt_input_name)),
-            template.content_tag(:span, "-", :class => "seperator"),
-            builder.text_field(lt_input_name, input_html_options(lt_input_name)),
-          ].join("\n").html_safe
-        end
-      end
-
-      def gt_input_name
-        "#{method}_gte"
-      end
-      alias :input_name :gt_input_name
-
-      def lt_input_name
-        "#{method}_lte"
-      end
-
-      def input_html_options(input_name = gt_input_name)
-        current_value = @object.send(input_name)
-        { :size => 12,
-          :class => "datepicker",
-          :max => 10,
-          :value => current_value.respond_to?(:strftime) ? current_value.strftime("%Y-%m-%d") : "" }
-      end
-    end
-  end
-end

data/lib/active_admin/inputs/filter_numeric_input.rb

@@ -1,10 +0,0 @@
-module ActiveAdmin
-  module Inputs
-    class FilterNumericInput < ::Formtastic::Inputs::NumberInput
-      include FilterBase
-      include FilterBase::SearchMethodSelect
-
-      filter :equals, :greater_than, :less_than
-    end
-  end
-end

data/lib/active_admin/inputs/filter_select_input.rb

@@ -1,49 +0,0 @@
-module ActiveAdmin
-  module Inputs
-    class FilterSelectInput < ::Formtastic::Inputs::SelectInput
-      include FilterBase
-
-      # If MetaSearch already responds to the given method, just use it.
-      #
-      # Otherwise:
-      # When it's a HABTM or has_many association, Formtastic builds "object_ids".
-      # That doesn't fit our scenario, so we override it here.
-      def input_name
-        return method if @object.respond_to? method
-
-        name = method.to_s
-        name.concat '_id' if reflection
-        name.concat multiple? ? '_in' : '_eq'
-      end
-
-      # Provide the AA translation to the blank input field.
-      def include_blank
-        I18n.t 'active_admin.any' if super
-      end
-
-      # was "#{object_name}[#{association_primary_key}]"
-      def input_html_options_name
-        "#{object_name}[#{input_name}]"
-      end
-
-      # Would normally return true for has_many and HABTM, which would subsequently
-      # cause the select field to be multi-select instead of a dropdown.
-      def multiple_by_association?
-        false
-      end
-
-      # Provides an efficient default lookup query if the attribute is a DB column.
-      def collection
-        unless Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR < 2
-          return pluck_column if !options[:collection] && column_for(method)
-        end
-        super
-      end
-
-      def pluck_column
-        @object.base.reorder("#{method} asc").uniq.pluck method
-      end
-
-    end
-  end
-end

data/lib/active_admin/inputs/filter_string_input.rb

@@ -1,24 +0,0 @@
-module ActiveAdmin
-  module Inputs
-    class FilterStringInput < ::Formtastic::Inputs::StringInput
-      include FilterBase
-      include FilterBase::SearchMethodSelect
-
-      filter :contains, :equals, :starts_with, :ends_with
-
-      # If the filter method includes a search condition, build a normal string search field.
-      # Else, build a search field with a companion dropdown to choose a search condition from.
-      def to_html
-        if @object.methods.exclude?(method) && @object.respond_to?(method)
-          input_wrapping do
-            label_html <<
-            builder.text_field(method, input_html_options)
-          end
-        else
-          super # SearchMethodSelect#to_html
-        end
-      end
-
-    end
-  end
-end

data/lib/active_admin/reloader.rb

@@ -1,130 +0,0 @@
-module ActiveAdmin
-
-  module Reloader
-
-    # Builds the proper Reloader implementation class given the
-    # current version of Rails.
-    #
-    # @param [Rails::Application] rails_app The current rails application
-    # @param [ActiveAdmin::Application] active_admin_app The current Active Admin app
-    # @param [String] rails_version The version of Rails we're using.
-    #
-    # @returns A concrete subclass of AbstractReloader
-    def self.build(rails_app, active_admin_app, rails_version)
-      reloader_class = rails_version.to_f >= 3.2 ? Rails32Reloader : RailsLessThan31Reloader
-      reloader_class.new(rails_app, active_admin_app, rails_version)
-    end
-
-    class AbstractReloader
-
-      attr_reader :active_admin_app, :rails_app, :rails_version
-
-      def initialize(rails_app, active_admin_app, rails_version)
-        @rails_app = rails_app
-        @active_admin_app = active_admin_app
-        @rails_version = rails_version.to_s
-      end
-
-      def attach!
-        raise "Please implement #{self.class}#attach!"
-      end
-
-      def reload!
-        active_admin_app.unload!
-        rails_app.reload_routes!
-      end
-
-      def major_rails_version
-        @rails_version[0..2]
-      end
-
-    end
-
-    # Reloads the application when using Rails 3.2
-    #
-    # 3.2 introduced a to_prepare block that only gets called when
-    # files have actually changed. ActiveAdmin had built this functionality
-    # in to speed up applications. So in Rails >= 3.2, we can now piggy
-    # back off the existing reloader. This simplifies our duties... which is
-    # nice.
-    class Rails32Reloader < AbstractReloader
-
-      # Attach to Rails and perform the reload on each request.
-      def attach!
-        active_admin_app.load_paths.each do |path|
-          rails_app.config.watchable_dirs[path] = [:rb]
-        end
-
-        reloader = self
-
-        ActionDispatch::Reloader.to_prepare do
-          reloader.reload!
-        end
-      end
-
-    end
-
-    # Deals with reloading Active Admin on each request in
-    # development and once in production in Rails < 3.2.
-    class RailsLessThan31Reloader < AbstractReloader
-
-      class FileUpdateChecker < ::ActiveSupport::FileUpdateChecker
-        def paths
-          # hack to support both Rails 3.1 and 3.2
-          @files || @paths
-        end
-
-        # Over-ride the default #updated_at to support the deletion of files
-        def updated_at
-          paths.map { |path| File.mtime(path) rescue Time.now }.max
-        end
-
-        def execute_if_updated
-          super
-        end
-      end
-
-      attr_reader :file_update_checker
-
-      def initialize(rails_app, active_admin_app, rails_version)
-        super
-        @file_update_checker = FileUpdateChecker.new(watched_paths) do
-          reload!
-        end
-      end
-
-      def reload!
-        super
-        file_update_checker.paths.clear
-        watched_paths.each{|path| file_update_checker.paths << path }
-      end
-
-
-      # Attach to Rails and perform the reload on each request.
-      def attach!
-        # Bring the checker into local scope for the ruby block
-        checker = file_update_checker
-
-        reloader_class.to_prepare do
-          checker.execute_if_updated
-        end
-      end
-
-      def watched_paths
-        paths = active_admin_app.load_paths
-        active_admin_app.load_paths.each{|path| paths += Dir[File.join(path, "**", "*.rb")]}
-        paths
-      end
-
-      def reloader_class
-        if major_rails_version == "3.1"
-          ActionDispatch::Reloader
-        else
-          ActionDispatch::Callbacks
-        end
-      end
-
-    end
-
-  end
-end

data/lib/active_admin/resource_controller/actions.rb

@@ -1,81 +0,0 @@
-module ActiveAdmin
-  class ResourceController < BaseController
-
-    # Override the InheritedResources actions to use the
-    # Active Admin templates.
-    #
-    # We ensure that the functionality provided by Inherited
-    # Resources is still available within any ResourceController
-
-    def index(options={}, &block)
-      super(options) do |format|
-        block.call(format) if block
-        format.html { render active_admin_template('index') }
-        format.csv do
-          headers['Content-Type'] = 'text/csv; charset=utf-8'
-          headers['Content-Disposition'] = %{attachment; filename="#{csv_filename}"}
-          render active_admin_template('index')
-        end
-      end
-    end
-    alias :index! :index
-
-    def show(options={}, &block)
-      super do |format|
-        block.call(format) if block
-        format.html { render active_admin_template('show') }
-      end
-    end
-    alias :show! :show
-
-    def new(options={}, &block)
-      super do |format|
-        block.call(format) if block
-        format.html { render active_admin_template('new') }
-      end
-    end
-    alias :new! :new
-
-    def edit(options={}, &block)
-      super do |format|
-        block.call(format) if block
-        format.html { render active_admin_template('edit') }
-      end
-    end
-    alias :edit! :edit
-
-    def create(options={}, &block)
-      super(options) do |success, failure|
-        block.call(success, failure) if block
-        failure.html { render active_admin_template('new') }
-      end
-    end
-    alias :create! :create
-
-    def update(options={}, &block)
-      super do |success, failure|
-        block.call(success, failure) if block
-        failure.html { render active_admin_template('edit') }
-      end
-    end
-    alias :update! :update
-
-
-    # Make aliases protected
-    protected :index!, :show!, :new!, :create!, :edit!, :update!
-
-    protected
-
-    # Returns the full location to the Active Admin template path
-    def active_admin_template(template)
-      "active_admin/resource/#{template}"
-    end
-
-    # Returns a filename for the csv file using the collection_name
-    # and current date such as 'my-articles-2011-06-24.csv'.
-    def csv_filename
-      "#{resource_collection_name.to_s.gsub('_', '-')}-#{Time.now.strftime("%Y-%m-%d")}.csv"
-    end
-
-  end
-end