alchemy_cms 2.8.2 → 2.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c340c7f6e2a90471d1b5772227b1498b37859249
-  data.tar.gz: 450b8d1a217f9deaecabab868405f5c4a9457df7
+  metadata.gz: bc35e337330b8a45d9a53897d1ec6f9377bce876
+  data.tar.gz: 7a100feddc7fb1094fc0dadadd1b6c9530d0e251
 SHA512:
-  metadata.gz: fa4fec08b37e3fe38aa3c3b0ddc10458007b1621299734c8ad8071849de679b0a08b5d33c0989198cff1321106c94be6cebe2560ceabb6ea721b5fb15c5750d2
-  data.tar.gz: adbccc24de430ef03733e08d179f2528f7cb947cdb363c17a8b66b6aa7dd5a0bd2e1961aedf205f249d74cc00d7f1f64c519395d2d733029dc3456b078232fd3
+  metadata.gz: b8c7b30d537f2b948f7bc9af5ef0fd1e9830b2046fc474a22b4c0c228de101871ac183ec79f414eb00b35aa2c179c49449568db1d40b177af8d7f7ec748211db
+  data.tar.gz: 63502e6354cdeae1f48e4f5aa47ccdc9c40152fdf862bfa5f94831bc0c1b1f93099d23d3a2e6afa7480b5101c678b58e2f8821f95ad45d6aa5e69ea48f10df74

data/app/controllers/alchemy/admin/pages_controller.rb

@@ -200,17 +200,19 @@ module Alchemy
         @sorting = true
       end
 
+      # Receives a JSON object representing a language tree to be ordered
+      # and updates all pages in that language structure to their correct indexes
       def order
-        @page_root = Page.language_root_for(session[:language_id])
-
-        # Taken from https://github.com/matenia/jQuery-Awesome-Nested-Set-Drag-and-Drop
         neworder = JSON.parse(params[:set])
-        prev_item = nil
-        neworder.each do |item|
-          dbitem = Page.find(item['id'])
-          prev_item.nil? ? dbitem.move_to_child_of(@page_root) : dbitem.move_to_right_of(prev_item)
-          sort_children(item, dbitem) unless item['children'].nil?
-          prev_item = dbitem.reload
+        rootpage = Page.language_root_for(session[:language_id])
+
+        tree = create_tree(neworder, rootpage)
+
+        Alchemy::Page.transaction do
+          tree.each do |key, node|
+            dbitem = Page.find(key)
+            dbitem.update_node!(node)
+          end
         end
 
         flash[:notice] = _t("Pages order saved")
@@ -240,6 +242,85 @@ module Alchemy
 
       private
 
+      # Returns the current left index and the aggregated hash of tree nodes indexed by page id visited so far
+      #
+      # Visits a batch of children nodes, assigns them the correct ordering indexes and spuns recursively the same
+      # procedure on their children, if any
+      #
+      # @param [Array]
+      #   An array of children nodes to be visited
+      # @param [Integer]
+      #   The lft attribute that should be given to the first node in the array
+      # @param [Integer]
+      #   The page id of the parent of this batch of children nodes
+      # @param [Integer]
+      #   The depth at which these children reside
+      # @param [Hash]
+      #   A Hash of TreeNode's indexed by their page ids
+      # @param [String]
+      #   The url for the parent node of these children
+      # @param [Boolean]
+      #   Whether these children reside in a restricted branch according to their ancestors
+      #
+      def visit_nodes(nodes, my_left, parent, depth, tree, url, restricted)
+        nodes.each do |item|
+          my_right = my_left + 1
+          my_restricted = item['restricted'] || restricted
+          urls = process_url(url, item)
+
+          if item['children']
+            my_right, tree = visit_nodes(item['children'], my_left + 1, item['id'], depth + 1, tree, urls[:children_path], my_restricted)
+          end
+
+          tree[item['id']] = TreeNode.new(my_left, my_right, parent, depth, urls[:my_urlname], my_restricted)
+          my_left = my_right + 1
+        end
+
+        [my_left, tree]
+      end
+
+      # Returns a Hash of TreeNode's indexed by their page ids
+      #
+      # Grabs the array representing a tree structure of pages passed as a parameter,
+      # visits it and creates a map of TreeNodes indexed by page id featuring Nested Set
+      # ordering information consisting of the left, right, depth and parent_id indexes as
+      # well as a node's url and restricted status
+      #
+      # @param [Array]
+      #   An Array representing a tree of Alchemy::Page's
+      # @param [Alchemy::Page]
+      #   The root page for the language being ordered
+      #
+      def create_tree(items, rootpage)
+        _, tree = visit_nodes(items, rootpage.lft + 1, rootpage.id, rootpage.depth + 1, {}, "", rootpage.restricted)
+        tree
+      end
+
+      # Returns a pair, the path that a given tree node should take, and the path its children should take
+      #
+      # This function will add a node's own slug into their ancestor's path
+      # in order to create the full URL of a node
+      #
+      # NOTE: external and invisible pages are not part of the full path of their children
+      #
+      # @param [String]
+      #   The node's ancestors path
+      # @param [Hash]
+      #   A children node
+      #
+      def process_url(ancestors_path, item)
+        default_urlname = (ancestors_path.blank? ? "" : "#{ancestors_path}/") + item['slug']
+
+        pair = {my_urlname: default_urlname, children_path: default_urlname}
+
+        if item['external'] == true || item['visible'] == false
+          # children ignore an ancestor in their path if external or invisible
+          pair[:children_path] = ancestors_path
+        end
+
+        pair
+      end
+
       def load_page
         @page = Page.find(params[:id])
       end
