alchemy_cms 2.7.4 → 2.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec39e6f9f8433170bdf6cfa12566eded64cc8970
-  data.tar.gz: 79ae67d762d97a743c584a0bd5e1d2df47ff56a0
+  metadata.gz: 491ad71e83bcd6aaaeb4f79f9c696982ea8c8112
+  data.tar.gz: 64c210c6d964efa046475945ede684ecf3e626ed
 SHA512:
-  metadata.gz: 36f7ce8de540fdb2d2830be679ac0215e6d16115342653ad83cb8ae84a0589d3b78b3e46d01ad3da7c413bb6cd4a78d6d326402a4e2001e57515510c7e6ba304
-  data.tar.gz: 3c1d7a9aab4b031126c5113deb889d7f7c12ac54e2d22e422bb0761bb7538f914a7b7983df534bb0ed454d4b9f460e518dfb24ca70a548e2da0639bbb721ae4d
+  metadata.gz: be1fe2cef675009c89d8f1a70f6b8b90ded20c81e91e74c0619347e9d7047d73da29683391d8512281147a7a71d0a88b3dbd840b94c5a0427814ada8eb9fb1a0
+  data.tar.gz: 91beddf874b48a4f4b761a5952c73a18059e5b355d0e28b417d8a34c1a4c61fda2f20e18369ee13488c2521555b3ddd8f9fb1c139b09f14d750d6402e6aba36c

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,5 +1,5 @@
 module Alchemy
-  VERSION = "2.7.4"
+  VERSION = "2.7.5"
 
   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.7.4
+  version: 2.7.5
 platform: ruby
 authors:
 - Thomas von Deyen
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-27 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