amalgam 2.1.1

data/spec/rule_spec.rb

@@ -0,0 +1,129 @@
+#encoding: UTF-8
+require 'spec_helper'
+
+class TestPage < ActiveRecord::Base
+  def self.columns() @columns ||= []; end
+
+  def self.column(name, sql_type = nil, default = nil, null = true)
+    columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
+  end
+
+  acts_as_nested_set :dependent => :destroy
+
+  has_and_belongs_to_many :test_groups
+
+  store :body
+
+  column :slug, :string
+  column :body, :string
+  column :parent_id, :integer
+  column :lft, :integer
+  column :rgt, :integer
+
+  attr_accessible :slug,:body
+
+  def template_keys
+    keys = []
+    keys << self.slug
+    self.test_groups.each do |g|
+      keys << '@' + g.name
+    end
+    keys
+  end
+end
+
+class TestGroup < ActiveRecord::Base
+  def self.columns() @columns ||= []; end
+
+  def self.column(name, sql_type = nil, default = nil, null = true)
+    columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
+  end
+
+  has_and_belongs_to_many :test_pages
+
+  column :name, :string
+
+  attr_accessible :name
+end
+
+describe Amalgam::TemplateFinder::Rule do
+  before do
+    @rules = Amalgam::TemplateFinder::Rule.load(File.dirname(__FILE__),"test_pages")
+    @rule = Amalgam::TemplateFinder::Rule.new(['slug2@group2'])
+
+    @page = TestPage.new(:slug => 'slug2')
+    @page_group1 = @page.test_groups.new(:name => 'group1')
+    @page_group2 = @page.test_groups.new(:name => 'group2')
+
+    @page1 = TestPage.new(:slug => 'slug3')
+    @page_group1 = @page1.test_groups.new(:name => 'group1')
+    @page_group2 = @page1.test_groups.new(:name => 'group3')
+
+    @page2 = TestPage.new(:slug => 'slug4')
+    @page_group1 = @page2.test_groups.new(:name => 'group1')
+    @page_group2 = @page2.test_groups.new(:name => 'group2')
+
+    @page4 = TestPage.new(:slug => 'slug5')
+
+    @page5 = TestPage.new(:slug => 'slug6')
+
+    @page6 = TestPage.new(:slug => 'slug7')
+
+    @page7 = TestPage.new(:slug => 'slug8')
+    @page7_group1 = @page7.test_groups.new(:name => 'group1')
+
+    @page8 = TestPage.new(:slug => 'slug9')
+
+    @default = TestPage.new(:slug => 'default')
+    @default_l1 = TestPage.new(:slug => 'default_l1')
+    @default_l2 = TestPage.new(:slug => 'default_l2')
+
+    @page9 = TestPage.new(:slug => 'slug10')
+
+    @page10 = TestPage.new(:slug => 'slug11')
+    @page10_group1 = @page10.test_groups.new(:name => 'group10')
+  end
+
+  it "page with groups should has keys" do
+    @page.test_groups.length.should eq(2)
+    @page.template_keys.length.should eq(3)
+    @page.template_keys.should eq ['slug2','@group1','@group2']
+  end
+
+  it "page本身可以唯一定位" do
+    Amalgam::TemplateFinder::Rule.look_up([@page,@page1,@page2]).should eq ["slug2@group1"]
+    Amalgam::TemplateFinder::Rule.look_up([@page1,@page2]).should eq ["@group1"]
+    Amalgam::TemplateFinder::Rule.look_up([@page7]).should eq ["@group1"]
+  end
+
+  it "需要祖先节点同时满足的准确定位" do
+    Amalgam::TemplateFinder::Rule.look_up([@page1,@page2,@page]).should eq ["slug2", "slug3@group3"]
+    Amalgam::TemplateFinder::Rule.look_up([@page2,@page4]).should eq ["slug5", "@group1"]
+  end
+
+  it "在没有自身满足条件，但是存在上级节点的级别限定模板的时候（如:level1）" do
+    Amalgam::TemplateFinder::Rule.look_up([@page4,@page]).should eq ["@group1", "&1"]
+    Amalgam::TemplateFinder::Rule.look_up([@page8,@page2,@page4]).should eq ["@group1", "&1"]
+    Amalgam::TemplateFinder::Rule.look_up([@page8,@page4,@page2]).should eq ["@group1", "&2"]
+  end
+
+  it "在没有自身满足条件，存在祖先节点下的default文件时" do
+    Amalgam::TemplateFinder::Rule.look_up([@page6,@page4,@page5]).should eq ['slug6','default']
+  end
+
+  it "在没有条件满足的情况下，去根目录的default文件夹里的层级结果去找" do
+    Amalgam::TemplateFinder::Rule.look_up([@page5,@page6]).should eq ["default", "&1"]
+    Amalgam::TemplateFinder::Rule.look_up([@default_l2,@default_l1,@default]).should eq ['default','&2']
+  end
+
+  it "在有祖先节点满足的时候，使用祖先节点的模板" do
+    Amalgam::TemplateFinder::Rule.look_up([@page9,@page10]).should eq ["@group10"]
+  end
+
+  it "在没有任何规则满足的情况下，使用根目录的show文件" do
+    Amalgam::TemplateFinder::Rule.look_up([@page9]).should eq ["show"]
+  end
+end
+
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,61 @@
+require 'rubygems'
+require 'spork'
+require 'factory_girl_rails'
+#uncomment the following line to use spork with the debugger
+#require 'spork/ext/ruby-debug'
+
+Spork.prefork do
+  # This file is copied to spec/ when you run 'rails generate rspec:install'
+  ENV["RAILS_ENV"] ||= 'test'
+
+  require 'amalgam'
+  Spork.trap_class_method(Amalgam, :setup)
+
+  require "rails/application"
+  Spork.trap_method(Rails::Application, :eager_load!)
+
+  require File.expand_path("../dummy/config/environment", __FILE__)
+  require 'rspec/rails'
+  require 'rspec/autorun'
+
+  # Requires supporting ruby files with custom matchers and macros, etc,
+  # in spec/support/ and its subdirectories.
+  Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
+
+  RSpec.configure do |config|
+    # ## Mock Framework
+    #
+    # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+    #
+    # config.mock_with :mocha
+    # config.mock_with :flexmock
+    # config.mock_with :rr
+
+    # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+    config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+    # If you're not using ActiveRecord, or you'd prefer not to run each of your
+    # examples within a transaction, remove the following line or assign false
+    # instead of true.
+    config.use_transactional_fixtures = true
+
+    # If true, the base class of anonymous controllers will be inferred
+    # automatically. This will be the default behavior in future versions of
+    # rspec-rails.
+    config.infer_base_class_for_anonymous_controllers = false
+
+    # Run specs in random order to surface order dependencies. If you find an
+    # order dependency and want to debug it, you can fix the order by providing
+    # the seed, which is printed after each run.
+    #     --seed 1234
+    config.order = "random"
+  end
+end
+
+Spork.each_run do
+  FactoryGirl.reload
+  I18n.backend.reload!
+  # Dir["#{Rails.root}/../../lib/amalgam/**/*.rb"].each do |file|
+  #   load file
+  # end
+end

