yousty-activeadmin 1.0.4.pre → 1.0.5.pre

data/lib/active_admin/view_helpers/breadcrumb_helper.rb

@@ -4,20 +4,27 @@ module ActiveAdmin
 
       # Returns an array of links to use in a breadcrumb
       def breadcrumb_links(path = request.path)
-        parts = path[1..-1].split('/') # remove leading "/" and split up the URL
-        parts.pop                      # remove last since it's used as the page title
+        # remove leading "/" and split up the URL
+        # and remove last since it's used as the page title
+        parts = path.split('/').select(&:present?)[0..-2]
 
         parts.each_with_index.map do |part, index|
           # 1. try using `display_name` if we can locate a DB object
           # 2. try using the model name translation
           # 3. default to calling `titlecase` on the URL fragment
           if part =~ /\A(\d+|[a-f0-9]{24})\z/ && parts[index-1]
-            config = active_admin_config.belongs_to_config.try(:target) || active_admin_config
-            name   = display_name config.find_resource(part)
+            parent = active_admin_config.belongs_to_config.try :target
+            config = parent && parent.resource_name.route_key == parts[index-1] ? parent : active_admin_config
+            name   = display_name config.find_resource part
           end
-          name ||= I18n.t "activerecord.models.#{part.singularize}", :count => 1.1, :default => part.titlecase
+          name ||= I18n.t "activerecord.models.#{part.singularize}", count: ::ActiveAdmin::Helpers::I18n::PLURAL_MANY_COUNT, default: part.titlecase
 
-          link_to name, '/' + parts[0..index].join('/')
+          # Don't create a link if the resource's show action is disabled
+          if !config || config.defined_actions.include?(:show)
+            link_to name, '/' + parts[0..index].join('/')
+          else
+            name
+          end
         end
       end
 

data/lib/active_admin/view_helpers/display_helper.rb

@@ -2,45 +2,58 @@ module ActiveAdmin
   module ViewHelpers
     module DisplayHelper
 
+      DISPLAY_NAME_FALLBACK = ->{
+        name, klass = "", self.class
+        name << klass.model_name.human         if klass.respond_to? :model_name
+        name << " ##{send(klass.primary_key)}" if klass.respond_to? :primary_key
+        name.present? ? name : to_s
+      }
+      def DISPLAY_NAME_FALLBACK.inspect
+        'DISPLAY_NAME_FALLBACK'
+      end
+
       # Attempts to call any known display name methods on the resource.
       # See the setting in `application.rb` for the list of methods and their priority.
       def display_name(resource)
-        resource.send display_name_method_for resource if resource
+        render_in_context resource, display_name_method_for(resource) if resource
       end
 
       # Looks up and caches the first available display name method.
+      # To prevent conflicts, we exclude any methods that happen to be associations.
+      # If no methods are available and we're about to use the Kernel's `to_s`, provide our own.
       def display_name_method_for(resource)
         @@display_name_methods_cache ||= {}
         @@display_name_methods_cache[resource.class] ||= begin
           methods = active_admin_application.display_name_methods - association_methods_for(resource)
-          methods.detect{ |method| resource.respond_to? method }
+          method  = methods.detect{ |method| resource.respond_to? method }
+
+          if method != :to_s || resource.method(method).source_location
+            method
+          else
+            DISPLAY_NAME_FALLBACK
+          end
         end
       end
 
-      # To prevent conflicts, we exclude any methods that happen to be associations.
       def association_methods_for(resource)
         return [] unless resource.class.respond_to? :reflect_on_all_associations
         resource.class.reflect_on_all_associations.map(&:name)
       end
 
-      # Return a pretty string for any object
-      # Date Time are formatted via #localize with :format => :long
-      # ActiveRecord and Mongoid objects are formatted via #auto_link
-      # We attempt to #display_name of any other objects
+      # Attempts to create a human-readable string for any object
       def pretty_format(object)
         case object
-        when String
-          object
-        when Arbre::Element
-          object
+        when String, Numeric, Arbre::Element
+          object.to_s
         when Date, Time
-          localize(object, :format => :long)
-        when ->(obj){defined?(::ActiveRecord) && obj.is_a?(ActiveRecord::Base)}
-          auto_link(object)
-        when ->(obj){defined?(::Mongoid) && obj.class.included_modules.include?(Mongoid::Document)}
-          auto_link(object)
+          localize object, format: :long
         else
-          display_name(object)
+          if defined?(::ActiveRecord) && object.is_a?(ActiveRecord::Base) ||
+             defined?(::Mongoid)      && object.class.include?(Mongoid::Document)
+            auto_link object
+          else
+            display_name object
+          end
         end
       end
 

