activeadmin 2.2.0

data/lib/active_admin/view_helpers/download_format_links_helper.rb

@@ -0,0 +1,59 @@
+module ActiveAdmin
+  module ViewHelpers
+    module DownloadFormatLinksHelper
+      private
+
+      def build_download_formats(download_links)
+        download_links = instance_exec(&download_links) if download_links.is_a?(Proc)
+
+        if download_links.is_a?(Array) && !download_links.empty?
+          download_links
+        elsif download_links == false
+          []
+        else
+          self.class.formats
+        end
+      end
+
+      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
+        # collection view.
+        # @return [Array]
+        # @see add_format for information on adding custom download link
+        # formats
+        def formats
+          @formats ||= [:csv, :xml, :json]
+          @formats.clone
+        end
+
+        # 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(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
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/fields_for.rb

@@ -0,0 +1,50 @@
+module ActiveAdmin
+  module ViewHelpers
+    module FormHelper
+
+      # Flatten a params Hash to an array of fields.
+      #
+      # @param params [Hash]
+      # @param options [Hash] :namespace and :except
+      #
+      # @return [Array] of [Hash] with one element.
+      #
+      # @example
+      #   fields_for_params(scope: "all", users: ["greg"])
+      #     => [ {"scope" => "all"} , {"users[]" => "greg"} ]
+      #
+      def fields_for_params(params, options = {})
+        namespace = options[:namespace]
+        except    = Array.wrap(options[:except]).map &:to_s
+
+        params.flat_map do |k, v|
+          next if namespace.nil? && %w(controller action commit utf8).include?(k.to_s)
+          next if except.include?(k.to_s)
+
+          if namespace
+            k = "#{namespace}[#{k}]"
+          end
+
+          case v
+          when String
+            { k => v }
+          when Symbol
+            { k => v.to_s }
+          when Hash
+            fields_for_params(v, namespace: k)
+          when Array
+            v.map do |v|
+              { "#{k}[]" => v }
+            end
+          when nil
+            { k => '' }
+          when TrueClass, FalseClass
+            { k => v }
+          else
+            raise "I don't know what to do with #{v.class} params: #{v.inspect}"
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/active_admin/view_helpers/flash_helper.rb

@@ -0,0 +1,14 @@
+module ActiveAdmin
+  module ViewHelpers
+    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.
+      # 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
+  end
+end

data/lib/active_admin/view_helpers/form_helper.rb

@@ -0,0 +1,20 @@
+module ActiveAdmin
+  module ViewHelpers
+    module FormHelper
+
+      def active_admin_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.to_unsafe_hash, options).map do |kv|
+          k, v = kv.first
+          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

@@ -0,0 +1,100 @@
+# Utility methods for internal use.
+# @private
+module MethodOrProcHelper
+  extend self
+
+  # This method will either call the symbol on self or instance_exec the Proc
+  # within self. Any args will be passed along to the method dispatch.
+  #
+  # Calling with a Symbol:
+  #
+  #     call_method_or_exec_proc(:to_s) #=> will call #to_s
+  #
+  # Calling with a Proc
+  #
+  #     my_proc = Proc.new{ to_s }
+  #     call_method_or_exec_proc(my_proc) #=> will instance_exec in self
+  #
+  def call_method_or_exec_proc(symbol_or_proc, *args)
+    case symbol_or_proc
+    when Symbol, String
+      send(symbol_or_proc, *args)
+    when Proc
+      instance_exec(*args, &symbol_or_proc)
+    else
+      symbol_or_proc
+    end
+  end
+
+  # Many times throughout the views we want to either call a method on an object
+  # or instance_exec a proc passing in the object as the first parameter. This
+  # method wraps that pattern.
+  #
+  # Calling with a String or Symbol:
+  #
+  #     call_method_or_proc_on(@my_obj, :size) same as @my_obj.size
+  #
+  # Calling with a Proc:
+  #
+  #     proc = Proc.new{|s| s.size }
+  #     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
+  # the options hash.
+  #
+  #     proc = Proc.new{|s| s.size }
+  #     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:
+  #
+  #     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!)
+
+    symbol_or_proc = args.shift
+
+    case symbol_or_proc
+    when Symbol, String
+      receiver.public_send symbol_or_proc.to_sym, *args
+    when Proc
+      if options[:exec]
+        instance_exec(receiver, *args, &symbol_or_proc)
+      else
+        symbol_or_proc.call(receiver, *args)
+      end
+    else
+      symbol_or_proc
+    end
+  end
+
+  # Many configuration options (Ex: site_title, title_image) could either be
+  # static (String), methods (Symbol) or procs (Proc). This helper takes care of
+  # returning the content when String or call call_method_or_proc_on when Symbol or Proc.
+  #
+  def render_or_call_method_or_proc_on(obj, string_symbol_or_proc, options = {})
+    case string_symbol_or_proc
+    when Symbol, Proc
+      call_method_or_proc_on(obj, string_symbol_or_proc, options)
+    else
+      string_symbol_or_proc
+    end
+  end
+
+  # This method is different from the others in that it calls `instance_exec` on the receiver,
+  # passing it the proc. This evaluates the proc in the context of the receiver, thus changing
+  # what `self` means inside the proc.
+  def render_in_context(context, obj, *args)
+    context = self if context.nil? # default to `self` only when nil
+    case obj
+    when Proc
+      context.instance_exec *args, &obj
+    when Symbol
+      context.public_send obj, *args
+    else
+      obj
+    end
+  end
+end