@@ -248,17 +329,6 @@ module Alchemy
         request.raw_post.split('&').map { |i| i = {i.split('=')[0].gsub(/[^0-9]/, '') => i.split('=')[1]} }
       end
 
-      # Taken from https://github.com/matenia/jQuery-Awesome-Nested-Set-Drag-and-Drop
-      def sort_children(element, dbitem)
-        prevchild = nil
-        element['children'].each do |child|
-          childitem = Page.find(child['id'])
-          prevchild.nil? ? childitem.move_to_child_of(dbitem) : childitem.move_to_right_of(prevchild)
-          sort_children(child, childitem) unless child['children'].nil?
-          prevchild = childitem
-        end
-      end
-
       def redirect_path_after_page_create
         if @page.redirects_to_external?
           admin_pages_path

data/app/models/alchemy/page.rb

@@ -298,6 +298,25 @@ module Alchemy
       set_language_code
     end
 
+    # Updates an Alchemy::Page based on a new ordering to be applied to it
+    #
+    # Note: Page's urls should not be updated (and a legacy URL created) if nesting is OFF
+    # or if a page is external or if the URL is the same
+    #
+    # @param [TreeNode]
+    #   A tree node with new lft, rgt, depth, url, parent_id and restricted indexes to be updated
+    #
+    def update_node!(node)
+      hash = {lft: node.left, rgt: node.right, parent_id: node.parent, depth: node.depth, restricted: node.restricted}
+
+      if Config.get(:url_nesting) && !self.redirects_to_external? && self.urlname != node.url
+        LegacyPageUrl.create(page_id: self.id, urlname: self.urlname)
+        hash.merge!(urlname: node.url)
+      end
+
+      self.class.update_all(hash, {id: self.id})
+    end
+
   private
 
     # Returns the next or previous page on the same level or nil.

data/app/models/alchemy/page/natures.rb

@@ -27,7 +27,7 @@ module Alchemy
 
     # Returns true or false if the pages layout_description for config/alchemy/page_layouts.yml contains redirects_to_external: true
     def redirects_to_external?
-      definition["redirects_to_external"]
+      !!definition["redirects_to_external"]
     end
 
     def has_controller?

data/app/models/alchemy/tree_node.rb

@@ -0,0 +1,4 @@
+module Alchemy
+  class TreeNode < Struct.new(:left, :right, :parent, :depth, :url, :restricted)
+  end
+end

data/app/views/alchemy/admin/pages/_page.html.erb

@@ -1,4 +1,4 @@
-<li id="page_<%= page.id %>" class="page_level_<%= "#{page.level} #{page.page_layout}" %>">
+<li id="page_<%= page.id %>" class="page_level_<%= "#{page.level} #{page.page_layout}" %>" data-slug="<%= page.slug %>" data-restricted="<%= page.restricted? %>" data-visible="<%= page.visible? %>" data-external="<%= page.redirects_to_external? %>">
   <div class="sitemap_page<%= page.locked ? ' locked' : '' %>" name="<%= page.name %>">
     <div class="sitemap_left_images">
       <%= sitemap_folder_link(page) unless page.level == 1 || page.children.blank? || @sorting %>

data/lib/alchemy/version.rb

@@ -1,6 +1,6 @@
 module Alchemy
 
-  VERSION = "2.8.2"
+  VERSION = "2.8.3"
 
   def self.version
     VERSION

data/spec/controllers/admin/pages_controller_spec.rb

@@ -55,6 +55,95 @@ module Alchemy
       end
     end
 