data/lib/active_admin/view_helpers/download_format_links_helper.rb

@@ -2,6 +2,20 @@ module ActiveAdmin
   module ViewHelpers
     module DownloadFormatLinksHelper
 
+      def build_download_format_links(formats = self.class.formats)
+        params = request.query_parameters.except :format, :commit
+        div class: "download_links" do
+          span I18n.t('active_admin.download')
+          formats.each do |format|
+            a format.upcase, href: url_for(params: params, format: format)
+          end
+        end
+      end
+
+      def self.included base
+        base.extend ClassMethods
+      end
+
       module ClassMethods
 
         # A ready only of formats to make available in index/paginated
@@ -14,36 +28,19 @@ module ActiveAdmin
           @formats.clone
         end
 
-        # Adds a mime type extension to the list of available formats.
-        # You must register the extension prior to adding it to the list
-        # of avilable formats. This should be used by plugins that want
-        # to add additional formats to the download format links.
-        # @param [Symbol] extension the mime extension to add
+        # Adds a mime type to the list of available formats available for data
+        # export. You must register the extension prior to adding it here.
+        # @param [Symbol] format the mime type to add
         # @return [Array] A copy of the updated formats array.
-        def add_format extension
-          unless formats.include?(extension)
-            if Mime::Type.lookup_by_extension(extension).nil?
-              raise ArgumentError, "The mime extension you defined: #{extension} is not registered. Please register it via Mime::Type.register before adding it to the available formats."
-            end
-          @formats << extension
+        def add_format(format)
+          unless Mime::Type.lookup_by_extension format
+            raise ArgumentError, "Please register the #{format} mime type with `Mime::Type.register`"
           end
+          @formats << format unless formats.include? format
           formats
         end
       end
 
-      # TODO: Refactor to new HTML DSL
-      def build_download_format_links(formats = self.class.formats)
-        params = request.query_parameters.except :format, :commit
-        links = formats.map { |format| link_to format.to_s.upcase, params: params, format: format }
-        div :class => "download_links" do
-          text_node [I18n.t('active_admin.download'), links].flatten.join("&nbsp;").html_safe
-        end
-      end
-
-      def self.included base
-        base.extend ClassMethods
-      end
     end
   end
 end
-

data/lib/active_admin/view_helpers/fields_for.rb

@@ -31,13 +31,13 @@ module ActiveAdmin
           when Symbol
             { k => v.to_s }
           when Hash
-            fields_for_params(v, :namespace => k)
+            fields_for_params(v, namespace: k)
           when Array
             v.map do |v|
               { "#{k}[]" => v }
             end
           when nil
-          	{ k => '' }
+            { k => '' }
           when TrueClass,FalseClass
             { k => v }
           else

data/lib/active_admin/view_helpers/flash_helper.rb

@@ -3,9 +3,10 @@ module ActiveAdmin
     module FlashHelper
 
       # Returns all the flash keys to display in any Active Admin view.
-      # This method removes the :timedout key that Devise uses by default
-      def active_admin_flash_messages
-        @active_admin_flash_messages ||= flash.to_hash.except(:timedout)
+      # This method removes the :timedout key that Devise uses by default.
+      # Note Rails >= 4.1 normalizes keys to strings automatically.
+      def flash_messages
+        @flash_messages ||= flash.to_hash.with_indifferent_access.except(*active_admin_application.flash_keys_to_except)
       end
 
     end

data/lib/active_admin/view_helpers/form_helper.rb

@@ -3,22 +3,18 @@ module ActiveAdmin
     module FormHelper
 
       def active_admin_form_for(resource, options = {}, &block)
-        options = Marshal.load( Marshal.dump(options) )
-        options[:builder] ||= ActiveAdmin::FormBuilder
-
-        if ! options.fetch(:decorate, true)
-          resource = resource.model
-        end
-
-        semantic_form_for resource, options, &block
+        Arbre::Context.new({}, self) do
+          active_admin_form_for resource, options, &block
+        end.content
       end
 
       def hidden_field_tags_for(params, options={})
         fields_for_params(params, options).map do |kv|
           k, v = kv.first
-          hidden_field_tag k, v, :id => sanitize_to_id("hidden_active_admin_#{k}")
+          hidden_field_tag k, v, id: sanitize_to_id("hidden_active_admin_#{k}")
         end.join("\n").html_safe
       end
+
     end
   end
 end

data/lib/active_admin/view_helpers/method_or_proc_helper.rb

@@ -25,7 +25,7 @@ module MethodOrProcHelper
   # or instance_exec a proc passing in the object as the first parameter. This
   # method wraps that pattern.
   #
