yousty-activeadmin 1.0.4.pre → 1.0.5.pre

data/lib/active_admin/dependency.rb

@@ -0,0 +1,93 @@
+module ActiveAdmin
+  module Dependency
+    DEVISE = '~> 3.2'
+
+    # Provides a clean interface to check for gem dependencies at runtime.
+    #
+    # ActiveAdmin::Dependency.draper
+    # => #<ActiveAdmin::Dependency::Matcher for draper 1.2.1>
+    #
+    # ActiveAdmin::Dependency.draper?
+    # => true
+    #
+    # ActiveAdmin::Dependency.draper? '>= 1.5.0'
+    # => false
+    #
+    # ActiveAdmin::Dependency.draper? '= 1.2.1'
+    # => true
+    #
+    # ActiveAdmin::Dependency.draper? '~> 1.2.0'
+    # => true
+    #
+    # ActiveAdmin::Dependency.rails? '>= 4.1.0', '<= 4.1.1'
+    # => true
+    #
+    # ActiveAdmin::Dependency.rails! '2'
+    # -> ActiveAdmin::DependencyError: You provided rails 3.2.18 but we need: 2.
+    #
+    # ActiveAdmin::Dependency.devise!
+    # -> ActiveAdmin::DependencyError: To use devise you need to specify it in your Gemfile.
+    #
+    #
+    # All but the pessimistic operator (~>) can also be run using Ruby's comparison syntax.
+    #
+    # ActiveAdmin::Dependency.rails >= '3.2.18'
+    # => true
+    #
+    # Which is especially useful if you're looking up a gem with dashes in the name.
+    #
+    # ActiveAdmin::Dependency['jquery-ui-rails'] < 5
+    # => false
+    #
+    def self.method_missing(name, *args)
+      if name[-1] == '?'
+        Matcher.new(name[0..-2]).match? args
+      elsif name[-1] == '!'
+        Matcher.new(name[0..-2]).match! args
+      else
+        Matcher.new name.to_s
+      end
+    end
+
+    def self.[](name)
+      Matcher.new name.to_s
+    end
+
+    class Matcher
+      def initialize(name)
+        @name, @spec = name, Gem.loaded_specs[name]
+      end
+
+      def match?(*reqs)
+        !!@spec && Gem::Requirement.create(reqs).satisfied_by?(@spec.version)
+      end
+
+      def match!(*reqs)
+        unless @spec
+          raise DependencyError, "To use #{@name} you need to specify it in your Gemfile."
+        end
+
+        unless match? reqs
+          raise DependencyError, "You provided #{@spec.name} #{@spec.version} but we need: #{reqs.join ', '}."
+        end
+      end
+
+      include Comparable
+
+      def <=>(other)
+        if @spec
+          @spec.version <=> Gem::Version.create(other)
+        else
+          # you'd otherwise get an unhelpful error message:
+          # ArgumentError: comparison of ActiveAdmin::Dependency::Matcher with 2 failed
+          raise DependencyError, "To use #{@name} you need to specify it in your Gemfile."
+        end
+      end
+
+      def inspect
+        info = @spec ? "#{@spec.name} #{@spec.version}" : '(missing)'
+        "<ActiveAdmin::Dependency::Matcher for #{info}>"
+      end
+    end
+  end
+end

data/lib/active_admin/deprecation.rb

@@ -23,13 +23,12 @@ module ActiveAdmin
     #     end
     #
     def deprecate(klass, method, message)