data/lib/active_admin/view_helpers/scope_name_helper.rb

@@ -0,0 +1,16 @@
+module ActiveAdmin
+  module ViewHelpers
+    module ScopeNameHelper
+
+      def scope_name(scope)
+        case scope.name
+        when Proc then
+          self.instance_exec(&scope.name).to_s
+        else
+          scope.name.to_s
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/sidebar_helper.rb

@@ -0,0 +1,15 @@
+module ActiveAdmin
+  module ViewHelpers
+    module SidebarHelper
+
+      def skip_sidebar!
+        @skip_sidebar = true
+      end
+
+      def skip_sidebar?
+        @skip_sidebar == true
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/title_helper.rb

@@ -0,0 +1,11 @@
+module ActiveAdmin
+  module ViewHelpers
+    module TitleHelper
+
+      def title(_title)
+        @page_title = _title
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/view_factory_helper.rb

@@ -0,0 +1,11 @@
+module ActiveAdmin
+  module ViewHelpers
+    module ViewFactoryHelper
+
+      def view_factory
+        active_admin_namespace.view_factory
+      end
+
+    end
+  end
+end

data/lib/active_admin/views.rb

@@ -0,0 +1,8 @@
+module ActiveAdmin
+  module Views
+
+    # Loads all the classes in views/*.rb
+    Dir[File.expand_path('views', __dir__) + "/**/*.rb"].sort.each { |f| require f }
+
+  end
+end

data/lib/active_admin/views/action_items.rb

@@ -0,0 +1,17 @@
+module ActiveAdmin
+  module Views
+
+    class ActionItems < ActiveAdmin::Component
+
+      def build(action_items)
+        action_items.each do |action_item|
+          span class: action_item.html_class do
+            instance_exec(&action_item.block)
+          end
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,155 @@
+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 = helpers.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 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?
+          form_builder.template.assigns[:has_many_block] = true
+        end
+        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
+            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
+          # Set except option to prevent sensitive fields from being shown in forms by default.
+          opts = args.extract_options!
+          opts[:except] ||= []
+          ActiveAdmin.application.filter_attributes.each { |e| opts[:except] << e }
+          args << opts
+
+          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
+        add_create_another_checkbox
+        action(:submit)
+        cancel_link
+      end
+
+      def add_create_another_checkbox
+        if %w(new create).include?(helpers.action_name) && active_admin_config && active_admin_config.create_another
+          current_arbre_element.add_child(create_another_checkbox)
+        end
+      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
+
+      private
+
+      def create_another_checkbox
+        create_another = params[:create_another]
+        label = @resource.class.model_name.human
+        Arbre::Context.new do
+          li class: 'create_another' do
+            input(
+              checked: create_another,
+              id: 'create_another',
+              name: 'create_another',
+              type: 'checkbox'
+            )
+            label(I18n.t('active_admin.create_another', model: label), for: 'create_another')
+          end
+        end
+      end
+    end
+
+    class SemanticInputsProxy < FormtasticProxy
+      def build(form_builder, *args, &block)
+        html_options = args.extract_options!
+        html_options[:class] ||= "inputs"
+        legend = args.shift if args.first.is_a?(::String)
+        legend = html_options.delete(:name) if html_options.key?(:name)
+        legend_tag = legend ? "<legend><span>#{legend}</span></legend>" : ""
+        fieldset_attrs = html_options.map { |k, v| %Q{#{k}="#{v}"} }.join(" ")
+        @opening_tag = "<fieldset #{fieldset_attrs}>#{legend_tag}<ol>"
+        @closing_tag = "</ol></fieldset>"
+        super(*(args << html_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)
+        text_node form_builder.has_many(*args, &block)
+      end
+    end
+  end
+end