-  # Calling with a Symbol:
+  # Calling with a String or Symbol:
   #
   #     call_method_or_proc_on(@my_obj, :size) same as @my_obj.size
   #
@@ -35,11 +35,11 @@ module MethodOrProcHelper
   #     call_method_or_proc_on(@my_obj, proc)
   #
   # By default, the Proc will be instance_exec'd within self. If you would rather
-  # not instance exec, but just call the Proc, then pass along `:exec => false` in
+  # not instance exec, but just call the Proc, then pass along `exec: false` in
   # the options hash.
   #
   #     proc = Proc.new{|s| s.size }
-  #     call_method_or_proc_on(@my_obj, proc, :exec => false)
+  #     call_method_or_proc_on(@my_obj, proc, exec: false)
   #
   # You can pass along any necessary arguments to the method / Proc as arguments. For
   # example:
@@ -47,13 +47,13 @@ module MethodOrProcHelper
   #     call_method_or_proc_on(@my_obj, :find, 1) #=> @my_obj.find(1)
   #
   def call_method_or_proc_on(receiver, *args)
-    options = { :exec => true }.merge(args.extract_options!)
+    options = { exec: true }.merge(args.extract_options!)
 
     symbol_or_proc = args.shift
 
     case symbol_or_proc
     when Symbol, String
-      receiver.send(symbol_or_proc.to_sym, *args)
+      receiver.public_send symbol_or_proc.to_sym, *args
     when Proc
       if options[:exec]
         instance_exec(receiver, *args, &symbol_or_proc)
@@ -85,7 +85,7 @@ module MethodOrProcHelper
     when Proc
       context.instance_exec *args, &obj
     when Symbol
-      context.send obj, *args
+      context.public_send obj, *args
     else
       obj
     end

data/lib/active_admin/views/action_items.rb

@@ -5,8 +5,8 @@ module ActiveAdmin
 
       def build(action_items)
         action_items.each do |action_item|
-          span :class => "action_item" do
-            instance_eval(&action_item.block)
+          span class: "action_item" do
+            instance_exec(&action_item.block)
           end
         end
       end

data/lib/active_admin/views/components/action_list_popover.rb

@@ -8,7 +8,7 @@ module ActiveAdmin
 
 
       def build(*args, &block)
-        @contents = ul :class => "popover_contents"
+        @contents = ul class: "popover_contents"
 
         options = args.extract_options!
 

data/lib/active_admin/views/components/active_admin_form.rb

@@ -0,0 +1,123 @@
+module ActiveAdmin
+  module Views
+    class FormtasticProxy < ::Arbre::Rails::Forms::FormBuilderProxy
+      def split_string_on(string, match)
+        return "" unless string && match
+        part_1 = string.split(Regexp.new("#{match}\\z")).first
+        [part_1, match]
+      end
+
+      def opening_tag
+        @opening_tag || ""
+      end
+
+      def closing_tag
+        @closing_tag || ""
+      end
+
+      def to_s
+        opening_tag << children.to_s << closing_tag
+      end
+    end
+    
+    class ActiveAdminForm < FormtasticProxy
+      builder_method :active_admin_form_for
+
+      def build(resource, options = {}, &block)
+        @resource = resource
+        options = options.deep_dup
+        options[:builder] ||= ActiveAdmin::FormBuilder
+        form_string = semantic_form_for(resource, options) do |f|
+          @form_builder = f
+        end
+
+        @opening_tag, @closing_tag = split_string_on(form_string, "</form>")
+        instance_eval(&block) if block_given?
+
+        # Rails 4 sets multipart automatically if a file field is present,
+        # but the form tag has already been rendered before the block eval.
+        if multipart? && @opening_tag !~ /multipart/
+          @opening_tag.sub!(/<form/, '<form enctype="multipart/form-data"')
+        end
+      end
+
+      def inputs(*args, &block)
+        if block_given? && block.arity == 0
+          wrapped_block = proc do
+            wrap_it = form_builder.already_in_an_inputs_block ? true : false
+            form_builder.already_in_an_inputs_block = true
+            form_builder.template.assign('has_many_block'=> true)
+            content = form_builder.template.capture do
+              block.call
+            end
+            form_builder.already_in_an_inputs_block = wrap_it
+            content
+          end
+          insert_tag(SemanticInputsProxy, form_builder, *args, &wrapped_block)
+        else
+          proxy_call_to_form(:inputs, *args, &block)
+        end
+      end
+
+      def input(*args)
+        proxy_call_to_form :input, *args
+      end
+
+      def actions(*args, &block)
+        block_given? ?
+          insert_tag(SemanticActionsProxy, form_builder, *args, &block) :
+          actions(*args) { commit_action_with_cancel_link }
+      end
+
+      def commit_action_with_cancel_link
+        action(:submit)
+        cancel_link
+      end
+
+      def has_many(*args, &block)
+        insert_tag(HasManyProxy, form_builder, *args, &block)
+      end
+
+      def multipart?
+        form_builder && form_builder.multipart?
+      end
+
+      def object
+        form_builder.object
+      end
+
+      def form_buffers
+        raise "'form_buffers' has been removed from ActiveAdmin::FormBuilder, please read https://github.com/activeadmin/activeadmin/blob/master/docs/5-forms.md for details."
+      end
+    end
+
+    class SemanticInputsProxy < FormtasticProxy
+      def build(form_builder, *args, &block)
+        options = args.extract_options!
+        legend = args.shift
+        legend_tag = legend ? "<legend><span>#{legend}</span></legend>" : ""
+        klasses = ["inputs"]
+        klasses << options[:class] if options[:class]
+        @opening_tag = "<fieldset class=\"#{klasses.join(" ")}\">#{legend_tag}<ol>"
+        @closing_tag = "</ol></fieldset>"
+        super(*(args << options), &block)
+      end
+    end
+
+    class SemanticActionsProxy < FormtasticProxy
+      def build(form_builder, *args, &block)
+        @opening_tag = "<fieldset class=\"actions\"><ol>"
+        @closing_tag = "</ol></fieldset>"
+        super(*args, &block)
+      end
+    end
+
+    class HasManyProxy < FormtasticProxy
+      def build(form_builder, *args, &block)
+        assoc = args[0]
+        builder_options = args[1] || {}
+        text_node form_builder.has_many(*args, &block)
+      end
+    end
+  end
+end