-      klass.class_eval <<-EOC, __FILE__, __LINE__ + 1
-        alias_method :deprecated_#{method}, :#{method}
-        def #{method}(*args)
-          ActiveAdmin::Deprecation.warn('#{message}', caller)
-          send(:deprecated_#{method}, *args)
-        end
-      EOC
+      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

data/lib/active_admin/devise.rb

@@ -1,28 +1,26 @@
+ActiveAdmin::Dependency.devise! ActiveAdmin::Dependency::DEVISE
+
 require 'devise'
 
 module ActiveAdmin
   module Devise
 
     def self.config
-      config = {
-        :path => ActiveAdmin.application.default_namespace,
-        :controllers => ActiveAdmin::Devise.controllers,
-        :path_names => { :sign_in => 'login', :sign_out => "logout" }
+      {
+        path: ActiveAdmin.application.default_namespace || "/",
+        controllers: ActiveAdmin::Devise.controllers,
+        path_names: { sign_in: 'login', sign_out: "logout" },
+        sign_out_via: [*::Devise.sign_out_via, ActiveAdmin.application.logout_link_method].uniq
       }
-
-      if ::Devise.respond_to?(:sign_out_via)
-        logout_methods = [::Devise.sign_out_via, ActiveAdmin.application.logout_link_method].flatten.uniq
-        config.merge!( :sign_out_via => logout_methods)
-      end
-
-      config
     end
 
     def self.controllers
       {
-        :sessions => "active_admin/devise/sessions",
-        :passwords => "active_admin/devise/passwords",
-        :unlocks => "active_admin/devise/unlocks"
+        sessions: "active_admin/devise/sessions",
+        passwords: "active_admin/devise/passwords",
+        unlocks: "active_admin/devise/unlocks",
+        registrations: "active_admin/devise/registrations",
+        confirmations: "active_admin/devise/confirmations"
       }
     end
 
@@ -66,5 +64,19 @@ module ActiveAdmin
       include ::ActiveAdmin::Devise::Controller
     end
 
+    class RegistrationsController < ::Devise::RegistrationsController
+       include ::ActiveAdmin::Devise::Controller
+    end
+
+    class ConfirmationsController < ::Devise::ConfirmationsController
+       include ::ActiveAdmin::Devise::Controller
+    end
+
+    def self.controllers_for_filters
+      [SessionsController, PasswordsController, UnlocksController,
+        RegistrationsController, ConfirmationsController
+      ]
+    end
+
   end
 end

data/lib/active_admin/dsl.rb

@@ -1,9 +1,8 @@
 module ActiveAdmin
 
-  #
   # The Active Admin DSL. This class is where all the registration blocks
-  # are instance eval'd. This is the central place for the API given to
-  # users of Active Admin
+  # are evaluated. This is the central place for the API given to
+  # users of Active Admin.
   #
   class DSL
 
@@ -13,10 +12,10 @@ module ActiveAdmin
 
     # Runs the registration block inside this object
     def run_registration_block(&block)
-      instance_eval &block if block_given?
+      instance_exec &block if block_given?
     end
 
-    # The instance of ActiveAdmin::Config that's being registered
+    # The instance of ActiveAdmin::Resource that's being registered
     # currently. You can use this within your registration blocks to
     # modify options:
     #
@@ -51,13 +50,13 @@ module ActiveAdmin
     #
     # @param [Module] mod A module to include
     #
-    # @returns [Nil]
+    # @return [Nil]
     def include(mod)
       mod.included(self)
     end
 
     # Returns the controller for this resource. If you pass a
-    # block, it will be eval'd in the controller
+    # block, it will be evaluated in the controller.
     #
     # Example:
     #
@@ -72,19 +71,27 @@ module ActiveAdmin
     #   end
     #
     def controller(&block)
-      @config.controller.class_eval(&block) if block_given?
+      @config.controller.class_exec(&block) if block_given?
       @config.controller
     end
 
     # Add a new action item to the resource
     #
+    # @param [Symbol] name
     # @param [Hash] options valid keys include:
     #                 :only:  A single or array of controller actions to display
     #                         this action item on.
     #                 :except: A single or array of controller actions not to
     #                          display this action item on.
-    def action_item(options = {}, &block)
-      config.add_action_item(options, &block)
+    def action_item(name = nil, options = {}, &block)
+      if name.is_a?(Hash)
+        options = name
+        name = nil
+      end
+
+      Deprecation.warn "using `action_item` without a name is deprecated! Use `action_item(:edit)`." unless name
+
+      config.add_action_item(name, options, &block)
     end
 
     # Add a new batch action item to the resource
@@ -101,7 +108,7 @@ module ActiveAdmin
     def batch_action(title, options = {}, &block)
       # Create symbol & title information
       if title.is_a? String
-        sym = title.titleize.gsub(' ', '').underscore.to_sym
+        sym = title.titleize.tr(' ', '').underscore.to_sym
       else
         sym = title
         title = sym.to_s.titleize

data/lib/active_admin/engine.rb

@@ -1,7 +1,12 @@
 module ActiveAdmin
   class Engine < ::Rails::Engine
-    initializer "ActiveAdmin precompile hook", :group => :all do |app|
-      app.config.assets.precompile += %w(active_admin.js active_admin.css active_admin/print.css)
+    initializer "active_admin.precompile", group: :all do |app|
+      ActiveAdmin.application.stylesheets.each do |path, _|
+        app.config.assets.precompile << path
+      end
+      ActiveAdmin.application.javascripts.each do |path|
+        app.config.assets.precompile << path
+      end
     end
   end
 end

data/lib/active_admin/error.rb

@@ -0,0 +1,59 @@
+module ActiveAdmin
+  # Exception class to raise when there is an authorized access
+  # exception thrown. The exception has a few goodies that may
+  # be useful for capturing / recognizing security issues.
+  class AccessDenied < StandardError
+    attr_reader :user, :action, :subject
+
+    def initialize(user, action, subject)
+      @user, @action, @subject = user, action, subject
+
+      super()
+    end
+
+    def message
+      I18n.t("active_admin.access_denied.message")
+    end
+  end
+
+  class Error < RuntimeError
+  end
+
+  class ErrorLoading < Error
+    # Locates the most recent file and line from the caught exception's backtrace.
+    def find_cause(folder, backtrace)
+      backtrace.grep(/\/(#{folder}\/.*\.rb):(\d+)/){ [$1, $2] }.first
+    end
+  end
+
+  class DatabaseHitDuringLoad < ErrorLoading
+    def initialize(exception)
+      file, line = find_cause(:app, exception.backtrace)
+
+      super "Your file, #{file} (line #{line}), caused a database error while Active Admin was loading. This " +
+            "is most common when your database is missing or doesn't have the latest migrations applied. To " +
+            "prevent this error, move the code to a place where it will only be run when a page is rendered. " +
+            "One solution can be, to wrap the query in a Proc." +
+            "Original error message: #{exception.message}"
+    end
+
+    def self.capture
+      yield
+    rescue *database_error_classes => exception
+      raise new exception
+    end
+
+  private
+
+    def self.database_error_classes
+      @classes ||= []
+    end
+  end
+
+  class DependencyError < ErrorLoading
+  end
+
+  class NoMenuError < KeyError
+  end
+
+end

data/lib/active_admin/filters/dsl.rb

@@ -8,8 +8,8 @@ module ActiveAdmin
       end
 
       # For docs, please see ActiveAdmin::Filters::ResourceExtension#remove_filter
-      def remove_filter(attribute)
-        config.remove_filter(attribute)
+      def remove_filter(*attributes)
+        config.remove_filter(*attributes)
       end
 
       # For docs, please see ActiveAdmin::Filters::ResourceExtension#preserve_default_filters!

data/lib/active_admin/filters/forms.rb

@@ -1,19 +1,17 @@
 module ActiveAdmin
   module Filters
-
     # This form builder defines methods to build filter forms such
     # as the one found in the sidebar of the index page of a standard resource.
     class FormBuilder < ::ActiveAdmin::FormBuilder
       include ::ActiveAdmin::Filters::FormtasticAddons
+      self.input_namespaces = [::Object, ::ActiveAdmin::Inputs::Filters, ::ActiveAdmin::Inputs, ::Formtastic::Inputs]
 
-      def initialize(*args)
-        @use_form_buffer = true # force ActiveAdmin::FormBuilder to use the form buffer
-        super
-      end
+      # TODO: remove input class finders after formtastic 4 (where it will be default)
+      self.input_class_finder = ::Formtastic::InputClassFinder
 
       def filter(method, options = {})
         if method.present? && options[:as] ||= default_input_type(method)
-          input(method, options)
+          template.concat input(method, options)
         end
       end
 
@@ -22,8 +20,10 @@ module ActiveAdmin
       # Returns the default filter type for a given attribute. If you want
       # to use a custom search method, you have to specify the type yourself.
       def default_input_type(method, options = {})
-        if method =~ /_(contains|starts_with|ends_with)\z/
+        if method =~ /_(eq|equals|cont|contains|start|starts_with|end|ends_with)\z/
           :string
+        elsif klass._ransackers.key?(method.to_s)
+          klass._ransackers[method.to_s].type
         elsif reflection_for(method) || polymorphic_foreign_type?(method)
           :select
         elsif column = column_for(method)
@@ -39,15 +39,6 @@ module ActiveAdmin
           end
         end
       end
-
-      def custom_input_class_name(as)
-        "Filter#{as.to_s.camelize}Input"
-      end
-
-      def active_admin_input_class_name(as)
-        "ActiveAdmin::Inputs::Filter#{as.to_s.camelize}Input"
-      end
-
     end
 
 
@@ -56,30 +47,28 @@ module ActiveAdmin
 
       # Helper method to render a filter form
       def active_admin_filters_form_for(search, filters, options = {})
-        defaults = { :builder => ActiveAdmin::Filters::FormBuilder,
-                     :url     => collection_path,
-                     :html    => {:class  => 'filter_form'} }
-        required = { :html    => {:method => :get},
-                     :as      => :q }
+        defaults = { builder: ActiveAdmin::Filters::FormBuilder,
+                     url: collection_path,
+                     html: {class: 'filter_form'} }
+        required = { html: {method: :get},
+                     as: :q }
         options  = defaults.deep_merge(options).deep_merge(required)
 
         form_for search, options do |f|
           filters.each do |attribute, opts|
-            should   = opts.delete(:if)     || proc{ true }
-            shouldnt = opts.delete(:unless) || proc{ false }
+            next if opts.key?(:if)     && !call_method_or_proc_on(self, opts[:if])
+            next if opts.key?(:unless) &&  call_method_or_proc_on(self, opts[:unless])
 
-            if call_method_or_proc_on(self, should) && !call_method_or_proc_on(self, shouldnt)
-              f.filter attribute, opts
-            end
+            f.filter attribute, opts.except(:if, :unless)
           end
 
-          buttons = content_tag :div, :class => "buttons" do
+          buttons = content_tag :div, class: "buttons" do
             f.submit(I18n.t('active_admin.filters.buttons.filter')) +
-              link_to(I18n.t('active_admin.filters.buttons.clear'), '#', :class => 'clear_filters_btn') +
-              hidden_field_tags_for(params, :except => [:q, :page])
+              link_to(I18n.t('active_admin.filters.buttons.clear'), '#', class: 'clear_filters_btn') +
+              hidden_field_tags_for(params, except: [:q, :page])
           end
 
-          f.form_buffers.last + buttons
+          f.template.concat buttons
         end
       end
 

data/lib/active_admin/filters/formtastic_addons.rb

@@ -11,7 +11,7 @@ module ActiveAdmin
         if klass.respond_to?(:human_attribute_name)
           klass.human_attribute_name(method)
         else
-          method.to_s.send(builder.label_str_method)
+          method.to_s.public_send(builder.label_str_method)
         end
       end
 
@@ -37,34 +37,43 @@ module ActiveAdmin
       end
 
       def polymorphic_foreign_type?(method)
-        klass.reflections.values.select{ |r| r.macro == :belongs_to && r.options[:polymorphic] }
+        klass.reflect_on_all_associations.select{ |r| r.macro == :belongs_to && r.options[:polymorphic] }
           .map(&:foreign_type).include? method.to_s
       end
 
-      def searchable_through_association?(method = method)
-        ref = reflection_for(method)
-        ref.options[:through] && ref.through_reflection.klass.ransackable_attributes.include?(ref.foreign_key) if ref
-      end
-
       #
-      # These help figure out whether the given method will be recognized by Ransack.
+      # These help figure out whether the given method or association will be recognized by Ransack.
       #
 
+      def searchable_has_many_through?
+        if reflection && reflection.options[:through]
+          reflection.through_reflection.klass.ransackable_attributes.include? reflection.foreign_key
+        else
+          false
+        end
+      end
+
       def seems_searchable?
-        has_predicate? || ransacker?
+        has_predicate? || ransacker? || scope?
       end
 
       # If the given method has a predicate (like _eq or _lteq), it's pretty
       # likely we're dealing with a valid search method.
       def has_predicate?
-        !!Ransack::Predicate.detect_and_strip_from_string!(method.to_s)
+        !!Ransack::Predicate.detect_from_string(method.to_s)
       end
 
-      # Ransack lets you define custom search methods, so we need to check for them.
+      # Ransack lets you define custom search methods, called ransackers.
       def ransacker?
         klass._ransackers.key? method.to_s
       end
 
+      # Ransack supports exposing selected scopes on your model for advanced searches.
+      def scope?
+        context = Ransack::Context.for klass
+        context.respond_to?(:ransackable_scope?) && context.ransackable_scope?(method.to_s, klass)
+      end
+
     end
   end
 end