data/spec/support/tree_macro.rb

@@ -0,0 +1,44 @@
+require 'yaml'
+
+module TreeMacros
+
+  def setup_tree(model_class,tree)
+    create_tree(model_class,YAML.load(tree))
+  end
+
+  def nodes(name)
+    @nodes[name].reload
+  end
+
+  def print_tree(node, inspect = false, depth = 0)
+    print '  ' * depth
+    print '- ' unless depth == 0
+    print node.title
+    print " (#{node.inspect})" if inspect
+    print ':' if node.children.any?
+    print "\n"
+    node.children.each { |c| print_tree(c, inspect, depth + 1) }
+  end
+
+private
+  def create_tree(model_class,object)
+    case object
+      when String then return create_node(model_class,object)
+      when Array then object.each { |tree| create_tree(model_class,tree) }
+      when Hash then
+        name, children = object.first
+        node = create_node(model_class,name)
+        children.each { |c| node.children << create_tree(model_class,c) }
+        return node
+    end
+  end
+
+  def create_node(model_class,name)
+    @nodes ||= HashWithIndifferentAccess.new
+    @nodes[name] = model_class.create(:title => name , :slug => name)
+  end
+end
+
+RSpec.configure do |config|
+  config.include TreeMacros
+end

data/vendor/assets/javascripts/jquery.scrollto.js