data/lib/active_admin/views/components/attributes_table.rb

@@ -4,8 +4,8 @@ module ActiveAdmin
     class AttributesTable < ActiveAdmin::Component
       builder_method :attributes_table_for
 
-      def build(record_or_collection, *attrs)
-        @collection = Array(record_or_collection)
+      def build(obj, *attrs)
+        @collection     = is_array?(obj) ? obj : [obj]
         @resource_class = @collection.first.class
         options = { }
         options[:for] = @collection.first if single_record?
@@ -59,44 +59,53 @@ module ActiveAdmin
           col # column for row headers
           @collection.each do |record|
             classes = Arbre::HTML::ClassList.new
-            classes << cycle(:even, :odd, :name => self.class.to_s)
+            classes << cycle(:even, :odd, name: self.class.to_s)
             classes << dom_class_name_for(record)
-            col(:id => dom_id_for(record), :class => classes)
+            col(id: dom_id_for(record), class: classes)
           end
         end
       end
 
       def header_content_for(attr)
         if @resource_class.respond_to?(:human_attribute_name)
-          @resource_class.human_attribute_name(attr, :default => attr.to_s.titleize)
+          @resource_class.human_attribute_name(attr, default: attr.to_s.titleize)
         else
           attr.to_s.titleize
         end
       end
 
       def empty_value
-        span I18n.t('active_admin.empty'), :class => "empty"
+        span I18n.t('active_admin.empty'), class: "empty"
       end
 
       def content_for(record, attr)
-        previous = current_arbre_element.to_s
-        value    = pretty_format find_attr_value(record, attr)
-        value.blank? && previous == current_arbre_element.to_s ? empty_value : value
+        value = pretty_format find_attr_value(record, attr)
+        value.blank? && current_arbre_element.children.to_s.empty? ? empty_value : value
       end
 
       def find_attr_value(record, attr)
         if attr.is_a?(Proc)
           attr.call(record)
-        elsif attr.to_s[/\A(.+)_id\z/] && record.respond_to?($1.to_sym)
-          record.send($1.to_sym)
-        else
-          record.send(attr.to_sym)
+        elsif attr =~ /\A(.+)_id\z/ && reflection_for(record.class, $1.to_sym)
+          record.public_send $1
+        elsif record.respond_to? attr
+          record.public_send attr
+        elsif record.respond_to? :[]
+          record[attr]
         end
       end
 
+      def reflection_for(klass, method)
+        klass.reflect_on_association method if klass.respond_to? :reflect_on_association
+      end
+
       def single_record?
         @single_record ||= @collection.size == 1
       end
+      
+      def is_array?(obj)
+        obj.respond_to?(:each) && obj.respond_to?(:first) && !obj.is_a?(Hash)
+      end
     end
 
   end