rs-active_admin-sortable_tree 2.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 186e690db8e7c024d32af6eb103aec23a61995b7843aa82380506d0ba9e14a91
+  data.tar.gz: d12dcb444862b75f86e03a00e8acd8ea084865e9537d3e648992d5374875a1ab
+SHA512:
+  metadata.gz: d3add2cb7ab0ea838175ee39ff88378932e8337742c0a3898ae3083554bba57f00bd119d8d02dc86dc76d51f812fc851020deccefa136c6d92dbeff38f885bfd
+  data.tar.gz: c8949af1bb754a93d463356bce5b999f9aedd8c797c33d80b1dde3745dc863fb451d872a9114e4b1b2a6292bcbb9c22a5e49dfc3b73b893bf355956276dcc8de

data/Changelog.md

@@ -0,0 +1,75 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+
+## [2.0.0] - 2018-01-22
+
+### Changed
+
+- Depend on same version of `jquery-ui-rails` as ActiveAdmin
+- Update dependencies to only support ActiveAdmin `< 1.1.0` because `v1.1.0`
+  [dropped its dependency on `jquery-ui-rails`](https://github.com/activeadmin/activeadmin/blob/master/CHANGELOG.md).
+- Remove usage of bourbon mixin; instead rely on ActiveAdmin's utilities mixin
+  (fixes #73)
+
+### Removed
+
+- Remove support for Rails 3.2
+- Remove support for ActiveAdmin 0.6.6
+
+### Upgrading from 1.0.0
+
+It is suggested (but not required) to manually include the JavaScript and
+stylesheet to your manifest files in preparation for ActiveAdmin v2.0. See the
+Installation section of the [README.md](README.md#installation) for instructions.
+
+## [1.0.0] - 2017-06-01
+
+### Added
+
+- Support for Rails 5.0 and 5.1 by conditionally invoking `parameterize` with its
+  expected parameters.
+
+### Changed
+
+- Relax dependency on `jquery-ui-rails` to be `>= 5.0` (previously `~> 5.0`).
+
+### Removed
+
+- Ruby 1.9.3, 2.1, and 2.2 are no longer explicitly supported.
+
+## [0.3.0] - 2016-09-08
+
+- Rename sortable.css.sass to sortable.sass to fix deprecation warnings
+- Update usage of box-sizing to fix Bourbon deprecation warning
+
+## [0.2.1] - 2015-04-15
+
+- Suppress list styles on sortable indexes when batch actions are disabled.
+  ([#48](https://github.com/zorab47/activeadmin-sortable-tree/issues/48)).
+- Do not render the extra cell for batch actions when they are disabled, which
+  removes extra whitespace to the left of items.
+
+## [0.2.0] - 2014-12-23
+
+- Shrink gem file size by excluding spec files and dummy application.
+
+## [0.1.0] - 2014-11-19
+
+- Add option to disable sorting: `sortable: false`, which causes the index view
+  to be a static tree view.
+- Ensure the default actions honor authorization checks
+  ([#43](https://github.com/nebirhos/activeadmin-sortable-tree/pull/43)).
+
+## 0.0.1 - 2014-08-07
+
+- Published to Rubygems.
+
+
+[unreleased]: https://github.com/zorab47/active_admin-sortable_tree/compare/v1.0.0...HEAD
+[0.1.0]: https://github.com/zorab47/active_admin-sortable_tree/compare/v0.0.1...v0.1.0
+[0.2.0]: https://github.com/zorab47/active_admin-sortable_tree/compare/v0.1.0...v0.2.0
+[0.2.1]: https://github.com/zorab47/active_admin-sortable_tree/compare/v0.2.0...v0.2.1
+[0.3.0]: https://github.com/zorab47/active_admin-sortable_tree/compare/v0.2.1...v0.3.0
+[1.0.0]: https://github.com/zorab47/active_admin-sortable_tree/compare/v0.3.0...v1.0.0
+[1.1.0]: https://github.com/zorab47/active_admin-sortable_tree/compare/v1.0.0...v1.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,254 @@
+# ActiveAdmin::SortableTree
+
+This fork allows to work with awesome nested set & adds custom HTML in label
+
+[![Build Status](https://travis-ci.org/rs-pro/active_admin-sortable_tree.svg?branch=master)](https://travis-ci.org/rs-pro/active_admin-sortable_tree)
+
+This gem adds a tree and a list view to your ActiveAdmin resource index, both
+sortable via drag'n'drop.
+
+![ActiveAdmin::SortableTree Example](docs/example.gif)
+
+## Installation
+
+```ruby
+# Gemfile
+gem "activeadmin"
+gem "rs-active_admin-sortable_tree"
+```
+
+```ruby
+# app/assets/javascripts/active_admin.js
+//= require active_admin/sortable
+
+# app/assets/stylesheets/active_admin.scss
+@import "active_admin/sortable";
+```
+
+## Usage (Tree)
+
+**Admin**:
+
+```ruby
+# app/admin/page.rb
+ActiveAdmin.register Page do
+  sortable tree: true
+
+  index :as => :sortable do
+    label :title # item content
+        actions
+  end
+end
+```
+
+### Custom HTML in label
+
+```ruby
+# app/admin/home_item.rb
+ActiveAdmin.register HomeItem do
+  member_action :toggle, method: :get do
+    resource.update_attribute :enabled, !resource.enabled
+
+    render js: "$('#home_item_#{resource.id} .status_tag').removeClass('yes').removeClass('no').addClass('#{resource.enabled ? :yes : :no}').text('#{resource.enabled ? "Вкл" : "Выкл"}')"
+  end
+
+  index as: :sortable do
+    label do |r|
+      span(r.id) +
+      span(r.name) + span(" ") +
+      a("data-href": toggle_admin_home_item_path(r), class: "status_tag #{r.enabled ? :yes : :no}") do
+        r.enabled ? "Вкл" : "Выкл"
+      end
+    end
+  end
+end
+```
+
+```js
+// app/assets/javascripts/active_admin.js
+
+$(document).on("click", ".status_tag", function(e) {
+  e.preventDefault()
+  e.stopPropagation();
+  var $t = $(this)
+  $.ajax({
+    url: $t.data("href"),
+    success: function (r) {
+      eval(r)
+    },
+    error: function(e) {
+      console.error(e)
+    }
+  })
+})
+
+```
+
+**Model**: ActiveAdmin::SortableTree is agnostic to the tree implementation. All
+you have to do is expose a sorting attribute and a few tree methods (`:parent`,
+`:children` and `:roots`).  Let's say you use
+[Ancestry](https://github.com/stefankroes/ancestry):
+
+```ruby
+class Page < ActiveRecord::Base
+  attr_accessible :title, :body, :position
+  has_ancestry :orphan_strategy => :rootify
+end
+```
+
+You can configure these methods if you need:
+
+```ruby
+ActiveAdmin.register Page do
+  sortable tree: true,
+           sorting_attribute: :position,
+           parent_method: :parent,
+           children_method: :children,
+           roots_method: :roots,
+           roots_collection: proc { current_user.pages.roots }
+  # …
+end
+```
+
+The option `roots_collection` provides full control on how to find the root
+nodes of your sortable tree and is evaluated within the context of the
+controller. Please note that `roots_collection` will override what is specified
+in `roots_method`.
+
+## Usage (List)
+
+**Admin**:
+
+```ruby
+# app/admin/page.rb
+ActiveAdmin.register Page do
+  sortable
+
+  index :as => :sortable do
+    label :title # item content
+    actions
+  end
+end
+```
+
+**Model**: Sortable list assumes you have a `:position` field in your resource.
+Of course it's configurable:
+
+```ruby
+ActiveAdmin.register Page do
+  sortable tree: false, # default
+           sorting_attribute: :my_position_field
+  # …
+end
+```
+
+**Note**: If you are using the [acts_as_list](https://github.com/swanandp/acts_as_list) gem to manage a `:position` field (not required, but allows for other nice programmatic manipulation of ordered model lists), you must ensure a zero-based index for your list using the `top_of_list` option:
+
+```ruby
+class Page < ActiveRecord::Base
+  # Make this list act like a zero-indexed array to avoid off-by-one errors in your sorting
+  acts_as_list top_of_list: 0
+end
+```
+
+
+## Usage (generic ActiveAdmin index)
+
+Currently supports only IndexAsBlock, more to come!
+
+**Admin**:
+```ruby
+# app/admin/page.rb
+ActiveAdmin.register Page do
+  sortable
+
+  index :as => :block do |page|
+    # item content
+  end
+end
+```
+
+**Model**: Same as list view (see above)
+
+## Customization
+
+### Full options list with defaults
+
+```ruby
+ActiveAdmin.register Page do
+  sortable tree: true,
+           max_levels: 0,               # infinite indent levels
+           protect_root: false,         # allow root items to be dragged
+           sorting_attribute: :position,
+           parent_method: :parent,
+           children_method: :children,
+           roots_method: :roots,
+           roots_collection: nil,       # proc to specifiy retrieval of roots
+           sortable: true,              # Disable sorting (use only 'tree' functionality)
+           collapsible: false,          # show +/- buttons to collapse children
+           start_collapsed: false,      # when collapsible, start with all roots collapsed
+end
+```
+
+
+### Actions
+
+In `IndexAsSortable` you can add custom actions (with or without the defaults):
+
+```ruby
+index :as => :sortable do
+  actions defaults: false do |page|
+    link_to "Custom action", my_custom_path(page)
+  end
+end
+```
+
+### Ajax Callback Config
+
+It exposes three Ajax Events: ajaxDone, ajaxFail and ajaxAlways, which
+correspond to jQuery ajax callbacks: done, fail and always.
+
+To subscribe Ajax callback:
+
+```javascript
+ActiveAdminSortableEvent.add('ajaxDone', function (){
+  // do what you want
+})
+```
+
+### Upgrading to SortableTree 2.0 from 1.0
+
+Upgrading from SortableTree 1.x requires manually specifying assets in your
+`app/assets/javascripts/active_admin.js` and `app/assets/stylesheets/active_admin.scss`
+files.
+
+
+### Dependencies
+
+ActiveAdmin::SortableTree 2.0 supports ActiveAdmin 1.0.0+. For previous versions
+of ActiveAdmin use older SortableTree versions from the 1.x branch.
+
+Note: If you experience issues with drag and drop capability, you may need to
+specify the version for your ActiveAdmin installation. It is reported working
+using v0.6.6, or if you are using v1.0.0.pre, it is reported working on this
+commit [b3a9f4b](https://github.com/activeadmin/activeadmin/commit/b3a9f4b3e4051447d011c59649a73f876989a199)
+or later.
+
+```ruby
+# Gemfile
+gem 'activeadmin', github: 'activeadmin', ref: 'b3a9f4b'
+```
+
+## Semantic Versioning
+
+ActiveAdmin::SortableTree follows [semantic versioning](http://semver.org).
+
+## Alternatives
+
+- [Active Admin Sortable](https://github.com/neo/activeadmin-sortable)
+
+## Copyright
+
+Copyright © 2013 Francesco Disperati, Cantiere Creativo. See the file
+MIT-LICENSE for details. See the full list list of
+[contributors](http://github.com/zorab47/active_admin-sortable_tree/graphs/contributors).

data/app/assets/javascripts/active_admin/sortable.js

@@ -0,0 +1,2 @@
+//= require jquery-ui/widgets/sortable
+//= require active_admin/sortable_core

data/app/assets/javascripts/active_admin/sortable_core.js

@@ -0,0 +1,109 @@
+//= require jquery.mjs.nestedSortable
+
+window.ActiveAdminSortableEvent = (function() {
+  var eventToListeners;
+  eventToListeners = {};
+  return {
+    add: function(event, callback) {
+      if (!eventToListeners.hasOwnProperty(event)) {
+        eventToListeners[event] = [];
+      }
+      eventToListeners[event].push(callback);
+    },
+    trigger: function(event, args) {
+      var callback, e, i, len, ref, results;
+      if (eventToListeners.hasOwnProperty(event)) {
+        ref = eventToListeners[event];
+        results = [];
+        for (i = 0, len = ref.length; i < len; i++) {
+          callback = ref[i];
+          try {
+            results.push(callback.call(null, args));
+          } catch (_error) {
+            e = _error;
+            if (console && console.error) {
+              results.push(console.error(e));
+            } else {
+              results.push(void 0);
+            }
+          }
+        }
+        return results;
+      }
+    }
+  };
+})();
+
+$(function() {
+  $('.disclose').bind('click', function(event) {
+    $(this).closest('li').toggleClass('mjs-nestedSortable-collapsed').toggleClass('mjs-nestedSortable-expanded');
+  });
+  $(".index_as_sortable [data-sortable-type]").each(function() {
+    var $this, max_levels, tab_hack, getData;
+    $this = $(this);
+
+
+    if ($this.data('sortable-type') === "tree") {
+      max_levels = $this.data('max-levels');
+      tab_hack = 20;
+      getData = function(item) {
+        return {
+          id: item.data("id"),
+          parent_id: item.parent().parent().data("id"),
+          prev_id: item.prev().data("id"),
+          next_id: item.next().data("id")
+        }
+      }
+    } else {
+      max_levels = 1;
+      tab_hack = 99999;
+
+      getData = function(item) {
+        return $this.nestedSortable("serialize")
+      }
+    }
+
+    $this.nestedSortable({
+      forcePlaceholderSize: true,
+      forceHelperSizeType: true,
+      errorClass: 'cantdoit',
+      disableNesting: 'cantdoit',
+      handle: '> .item',
+      listType: 'ol',
+      items: 'li',
+      opacity: .6,
+      placeholder: 'placeholder',
+      revert: 250,
+      maxLevels: max_levels,
+      tabSize: tab_hack,
+      protectRoot: $this.data('protect-root'),
+      tolerance: 'pointer',
+      toleranceElement: '> div',
+      isTree: true,
+      startCollapsed: $this.data("start-collapsed"),
+      update: function(event, ui) {
+        $this.nestedSortable("disable");
+        $.ajax({
+          url: $this.data("sortable-url"),
+          type: "post",
+          data: getData(ui.item)
+        }).always(function() {
+          $this.find('.item').each(function(index) {
+            if (index % 2) {
+              $(this).removeClass('odd').addClass('even');
+            } else {
+              $(this).removeClass('even').addClass('odd');
+            }
+          });
+          $this.nestedSortable("enable");
+          ActiveAdminSortableEvent.trigger('ajaxAlways');
+        }).done(function() {
+          ActiveAdminSortableEvent.trigger('ajaxDone');
+        }).fail(function() {
+          ActiveAdminSortableEvent.trigger('ajaxFail');
+        });
+      }
+    });
+  });
+});
+