@@ -0,0 +1,218 @@
+/*!
+ * jQuery scrollintoview() plugin and :scrollable selector filter
+ *
+ * Version 1.8 (14 Jul 2011)
+ * Requires jQuery 1.4 or newer
+ *
+ * Copyright (c) 2011 Robert Koritnik
+ * Licensed under the terms of the MIT license
+ * http://www.opensource.org/licenses/mit-license.php
+ */
+ 
+(function ($) {
+    var converter = {
+        vertical: { x: false, y: true },
+        horizontal: { x: true, y: false },
+        both: { x: true, y: true },
+        x: { x: true, y: false },
+        y: { x: false, y: true }
+    };
+ 
+    var settings = {
+        duration: "fast",
+        direction: "both"
+    };
+ 
+    var rootrx = /^(?:html)$/i;
+ 
+    // gets border dimensions
+    var borders = function (domElement, styles) {
+        styles = styles || (document.defaultView && document.defaultView.getComputedStyle ? document.defaultView.getComputedStyle(domElement, null) : domElement.currentStyle);
+        var px = document.defaultView && document.defaultView.getComputedStyle ? true : false;
+        var b = {
+            top: (parseFloat(px ? styles.borderTopWidth : $.css(domElement, "borderTopWidth")) || 0),
+            left: (parseFloat(px ? styles.borderLeftWidth : $.css(domElement, "borderLeftWidth")) || 0),
+            bottom: (parseFloat(px ? styles.borderBottomWidth : $.css(domElement, "borderBottomWidth")) || 0),
+            right: (parseFloat(px ? styles.borderRightWidth : $.css(domElement, "borderRightWidth")) || 0)
+        };
+        return {
+            top: b.top,
+            left: b.left,
+            bottom: b.bottom,
+            right: b.right,
+            vertical: b.top + b.bottom,
+            horizontal: b.left + b.right
+        };
+    };
+ 
+    var dimensions = function ($element) {
+        var win = $(window);
+        var isRoot = rootrx.test($element[0].nodeName);
+        return {
+            border: isRoot ? { top: 0, left: 0, bottom: 0, right: 0} : borders($element[0]),
+            scroll: {
+                top: (isRoot ? win : $element).scrollTop(),
+                left: (isRoot ? win : $element).scrollLeft()
+            },
+            scrollbar: {
+                right: isRoot ? 0 : $element.innerWidth() - $element[0].clientWidth,
+                bottom: isRoot ? 0 : $element.innerHeight() - $element[0].clientHeight
+            },
+            rect: (function () {
+                var r = $element[0].getBoundingClientRect();
+                return {
+                    top: isRoot ? 0 : r.top,
+                    left: isRoot ? 0 : r.left,
+                    bottom: isRoot ? $element[0].clientHeight : r.bottom,
+                    right: isRoot ? $element[0].clientWidth : r.right
+                };
+            })()
+        };
+    };
+ 
+    $.fn.extend({
+        scrollintoview: function (options) {
+            /// <summary>Scrolls the first element in the set into view by scrolling its closest scrollable parent.</summary>
+            /// <param name="options" type="Object">Additional options that can configure scrolling:
+            ///        duration (default: "fast") - jQuery animation speed (can be a duration string or number of milliseconds)
+            ///        direction (default: "both") - select possible scrollings ("vertical" or "y", "horizontal" or "x", "both")
+            ///        complete (default: none) - a function to call when scrolling completes (called in context of the DOM element being scrolled)
+            /// </param>
+            /// <return type="jQuery">Returns the same jQuery set that this function was run on.</return>
+ 
+            options = $.extend({}, settings, options);
+            options.direction = converter[typeof (options.direction) === "string" && options.direction.toLowerCase()] || converter.both;
+ 
+            var dirStr = "";
+            if (options.direction.x === true) dirStr = "horizontal";
+            if (options.direction.y === true) dirStr = dirStr ? "both" : "vertical";
+ 
+            var el = this.eq(0);
+            var scroller = el.closest(":scrollable(" + dirStr + ")");
+ 
+            // check if there's anything to scroll in the first place
+            if (scroller.length > 0)
+            {
+                scroller = scroller.eq(0);
+ 
+                var dim = {
+                    e: dimensions(el),
+                    s: dimensions(scroller)
+                };
+ 
+                var rel = {
+                    top: dim.e.rect.top - (dim.s.rect.top + dim.s.border.top),
+                    bottom: dim.s.rect.bottom - dim.s.border.bottom - dim.s.scrollbar.bottom - dim.e.rect.bottom,
+                    left: dim.e.rect.left - (dim.s.rect.left + dim.s.border.left),
+                    right: dim.s.rect.right - dim.s.border.right - dim.s.scrollbar.right - dim.e.rect.right
+                };
+ 
+                var animOptions = {};
+ 
+                // vertical scroll
+                if (options.direction.y === true)
+                {
+                    if (rel.top < 0)
+                    {
+                        animOptions.scrollTop = dim.s.scroll.top + rel.top;
+                    }
+                    else if (rel.top > 0 && rel.bottom < 0)
+                    {
+                        animOptions.scrollTop = dim.s.scroll.top + Math.min(rel.top, -rel.bottom);
+                    }
+                }
+ 
+                // horizontal scroll
+                if (options.direction.x === true)
+                {
+                    if (rel.left < 0)
+                    {
+                        animOptions.scrollLeft = dim.s.scroll.left + rel.left;
+                    }
+                    else if (rel.left > 0 && rel.right < 0)
+                    {
+                        animOptions.scrollLeft = dim.s.scroll.left + Math.min(rel.left, -rel.right);
+                    }
+                }
+ 
+                // scroll if needed
+                if (!$.isEmptyObject(animOptions))
+                {
+                    if (rootrx.test(scroller[0].nodeName))
+                    {
+                        scroller = $("html,body");
+                    }
+                    scroller
+                        .animate(animOptions, options.duration)
+                        .eq(0) // we want function to be called just once (ref. "html,body")
+                        .queue(function (next) {
+                            $.isFunction(options.complete) && options.complete.call(scroller[0]);
+                            next();
+                        });
+                }
+                else
+                {
+                    // when there's nothing to scroll, just call the "complete" function
+                    $.isFunction(options.complete) && options.complete.call(scroller[0]);
+                }
+            }
+ 
+            // return set back
+            return this;
+        }
+    });
+ 
+    var scrollValue = {
+        auto: true,
+        scroll: true,
+        visible: false,
+        hidden: false
+    };
+
+    function scrollable(element, index, direction, stack) {
+      var styles = (document.defaultView && document.defaultView.getComputedStyle ? document.defaultView.getComputedStyle(element, null) : element.currentStyle);
+      var overflow = {
+          x: scrollValue[styles.overflowX.toLowerCase()] || false,
+          y: scrollValue[styles.overflowY.toLowerCase()] || false,
+          isRoot: rootrx.test(element.nodeName)
+      };
+
+      // check if completely unscrollable (exclude HTML element because it's special)
+      if (!overflow.x && !overflow.y && !overflow.isRoot)
+      {
+          return false;
+      }
+
+      var size = {
+          height: {
+              scroll: element.scrollHeight,
+              client: element.clientHeight
+          },
+          width: {
+              scroll: element.scrollWidth,
+              client: element.clientWidth
+          },
+          // check overflow.x/y because iPad (and possibly other tablets) don't dislay scrollbars
+          scrollableX: function () {
+              return (overflow.x || overflow.isRoot) && this.width.scroll > this.width.client;
+          },
+          scrollableY: function () {
+              return (overflow.y || overflow.isRoot) && this.height.scroll > this.height.client;
+          }
+      };
+      return direction.y && size.scrollableY() || direction.x && size.scrollableX();
+    }
+
+    $.expr[':'].scrollable = $.expr.createPseudo ?
+    $.expr.createPseudo(function( meta ) {
+      var direction = converter[typeof (meta) === "string" && meta.toLowerCase()] || converter.both;
+      return function( elem) {
+          return scrollable( elem, 0, direction);
+      };
+    }) :
+    function(element, index, meta, stack) {
+      var direction = converter[typeof (meta[3]) === "string" && meta[3].toLowerCase()] || converter.both;
+      return scrollable(element, index, direction, stack);
+    };
+
+})(jQuery);