+    describe '#order' do
+      let(:page_1)       { FactoryGirl.create(:page, visible: true) }
+      let(:page_2)       { FactoryGirl.create(:page, visible: true) }
+      let(:page_3)       { FactoryGirl.create(:page, visible: true) }
+      let(:page_item_1)  { {id: page_1.id, slug: page_1.slug, restricted: false, external: page_1.redirects_to_external?, visible: page_1.visible?, children: [page_item_2]} }
+      let(:page_item_2)  { {id: page_2.id, slug: page_2.slug, restricted: false, external: page_2.redirects_to_external?, visible: page_2.visible?, children: [page_item_3]} }
+      let(:page_item_3)  { {id: page_3.id, slug: page_3.slug, restricted: false, external: page_3.redirects_to_external?, visible: page_3.visible? } }
+      let(:set_of_pages) { [page_item_1] }
+
+      it "stores the new order" do
+        xhr :post, :order, set: set_of_pages.to_json
+        page_1.reload
+        expect(page_1.descendants).to eq([page_2, page_3])
+      end
+
+      context 'with url nesting enabled' do
+        before { Alchemy::Config.stub(get: true) }
+
+        it "updates the pages urlnames" do
+          xhr :post, :order, set: set_of_pages.to_json
+          [page_1, page_2, page_3].map(&:reload)
+          expect(page_1.urlname).to eq("#{page_1.slug}")
+          expect(page_2.urlname).to eq("#{page_1.slug}/#{page_2.slug}")
+          expect(page_3.urlname).to eq("#{page_1.slug}/#{page_2.slug}/#{page_3.slug}")
+        end
+
+        context 'with invisible page in tree' do
+          let(:page_item_2) do
+            {
+              id: page_2.id,
+              slug: page_2.slug,
+              children: [page_item_3],
+              visible: false
+            }
+          end
+
+          it "does not use this pages slug in urlnames of descendants" do
+            xhr :post, :order, set: set_of_pages.to_json
+            [page_1, page_2, page_3].map(&:reload)
+            expect(page_1.urlname).to eq("#{page_1.slug}")
+            expect(page_2.urlname).to eq("#{page_1.slug}/#{page_2.slug}")
+            expect(page_3.urlname).to eq("#{page_1.slug}/#{page_3.slug}")
+          end
+        end
+
+        context 'with external page in tree' do
+          let(:page_item_2) do
+            {
+              id: page_2.id,
+              slug: page_2.slug,
+              children: [page_item_3],
+              external: true
+            }
+          end
+
+          it "does not use this pages slug in urlnames of descendants" do
+            xhr :post, :order, set: set_of_pages.to_json
+            [page_1, page_2, page_3].map(&:reload)
+            expect(page_3.urlname).to eq("#{page_1.slug}/#{page_3.slug}")
+          end
+        end
+
+        context 'with restricted page in tree' do
+          let(:page_2) { FactoryGirl.create(:page, restricted: true) }
+          let(:page_item_2) do
+            {
+              id: page_2.id,
+              slug: page_2.slug,
+              children: [page_item_3],
+              restricted: true
+            }
+          end
+
+          it "updates restricted status of descendants" do
+            xhr :post, :order, set: set_of_pages.to_json
+            page_3.reload
+            expect(page_3.restricted).to be_true
+          end
+        end
+
+        it "creates legacy urls" do
+          xhr :post, :order, set: set_of_pages.to_json
+          [page_2, page_3].map(&:reload)
+          expect(page_2.legacy_urls.size).to eq(1)
+          expect(page_3.legacy_urls.size).to eq(1)
+        end
+      end
+    end
+
     describe "#configure" do
       render_views
 

data/spec/models/page_spec.rb

@@ -1117,6 +1117,124 @@ module Alchemy
       end
     end
 
