rails_admin_specified_actions 0.2.1.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 68fe0c0a44c1a044abea6ccb2119edb208a07baccee6c465c18fc6df2167c794
+  data.tar.gz: 3185483670aac1ae45230a9660935a4d7dee2cffa437ae08967357a6c9c9a112
+SHA512:
+  metadata.gz: 3187398a676a7c1cdf0a6235fc34eeb7d156c7acb2e8938a33384b4d0a0dac4793d19e40956c9c9a477dedb19ab5ed35df4d90d3cc26177dfcdc78e908bd731f
+  data.tar.gz: 0e3c52fbf1f58f3e3882966a12134380bec2f2df2f35c741ad5b9a1224ff2e8c23e7abaf7e6ca3daedeb97b749a8792490d2ec3aaa034f83e2ab7546e39b3e47

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rails_admin_specified_actions.gemspec
+gemspec

data/README.md

@@ -0,0 +1,148 @@
+# RailsAdminSpecifiedActions
+
+Custom actoions for RailsAdmin
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rails_admin_specified_actions'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rails_admin_specified_actions
+
+## Usage
+
+Add the sort_embedded action for each model or only for models you need
+
+```ruby
+    RailsAdmin.config do |config|
+      config.actions do
+        ...
+        specified_actions do
+          # You can add actions like this
+
+          require_relative 'rails_admin_specified_actions'
+          RailsAdminSpecifiedActions.root_actions(self)
+
+          # also you can add actions like this:
+          config.action :count do
+            object do
+              User
+            end
+          end # will perform `action_name` for `object`: 'User.count'
+        end # for root actions
+        specified_actions_for_collection # for collections actions
+        specified_actions_for_member # for member actions
+        ...
+      end
+    end
+```
+
+For root actions you can create config/initializers/rails_admin_specified_actions_root.rb:
+```ruby
+module RailsAdminSpecifiedActions
+
+  class << self
+
+    def root_actions(config)
+      config.action :some_root_action do
+        process_block do
+          proc { |obj, args|
+            # `obj` will be nil
+            Rails.cache.clear # or some other global action
+          }
+        end
+      end
+      config.action :some_root_action_with_obj do
+        process_block do
+          proc { |obj, args|
+            # `obj` will be User
+            obj.delete_all # delete them all
+          }
+        end
+        object do
+          Page
+        end
+      end
+    end
+
+  end
+
+end
+
+```
+or something like this.
+
+
+For collection and member actions actions:
+In rails_admin block:
+
+```ruby
+  rails_admin do
+    ...
+    specified_actions_for_collection do
+      action :count, :collection do
+        process_block do
+          proc { |model, args|
+            model.all.count
+          }
+        end
+      end
+    end
+    ...
+  end
+```
+or
+
+```ruby
+  rails_admin do
+    ...
+    specified_actions_for_member do
+      action :touch
+    end
+    ...
+  end
+```
+or both.
+
+Options for action:
+
+| Option name              | Description                                                      | Default value |
+|--------------------------|------------------------------------------------------------------|---------------|
+| label                    | Displayed label                                                  | as name       |
+| process_block            | Proc for action or action name for \__send__()                   | nil           |
+| target                   | :root, :collection or :member                                    | nil           |
+| ajax                     | If you don`t need reload page                                    | false         |
+| threaded                 | Create new thread for this action if that can take a long time   | false         |
+| can_view_error_backtrace | If you want show error code backtrace. Perhaps, only for admins. | 'only admin'  |
+| can_view_error_message   | If you want show detailed errors message                         | false         |
+| args                     | Hash of possible arguments (and their types) for action          | {}            |
+
+Possible argument types (and field types):
+
+
+| Type                     | Field                                                            |
+|--------------------------|------------------------------------------------------------------|
+| nil                      | String (`text_field` method)                                     |
+| :string                  | String (`text_field` method)                                     |
+| :boolean                 | Boolean/Checkbox field (`check_box` method)                      |
+| :toggle                  | Boolean/Checkbox field (`check_box` method)                      |
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/red-rocks/rails_admin_specified_actions.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/app/assets/javascripts/rails_admin/rails_admin_specified_actions.coffee

@@ -0,0 +1,27 @@
+$(document).on "ajax:complete", "#rails_admin_specified_actions_wrapper #rails_admin_specified_actions .form_block form", (e, xhr, opts)->
+  form = $(e.currentTarget)
+  result_block = form.closest(".form_block").siblings(".ajax_result_block")
+  error_block = result_block.siblings(".ajax_error_block")
+  json = $.parseJSON(xhr.responseText)
+  result_block.stop().hide().html(json['result'])
+  error_block.stop().hide().find("*").html("")
+  if json['error']
+    error_block.find(".message").html(json['error']['message'])     if json['error']['message']
+    error_block.find(".backtrace").html(json['error']['backtrace']) if json['error']['backtrace']
+    error_block.show(100)
+  result_block.show(100)
+
+
+$(document).on "ajax:before", "#rails_admin_specified_actions_wrapper #rails_admin_specified_actions .form_block form", (e)->
+  form = $(e.currentTarget)
+  result_block = form.closest(".form_block").siblings(".ajax_result_block")
+  error_block = result_block.siblings(".ajax_error_block")
+  result_block.hide(200)
+  error_block.hide(200)
+
+
+
+$(document).on "click", ".content > .alert > .show_hide, #rails_admin_specified_actions_wrapper #rails_admin_specified_actions .ajax_error_block .backtrace > .show_hide", (e)->
+  e.preventDefault()
+  $(e.currentTarget).parent().toggleClass('short')
+  return false

data/app/assets/stylesheets/rails_admin/rails_admin_specified_actions.sass

@@ -0,0 +1,26 @@
+html, body.rails_admin
+  overflow-y: scroll
+
+.content > .alert, .ajax_error_block .backtrace
+  max-height: auto
+  overflow: hidden
+  &.short
+    max-height: 53px
+  pre
+    margin: 0
+    padding: 0
+  > .show_hide
+    right: -17px
+
+
+#rails_admin_specified_actions_wrapper
+  #rails_admin_specified_actions
+
+    .ajax_error_block .backtrace
+      background-color: #fcf8e3
+      border-color: #faebcc
+      color: #8a6d3b
+      padding: 0px
+      margin-bottom: 20px
+      border: 1px solid transparent
+      border-radius: 4px

data/app/views/rails_admin/main/_specified_actions_list.html.slim

@@ -0,0 +1,30 @@
+ul
+  - @actions_list.each do |a|
+    li
+      span= a.label.blank? ? a.name : a.label
+      br
+      - unless a.desc.blank?
+        div= a.desc
+      .form_block
+        ruby:
+          opts = {url: _url, method: :post, data: {}}
+          opts[:data][:remote] = true if a.ajax
+        = form_for "specified_action", opts do |f|
+          = f.hidden_field :name, value: a.name
+          - if a.args and !a.args.blank?
+            - a.args.each_pair do |a_name, a_type|
+              = f.label "args[#{a_name}]", a_name
+              - case a_type and a_type.to_sym
+              - when :string 
+                = f.text_field "args[#{a_name}]"
+              - when :boolean, :toggle
+                = f.check_box "args[#{a_name}]"
+              - else
+                = f.text_field "args[#{a_name}]"
+              
+          / = f.submit "сделать"
+          = f.submit a.button_text
+      .ajax_result_block
+      .ajax_error_block
+        .message
+        .backtrace

data/app/views/rails_admin/main/specified_actions.html.slim

@@ -0,0 +1,24 @@
+= stylesheet_link_tag 'rails_admin/rails_admin_specified_actions'
+= javascript_include_tag 'rails_admin/rails_admin_specified_actions'
+
+#rails_admin_specified_actions_wrapper
+  #rails_admin_specified_actions
+    .controls
+      - if @object 
+        - if @actions_list.count > 0
+          = render partial: "rails_admin/main/specified_actions_list", locals: {_actions: @actions_list, _url: specified_actions_for_member_path(model_name: @abstract_model, id: @object.id)}
+        - else
+          h3 нечего делать c этой штукой
+          
+      - else
+        - if @abstract_model 
+          - if @actions_list.count > 0
+            = render partial: "rails_admin/main/specified_actions_list", locals: {_actions: @actions_list, _url: specified_actions_for_collection_path(model_name: @abstract_model)}            
+          - else
+            h3 нечего делать c этими штуками
+              
+        - else 
+          - if @actions_list.count > 0
+            = render partial: "rails_admin/main/specified_actions_list", locals: {_actions: @actions_list, _url: specified_actions_path}
+          - else
+            h3 нечего делать вообще

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rails_admin_specified_actions"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/config/locales/specific_actions.en.yml

@@ -0,0 +1,36 @@
+
+en:
+  admin:
+    actions:
+      specified_actions:
+        title:      "SpecifiedActions"
+        menu:       "SpecifiedActions for %{model_label} '%{object_label}'"
+        breadcrumb: "SpecifiedActions"
+        link:       "SpecifiedActions"
+        bulk_link:  "SpecifiedActions selected %{model_label_plural}"
+        done:       "SpecifiedActions done"
+        confirm:    "Are you sure?"
+
+        unknown_error:        "Unknown error"
+
+      specified_actions_for_collection:
+        title:      "SpecifiedActions"
+        menu:       "SpecifiedActions for %{model_label} '%{object_label}'"
+        breadcrumb: "SpecifiedActions"
+        link:       "SpecifiedActions"
+        bulk_link:  "SpecifiedActions selected %{model_label_plural}"
+        done:       "SpecifiedActions done"
+        confirm:    "Are you sure?"
+
+        unknown_error:        "Unknown error"
+
+      specified_actions_for_member:
+        title:      "SpecifiedActions"
+        menu:       "SpecifiedActions for %{model_label} '%{object_label}'"
+        breadcrumb: "SpecifiedActions"
+        link:       "SpecifiedActions"
+        bulk_link:  "SpecifiedActions selected %{model_label_plural}"
+        done:       "SpecifiedActions done"
+        confirm:    "Are you sure?"
+
+        unknown_error:        "Unknown error"

data/config/locales/specific_actions.ru.yml

@@ -0,0 +1,35 @@
+ru:
+  admin:
+    actions:
+      specified_actions:
+        title:      "Действия"
+        menu:       "Действия"
+        breadcrumb: "Действия"
+        link:       "Действия"
+        bulk_link:  "Действия"
+        done:       "Действия выполнены"
+        confirm:    "Вы уверены?"
+
+        unknown_error:       "Неизвестная ошибка"
+
+      specified_actions_for_collection:
+        title:      "Действия"
+        menu:       "Действия"
+        breadcrumb: "Действия"
+        link:       "Действия"
+        bulk_link:  "Действия"
+        done:       "Действия выполнены"
+        confirm:    "Вы уверены?"
+
+        unknown_error:       "Неизвестная ошибка"
+
+      specified_actions_for_member:
+        title:      "Действия"
+        menu:       "Действия"
+        breadcrumb: "Действия"
+        link:       "Действия"
+        bulk_link:  "Действия"
+        done:       "Действия выполнены"
+        confirm:    "Вы уверены?"
+
+        unknown_error:       "Неизвестная ошибка"

data/lib/rails_admin_specified_actions.rb

@@ -0,0 +1,19 @@
+require "rails_admin_specified_actions/version"
+require "rails_admin_specified_actions/engine"
+
+module RailsAdminSpecifiedActions
+
+  class << self
+    def root_actions(config)
+
+    end
+  end
+
+end
+
+require "rails_admin"
+require "rails_admin_specified_actions/rails_admin_patch"
+
+require "rails_admin_specified_actions/specified_action"
+require "rails_admin_specified_actions/section"
+require "rails_admin_specified_actions/action"

data/lib/rails_admin_specified_actions/action.rb

@@ -0,0 +1,203 @@
+require 'rails_admin/config/actions'
+require 'rails_admin/config/actions/base'
+
+require 'rails_admin_specified_actions/specified_action'
+
+module RailsAdmin
+  module Config
+    module Actions
+      class SpecifiedActions < RailsAdmin::Config::Actions::Base
+        RailsAdmin::Config::Actions.register(self)
+
+        include RailsAdmin::Config::HasActions
+
+        register_instance_option :root? do
+          true
+        end
+
+        register_instance_option :collection? do
+          false
+        end
+
+        register_instance_option :member do
+          false
+        end
+
+        register_instance_option :pjax? do
+          false
+        end
+
+        register_instance_option :route_fragment do
+          'specified_actions'
+        end
+
+        register_instance_option :template_name do
+          'specified_actions'
+        end
+
+        register_instance_option :controller do
+          proc do
+            def fallback_location
+              if @object
+                specified_actions_for_member_path(model_name: @abstract_model, id: @object.id)
+              elsif @abstract_model
+                specified_actions_for_collection_path(model_name: @abstract_model)
+              else
+                specified_actions_path
+              end
+            end
+            if @object
+              @actions_list = (@model_config.specified_actions_for_member.actions || []).select(&:member?)
+            elsif @abstract_model
+              @actions_list = (@model_config.specified_actions_for_collection.actions || []).select(&:collection?)
+            else
+              @actions_list = (RailsAdmin::Config.specified_actions || []).select(&:root?)
+            end
+            @actions_list.map! { |a| a.with({controller: self, object: @object, model: (@abstract_model and @abstract_model.model)}) }
+
+            if request.get? # Actions list
+              respond_to do |format|
+                format.html { render @action.template_name }
+                format.js   { render @action.template_name, layout: false }
+              end
+
+            elsif request.post? # Do action
+
+              if (_action = @actions_list.find { |a| a.name == params[:specified_action][:name].to_sym })
+                if _action.args.blank?
+                  args = {}
+                else
+                  args = (params.require(:specified_action).require(:args).permit(_action.args.keys) || {})
+                end
+                begin
+                  obj = @object || (@abstract_model and @abstract_model.model) || _action.object
+                  @result = _action.process(obj, args)
+                  @result = "Задача выполняется" if @result.is_a?(Thread)
+                  @result ||= "Успешно!"
+                rescue Exception => ex
+                  @error_message    = _action.can_view_error_message ? ex.message : "Произошла ошибка ;("
+                  @error_backtrace  = ex.backtrace.join("\n") if _action.can_view_error_backtrace
+                end
+                respond_to do |format|
+                  format.html {
+                    # render @action.template_name
+                    flash[:info] = "Попытка выполнения '#{_action.name}':"
+                    flash[:success] = @result.to_s unless @error_message
+                    flash[:error] = @error_message.to_s if @error_message
+                    if @error_backtrace
+                      flash[:alert] = "<button class='close show_hide' type='button'>⇕</button><pre>#{@error_backtrace}</pre>".html_safe
+                    end
+                    redirect_back(fallback_location: fallback_location)
+                  }
+                  format.js   {
+                    render json: {
+                      result: (@error_message || @result).to_s,
+                      error: {
+                        message:    @error_message.to_s,
+                        backtrace:  (@error_backtrace and "<button class='close show_hide' type='button'>⇕</button><pre>#{@error_backtrace}</pre>".html_safe)
+                      }.compact
+                    }
+                  }
+                end
+              else
+                respond_to do |format|
+                  format.html {
+                    # render @action.template_name
+                    flash[:error] = "Не найдено действия для выполнения"
+                    redirect_back(fallback_location: fallback_location)
+                  }
+                  format.js   {
+                    render json: {
+                      error: {
+                        message: "Не найдено действия для выполнения"
+                      }
+                    }
+                  }
+                end
+              end
+
+            end
+          end
+        end
+
+        register_instance_option :link_icon do
+          'fa fa-magic'
+        end
+
+        register_instance_option :statistics? do
+          false
+        end
+
+        register_instance_option :http_methods do
+          [:get, :post]
+        end
+      end
+    end
+  end
+end
+
+
+module RailsAdmin
+  module Config
+    module Actions
+      class SpecifiedActionsForCollection < RailsAdmin::Config::Actions::SpecifiedActions
+        RailsAdmin::Config::Actions.register(self)
+
+        # Is the action acting on the root level (Example: /admin/contact)
+        register_instance_option :root? do
+          false
+        end
+
+        register_instance_option :collection? do
+          true
+        end
+
+        register_instance_option :member do
+          false
+        end
+
+        register_instance_option :route_fragment do
+          'specified_actions'
+        end
+
+        register_instance_option :template_name do
+          'specified_actions'
+        end
+
+      end
+    end
+  end
+end
+
+
+module RailsAdmin
+  module Config
+    module Actions
+      class SpecifiedActionsForMember < RailsAdmin::Config::Actions::SpecifiedActions
+        RailsAdmin::Config::Actions.register(self)
+
+        # Is the action acting on the root level (Example: /admin/contact)
+        register_instance_option :root? do
+          false
+        end
+
+        register_instance_option :collection? do
+          false
+        end
+
+        register_instance_option :member do
+          true
+        end
+
+        register_instance_option :route_fragment do
+          'specified_actions'
+        end
+
+        register_instance_option :template_name do
+          'specified_actions'
+        end
+
+      end
+    end
+  end
+end

data/lib/rails_admin_specified_actions/engine.rb

@@ -0,0 +1,9 @@
+module RailsAdminSpecifiedActions
+  class Engine < ::Rails::Engine
+
+    initializer "RailsAdminSpecifiedActions precompile hook", group: :all do |app|
+      app.config.assets.precompile += %w(rails_admin/rails_admin_specified_actions.js rails_admin/rails_admin_specified_actions.css)
+    end
+    
+  end
+end

data/lib/rails_admin_specified_actions/has_actions.rb

@@ -0,0 +1,150 @@
+module RailsAdmin
+  module Config
+    # Provides accessors and autoregistering of model's fields.
+    module HasActions
+      # Defines a configuration for a field.
+      def action(name, target = nil, args = {}, add_to_section = true, &block)
+        action = _actions.detect { |a| name == a.name and (target.nil? or a.target == target) }
+
+        # some fields are hidden by default (belongs_to keys, has_many associations in list views.)
+        # unhide them if config specifically defines them
+        # if action
+        #   action.show unless action.instance_variable_get("@#{action.name}_registered").is_a?(Proc)
+        # end
+        # Specify field as virtual if type is not specifically set and field was not
+        # found in default stack
+
+        if action.nil? && args == {}
+          action = (_actions << RailsAdminSpecifiedActions::SpecifiedAction.new(self, name, args)).last
+        else
+          if args && args != (action.nil? ? {} : action.args)
+            if action
+              # properties = action.properties
+              action = _actions[_actions.index(action)] = RailsAdminSpecifiedActions::SpecifiedAction.new(self, name, args)
+            else
+              action = (_actions << RailsAdminSpecifiedActions::SpecifiedAction.new(self, name, args)).last
+            end
+          end
+        end
+        if target
+          action.target do
+            target
+          end
+        end
+
+        # If field has not been yet defined add some default properties
+        if add_to_section && !action.defined
+          action.defined = true
+          action.order = _actions.count(&:defined)
+        end
+
+        # If a block has been given evaluate it and sort fields after that
+        action.instance_eval(&block) if block
+        _actions
+      end
+
+      # configure a field without adding it.
+      def configure(name, type = nil, &block)
+        action(name, type, false, &block)
+      end
+
+      # include fields by name and apply an optionnal block to each (through a call to fields),
+      # or include fields by conditions if no field names
+      def include_actions(*action_names, &block)
+        if action_names.empty?
+          _actions.select { |a| a.instance_eval(&block) }.each do |a|
+            next if a.defined
+            a.defined = true
+            # a.order = _actions.count(&:defined)
+          end
+        else
+          actions(*action_names, &block)
+        end
+      end
+
+      # exclude fields by name or by condition (block)
+      def exclude_actions(*action_names, &block)
+        block ||= proc { |a| action_names.include?(a.name) }
+        _actions.each { |a| a.defined = true } if _actions.select(&:defined).empty?
+        _actions.select { |a| a.instance_eval(&block) }.each { |a| a.defined = false }
+      end
+
+      # API candy
+      alias_method :exclude_actions_if, :exclude_actions
+      alias_method :include_actions_if, :include_actions
+
+      def include_all_actions
+        include_actions_if { true }
+      end
+
+      # Returns all field configurations for the model configuration instance. If no fields
+      # have been defined returns all fields. Defined fields are sorted to match their
+      # order property. If order was not specified it will match the order in which fields
+      # were defined.
+      #
+      # If a block is passed it will be evaluated in the context of each field
+      def actions(*action_names, &block)
+        return all_actions if action_names.empty? && !block
+
+        if action_names.empty?
+          defined = _actions.select(&:defined)
+          defined = _actions if defined.empty?
+        else
+          defined = action_names.collect { |action_name| _actions.detect { |a| a.name == action_name } }
+        end
+        defined.collect do |a|
+          unless a.defined
+            a.defined = true
+            # a.order = _actions.count(&:defined)
+          end
+          a.instance_eval(&block) if block
+          a
+        end
+      end
+
+      # Defines configuration for fields by their type.
+      # def fields_of_type(type, &block)
+      #   _fields.select { |f| type == f.type }.map! { |f| f.instance_eval(&block) } if block
+      # end
+
+      # Accessor for all fields
+      def all_actions
+        ((ro_actions = _actions(true)).select(&:defined).presence || ro_actions).collect do |a|
+          # a.section = self
+          a
+        end
+      end
+
+      # Get all fields defined as visible, in the correct order.
+      def visible_actions
+        i = 0
+        # all_actions.collect { |a| a.with(bindings) }.select(&:visible?).sort_by { |a| [a.order, i += 1] } # stable sort, damn
+        all_actions.collect { |a| a.with(bindings) }.select(&:visible?)
+      end
+
+    # protected
+
+      # Raw fields.
+      # Recursively returns parent section's raw fields
+      # Duping it if accessed for modification.
+      def _actions(readonly = false)
+        return @_actions if @_actions
+        return @_ro_actions if readonly && @_ro_actions
+
+        if self.class == RailsAdmin::Config::Sections::Base
+          @_ro_actions = @_actions = [] #RailsAdmin::Config::Fields.factory(self)
+        else
+          # parent is RailsAdmin::Config::Model, recursion is on Section's classes
+          if respond_to?(:parent) and parent
+            @_ro_actions ||= [].freeze #parent.send(self.class.superclass.to_s.underscore.split('/').last)._actions(true).freeze
+          else
+            RailsAdmin::Config.specified_actions ||= []
+            @_ro_actions ||= RailsAdmin::Config.specified_actions
+            return readonly ? @_ro_actions : (RailsAdmin::Config.specified_actions ||= @_ro_actions.collect(&:clone))
+          end
+        end
+        readonly ? @_ro_actions : (@_actions ||= @_ro_actions.collect(&:clone))
+      end
+    end
+  end
+end

data/lib/rails_admin_specified_actions/rails_admin_patch.rb

@@ -0,0 +1,10 @@
+require 'rails_admin/config'
+module RailsAdmin
+  module Config
+
+    class << self
+      attr_accessor :specified_actions
+    end
+
+  end
+end

data/lib/rails_admin_specified_actions/section.rb

@@ -0,0 +1,19 @@
+# require 'rails_admin/config/sections'
+require 'rails_admin/config/sections/list'
+require 'rails_admin_specified_actions/has_actions'
+
+module RailsAdmin
+  module Config
+    module Sections
+      # Configuration of the explore view
+      class SpecifiedActions < Base
+        include RailsAdmin::Config::HasActions
+      end
+      class SpecifiedActionsForCollection < SpecifiedActions
+      end
+      class SpecifiedActionsForMember < SpecifiedActions
+      end
+    end
+  end
+end
+RailsAdmin::Config::Model.send :include, RailsAdmin::Config::Sections

data/lib/rails_admin_specified_actions/specified_action.rb

@@ -0,0 +1,151 @@
+require 'rails_admin/config/proxyable'
+require 'rails_admin/config/configurable'
+class RailsAdminSpecifiedActions::SpecifiedAction
+
+  include RailsAdmin::Config::Proxyable
+  include RailsAdmin::Config::Configurable
+
+  attr_accessor :section, :defined, :order,
+                :abstract_model, :root, :parent,
+                :name
+
+  def initialize(_parent, _name, _args = {}, &block)
+    @parent = _parent
+    @root   = _parent.root
+    @section = _parent
+
+    @abstract_model = parent.abstract_model unless parent.is_a?(RailsAdmin::Config::Actions::SpecifiedActions)
+    @defined = false
+    @name = _name.to_sym
+    args   = _args || {}
+    @process_block = block
+  end
+
+  def root?
+    @root
+    # @parent.nil? or @parent == @root
+    # self.target == :root
+  end
+  def collection?
+    @parent.is_a? RailsAdmin::Config::Sections::SpecifiedActionsForCollection
+    # self.target == :collection
+  end
+  def member?
+    @parent.is_a? RailsAdmin::Config::Sections::SpecifiedActionsForMember
+    # self.target == :member
+  end
+
+  # private :do_process
+  def do_process(target, args)
+    if (_pb = self.process_block)
+      if _pb.respond_to?(:call)
+        begin
+          _pb.call(target, args)
+        rescue
+          _pb.call(target)
+        end
+      else
+        begin
+          target and target.try(_pb, args)
+        rescue
+          target and target.try(_pb)
+        end
+      end
+    else
+      begin
+        target and target.try(@name, args)
+      rescue
+        target and target.try(@name)
+      end
+    end
+  end
+
+
+  def process(target, args)
+    return threaded_process(target, args) if self.threaded
+    do_process(target, args)
+  end
+
+  def threaded_process(target, args)
+    Thread.new(self, target, args) do |action, target, args|
+      action.do_process(target, args)
+    end
+  end
+
+  register_instance_option :label do
+    name
+  end
+
+  register_instance_option :button_text do
+    name
+  end
+
+  register_instance_option :desc do
+    nil
+  end
+
+  register_instance_option :visible? do
+    true
+  end
+
+  register_instance_option :can_view_error_backtrace do
+    cont = (bindings and bindings[:controller])
+    cu =  (cont and cont._current_user)
+    if cu
+      if cont.respond_to?(:can?)
+        cont.can?(:view_error_backtrace, self)
+      elsif cu.respond_to?(:can_view_error_backtrace)
+        cu.can_view_error_backtrace
+      elsif cu.respond_to?(:admin?)
+        cu.admin?
+      end
+    else
+      false
+    end
+  end
+
+  register_instance_option :can_view_error_message do
+    cont = (bindings and bindings[:controller])
+    cu =  (cont and cont._current_user)
+    if cu
+      if cont.respond_to?(:can?)
+        cont.can?(:view_error_message, self)
+      elsif cu.respond_to?(:can_view_error_message)
+        cu.can_view_error_message
+      elsif cu.respond_to?(:admin?)
+        cu.admin?
+      end
+    else
+      false
+    end
+  end
+
+  register_instance_option :process_block do
+    nil #true
+  end
+
+  register_instance_option :target do
+    nil
+  end
+
+  register_instance_option :ajax do
+    false
+  end
+
+  register_instance_option :threaded do
+    false
+  end
+
+  register_instance_option :object do
+    nil
+  end
+
+  register_instance_option :args do
+    {}
+  end
+
+        register_instance_option :button_text do
+          'do'
+        end
+
+end

data/lib/rails_admin_specified_actions/version.rb

@@ -0,0 +1,3 @@
+module RailsAdminSpecifiedActions
+  VERSION = "0.2.1.rc1"
+end

data/rails_admin_specified_actions.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rails_admin_specified_actions/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rails_admin_specified_actions"
+  spec.version       = RailsAdminSpecifiedActions::VERSION
+  spec.authors       = ["Alexander Kiseliev"]
+  spec.email         = ["dev@redrocks.pro"]
+
+  spec.summary       = %q{custom actions for rails_admin}
+  spec.description   = %q{custom actions for rails_admin}
+  spec.homepage      = "https://github.com/red-rocks/rails_admin_specified_actions"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_dependency "rails_admin", ">= 0.8.1"
+end

data/release.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/bash
+bundle update
+git add --all .
+git commit -am "${*:1}"
+git push -u origin master
+rake release

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: rails_admin_specified_actions
+version: !ruby/object:Gem::Version
+  version: 0.2.1.rc1
+platform: ruby
+authors:
+- Alexander Kiseliev
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-04-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails_admin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+description: custom actions for rails_admin
+email:
+- dev@redrocks.pro
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- app/assets/javascripts/rails_admin/rails_admin_specified_actions.coffee
+- app/assets/stylesheets/rails_admin/rails_admin_specified_actions.sass
+- app/views/rails_admin/main/_specified_actions_list.html.slim
+- app/views/rails_admin/main/specified_actions.html.slim
+- bin/console
+- bin/setup
+- config/locales/specific_actions.en.yml
+- config/locales/specific_actions.ru.yml
+- lib/rails_admin_specified_actions.rb
+- lib/rails_admin_specified_actions/action.rb
+- lib/rails_admin_specified_actions/engine.rb
+- lib/rails_admin_specified_actions/has_actions.rb
+- lib/rails_admin_specified_actions/rails_admin_patch.rb
+- lib/rails_admin_specified_actions/section.rb
+- lib/rails_admin_specified_actions/specified_action.rb
+- lib/rails_admin_specified_actions/version.rb
+- rails_admin_specified_actions.gemspec
+- release.sh
+homepage: https://github.com/red-rocks/rails_admin_specified_actions
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.9
+signing_key: 
+specification_version: 4
+summary: custom actions for rails_admin
+test_files: []