+    describe "#update_node!" do
+
+      let(:original_url) { "sample-url" }
+      let(:page) { FactoryGirl.create(:page, :language => language, :parent_id => language_root.id, :urlname => original_url, restricted: false) }
+      let(:node) { TreeNode.new(10, 11, 12, 13, "another-url", true) }
+
+      context "when nesting is enabled" do
+        before { Alchemy::Config.stub(:get).with(:url_nesting) { true } }
+
+        context "when page is not external" do
+
+          before { page.stub(redirects_to_external?: false)}
+
+          it "should update all attributes" do
+            page.update_node!(node)
+            page.reload
+            expect(page.lft).to eq(node.left)
+            expect(page.rgt).to eq(node.right)
+            expect(page.parent_id).to eq(node.parent)
+            expect(page.depth).to eq(node.depth)
+            expect(page.urlname).to eq(node.url)
+            expect(page.restricted).to eq(node.restricted)
+          end
+
+          context "when url is the same" do
+            let(:node) { TreeNode.new(10, 11, 12, 13, original_url, true) }
+
+            it "should not create a legacy url" do
+              page.update_node!(node)
+              page.reload
+              expect(page.legacy_urls.size).to eq(0)
+            end
+          end
+
+          context "when url is not the same" do
+            it "should create a legacy url" do
+              page.update_node!(node)
+              page.reload
+              expect(page.legacy_urls.size).to eq(1)
+            end
+          end
+        end
+
+        context "when page is external" do
+
+          before { page.stub(redirects_to_external?: true) }
+
+          it "should update all attributes except url" do
+            page.update_node!(node)
+            page.reload
+            expect(page.lft).to eq(node.left)
+            expect(page.rgt).to eq(node.right)
+            expect(page.parent_id).to eq(node.parent)
+            expect(page.depth).to eq(node.depth)
+            expect(page.urlname).to eq(original_url)
+            expect(page.restricted).to eq(node.restricted)
+          end
+
+          it "should not create a legacy url" do
+            page.update_node!(node)
+            page.reload
+            expect(page.legacy_urls.size).to eq(0)
+          end
+        end
+      end
+
+      context "when nesting is disabled" do
+        before { Alchemy::Config.stub(:get).with(:url_nesting) { false } }
+
+        context "when page is not external" do
+
+          before { page.stub(redirects_to_external?: false)}
+
+          it "should update all attributes except url" do
+            page.update_node!(node)
+            page.reload
+            expect(page.lft).to eq(node.left)
+            expect(page.rgt).to eq(node.right)
+            expect(page.parent_id).to eq(node.parent)
+            expect(page.depth).to eq(node.depth)
+            expect(page.urlname).to eq(original_url)
+            expect(page.restricted).to eq(node.restricted)
+          end
+
+          it "should not create a legacy url" do
+            page.update_node!(node)
+            page.reload
+            expect(page.legacy_urls.size).to eq(0)
+          end
+
+        end
+
+        context "when page is external" do
+
+          before { page.stub(redirects_to_external?: true) }
+
+          before { Alchemy::Config.stub(get: true) }
+
+          it "should update all attributes except url" do
+            page.update_node!(node)
+            page.reload
+            expect(page.lft).to eq(node.left)
+            expect(page.rgt).to eq(node.right)
+            expect(page.parent_id).to eq(node.parent)
+            expect(page.depth).to eq(node.depth)
+            expect(page.urlname).to eq(original_url)
+            expect(page.restricted).to eq(node.restricted)
+          end
+
+          it "should not create a legacy url" do
+            page.update_node!(node)
+            page.reload
+            expect(page.legacy_urls.size).to eq(0)
+          end
+        end
+      end
+    end
+
     describe '#slug' do
       context "with parents path saved in urlname" do
         let(:page) { FactoryGirl.build(:page, urlname: 'root/parent/my-name')}

data/vendor/assets/javascripts/jquery_plugins/jquery.ui.nestedSortable.js

@@ -255,8 +255,14 @@
 
       function _recursiveItems(li) {
         var id = ($(li).attr(o.attribute || 'id') || '').match(o.expression || (/(.+)[-=_](.+)/));
+
+        var restricted = $(li).data("restricted");
+        var slug = $(li).data("slug");
+        var external = $(li).data("external");
+        var visible = $(li).data("visible");
+
         if (id) {
-          var item = {"id":id[2]};
+          var item = {"id": id[2], "slug": slug, "restricted": restricted, "external": external, "visible": visible};
           if ($(li).children(o.listType).children('li').length > 0) {
             item.children = [];
             $(li).children(o.listType).children('li').each(function () {
@@ -391,4 +397,4 @@
   }));
 
   $.ui.nestedSortable.prototype.options = $.extend({}, $.ui.sortable.prototype.options, $.ui.nestedSortable.prototype.options);
-})(jQuery);
+})(jQuery);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alchemy_cms
 version: !ruby/object:Gem::Version
-  version: 2.8.2
+  version: 2.8.3
 platform: ruby
 authors:
 - Thomas von Deyen
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-26 00:00:00.000000000 Z
+date: 2014-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -551,6 +551,7 @@ files:
 - app/models/alchemy/site.rb
 - app/models/alchemy/site/layout.rb
 - app/models/alchemy/tag.rb
+- app/models/alchemy/tree_node.rb
 - app/models/alchemy/user.rb
 - app/sweepers/alchemy/content_sweeper.rb
 - app/sweepers/alchemy/pages_sweeper.rb