alula 0.2.3 → 0.4.0b

data/test/test_post.rb

@@ -0,0 +1,123 @@
+require "minitest_helper"
+require 'alula/contents/post'
+require 'alula/config'
+require 'alula/storage'
+
+describe Alula::Content::Post do
+  before do
+    @site = MiniTest::Mock.new
+    @site.expect :context, {}
+    @site.expect :config, OpenStruct.new({
+      permalinks: "/:year/:month/:title/",
+      pagelinks: "/:locale/:slug/",
+      locale: "en", hides_base_locale: true,
+    })
+  end
+  
+  def mock_item(name)
+    item = MiniTest::Mock.new
+    item.expect :nil?, false
+    item.expect :exists?, File.exists?("test/fixtures/posts/#{name}")
+    item.expect :name, name
+    if File.exists?("test/fixtures/posts/#{name}")
+      item.expect :has_payload?, File.read("test/fixtures/posts/#{name}", 3) == "---"
+      item.expect :read, File.read("test/fixtures/posts/#{name}")
+    end
+
+    item
+  end
+    
+  let :missing_post do
+    mock_item("invalid.file")
+  end
+  
+  let :simple_post do
+    mock_item("2012-07-02-simple.markdown")
+  end
+  
+  let :metadata_post do
+    mock_item("2012-07-03-full-metadata.markdown")
+  end
+  
+  let :invalid_post do
+    mock_item("2012-07-02-invalid-post.markdown")
+  end
+  
+  let :complex_post do
+    mock_item("2012-07-03-multilingual-full-metadata.markdown")
+  end
+  
+  it "fails with non-existing file" do
+    post = Alula::Content::Post.load(item: missing_post, site: @site)
+    post.must_be_nil
+  end
+  
+  it "skips invalid post" do
+    post = Alula::Content::Post.load(item: invalid_post, site: @site)
+  end
+  
+  it "parses simple post" do
+    post = Alula::Content::Post.load(item: simple_post, site: @site)
+    post.metadata.title.must_equal "Simple Post"
+    post.metadata.languages.must_be_nil
+    
+    # Parse and render
+    post.send(:parse_liquid).must_equal "# Header\n\nThis is a simple post.\n"
+    post.send(:parse_markdown).must_equal "<h1>Header</h1>\n\n<p>This is a simple post.</p>\n"
+    
+    # Path and URI must be correct
+    post.path.must_equal "/2012/07/simple-post/index.html"
+    post.url.must_equal "/2012/07/simple-post/"
+  end
+  
+  it "parses full metadata post" do
+    post = Alula::Content::Post.load(item: metadata_post, site: @site)
+    post.url.must_equal "/blog/path/to/long/nonce/to/get/nonce/"
+    post.path.must_equal "/blog/path/to/long/nonce/to/get/nonce/index.html"
+  end
+  
+  it "parses complex post" do
+    @site.config.permalinks = "/:locale/:year/:month/:title/"
+    @site.config.locale = "en"
+    @site.config.hides_base_locale = true
+    
+    post = Alula::Content::Post.load(item: complex_post, site: @site)
+    post.metadata.title.must_equal "Multilingual Post"
+    post.metadata.languages.must_equal ["en", "fi"]
+    post.metadata.title("fi").must_equal "Monikielinen kirjoitelma"
+    
+    post.url.must_equal "/2012/07/multilingual-post/"
+    post.url("fi").must_equal "/fi/2012/07/monikielinen-kirjoitelma/"
+    
+    @site.config.hides_base_locale = false
+    post = Alula::Content::Post.load(item: complex_post, site: @site)
+    post.url.must_equal "/en/2012/07/multilingual-post/"
+    
+    @site.config.permalinks = "/:locale/:year/:slug"
+    post = Alula::Content::Post.load(item: complex_post, site: @site)
+    post.url("fi").must_equal "/fi/2012/monikielinen-blogi-kirjoitelma.html"
+    post.path("fi").must_equal "/fi/2012/monikielinen-blogi-kirjoitelma.html"
+  end
+  
+  it "renders content on simple post" do
+    # Create mockup layout
+    view = MiniTest::Mock.new
+    view.expect :render, "<h1>Header</h1>", [{}]
+    
+    layout = MiniTest::Mock.new
+    
+    theme = MiniTest::Mock.new
+    theme.expect :view, view, ["post"]
+    
+    site = MiniTest::Mock.new
+    site.expect :context, {}
+    site.expect :config, OpenStruct.new({locale: "en"})
+    site.expect :theme, theme
+    post = Alula::Content::Post.load(item: simple_post, site: site)
+    
+    # Render page using current layout, for all languages
+    post.render
+    post.content.must_equal "<h1>Header</h1>"
+    
+  end
+end

data/test/test_storage.rb

@@ -0,0 +1,23 @@
+require "minitest_helper"
+require 'alula/storage'
+require 'ostruct'
+
+describe "Storage" do
+  before do
+    @site = MiniTest::Mock.new
+    @site.expect :config, OpenStruct.new({})
+  end
+  
+  it "loads proper provider" do
+    puts ":: #{@site.config.storage.inspect}"
+    @site.config.storage = {"none" => {}}
+    storage = Alula::Storage.load(site: @site)
+    storage.must_be_nil
+    
+    @site.config.storage = {"file" => { "content_path" => 'test/fixtures', "pages_path" => 'test/fixtures/pages',
+      "posts_path" => 'test/fixtures/posts', "attachments_path" => 'test/fixtures/attachments', "public_path" => 'public' }}
+    storage = Alula::Storage.load(site: @site)
+    storage.wont_be_nil
+    
+  end
+end

data/test/test_storage_file.rb

@@ -0,0 +1,32 @@
+require "minitest_helper"
+require 'alula/storages/file'
+require 'ostruct'
+
+describe "File Storage" do
+  before do
+    @site = MiniTest::Mock.new
+    @config = {
+      "content_path"      => 'test/fixtures',
+      "pages_path"        => 'test/fixtures/pages',
+      "posts_path"        => 'test/fixtures/posts',
+      "attachments_path"  => 'test/fixtures/attachments',
+      "public_path"       => 'public',
+      }
+  end
+  
+  it "accept simple configuration" do
+    storage = Alula::Storage::File.new(@config, site: @site)
+  end
+  
+  it "lists all posts" do
+    storage = Alula::Storage::File.new(@config, site: @site)
+    storage.posts.count.must_equal 4
+    storage.post("2012-07-02-simple.markdown").wont_be_nil
+  end
+  
+  it "list all pages" do
+    storage = Alula::Storage::File.new(@config, site: @site)
+    storage.pages.count.must_equal 4
+    storage.page("simple-page.markdown").wont_be_nil
+  end
+end

data/test/test_theme.rb

@@ -0,0 +1,45 @@
+require "minitest_helper"
+require 'alula/theme'
+require 'ostruct'
+
+describe "Themes" do
+  before do
+    context = Object.new
+    context.class.class_eval do
+      def initialize; @vars = {}; end
+      def [](key); @vars[key]; end
+      def []=(key, val); @vars[key] = val; end
+      def method_missing(meth, *args, &blk); return @vars[meth] if @vars; super; end
+    end
+
+    @site = MiniTest::Mock.new
+    @site.expect :config, OpenStruct.new({theme: 'test'})
+    @site.expect :context, context
+
+    # Register our theme
+    Alula::Theme.register(:test, "test/fixtures/theme")
+  end
+  
+  it "doesn't load nonexisting theme" do
+    @site.config.theme = "unknown"
+    theme = Alula::Theme.load(site: @site)
+    theme.must_be_nil
+  end
+  
+  it "has working theme" do
+    @site.config.theme = "test"
+    theme = Alula::Theme.load(site: @site)
+    theme.wont_be_nil
+    
+    # Find layout
+    layout = theme.layout("default")
+    layout.wont_be_nil
+    
+    # Find view
+    view = theme.view("post")
+    view.wont_be_nil
+    
+    # Test rendering
+    view.render(content: "Theme Test").must_equal "<html><body><p>Theme Test</p></body></html>"
+  end
+end

data/vendor/assets/javascripts/jquery.alula.js.coffee

@@ -0,0 +1,16 @@
+#=require jquery
+#
+# Copyright Owl Forstry
+# Alula JavaScript additions
+
+# Make sure we have devicePixelRatio always available
+jQuery.getDevicePixelRatio = ->
+		if window.devicePixelRatio is undefined
+			return 1
+		else
+			return window.devicePixelRatio
+
+# Hide mobile Safari address bar
+jQuery ->
+	delay = (ms, func) -> setTimeout func, ms
+	delay 0, -> window.scrollTo(0, 1)

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

@@ -0,0 +1,210 @@
+/*
+ * Lazy Load - jQuery plugin for lazy loading images
+ *
+ * Copyright (c) 2007-2012 Mika Tuupola
+ *
+ * Licensed under the MIT license:
+ *   http://www.opensource.org/licenses/mit-license.php
+ *
+ * Project home:
+ *   http://www.appelsiini.net/projects/lazyload
+ *
+ * Version:  1.7.2
+ *
+ */
+(function($, window) {
+
+    $window = $(window);
+
+    $.fn.lazyload = function(options) {
+        var elements = this;
+        var settings = {
+            threshold       : 0,
+            failure_limit   : 0,
+            event           : "scroll",
+            effect          : "show",
+            container       : window,
+            data_attribute  : "original",
+            skip_invisible  : true,
+            appear          : null,
+            load            : null
+        };
+
+        function update() {
+            var counter = 0;
+      
+            elements.each(function() {
+                var $this = $(this);
+                if (settings.skip_invisible && !$this.is(":visible")) {
+                    return;
+                }
+                if ($.abovethetop(this, settings) ||
+                    $.leftofbegin(this, settings)) {
+                        /* Nothing. */
+                } else if (!$.belowthefold(this, settings) &&
+                    !$.rightoffold(this, settings)) {
+                        $this.trigger("appear");
+                } else {
+                    if (++counter > settings.failure_limit) {
+                        return false;
+                    }
+                }
+            });
+
+        }
+
+        if(options) {
+            /* Maintain BC for a couple of versions. */
+            if (undefined !== options.failurelimit) {
+                options.failure_limit = options.failurelimit; 
+                delete options.failurelimit;
+            }
+            if (undefined !== options.effectspeed) {
+                options.effect_speed = options.effectspeed; 
+                delete options.effectspeed;
+            }
+
+            $.extend(settings, options);
+        }
+
+        /* Cache container as jQuery as object. */
+        $container = (settings.container === undefined ||
+                      settings.container === window) ? $window : $(settings.container);
+
+        /* Fire one scroll event per scroll. Not one scroll event per image. */
+        if (0 === settings.event.indexOf("scroll")) {
+            $container.bind(settings.event, function(event) {
+                return update();
+            });
+        }
+
+        this.each(function() {
+            var self = this;
+            var $self = $(self);
+
+            self.loaded = false;
+
+            /* When appear is triggered load original image. */
+            $self.one("appear", function() {
+                if (!this.loaded) {
+                    if (settings.appear) {
+                        var elements_left = elements.length;
+                        settings.appear.call(self, elements_left, settings);
+                    }
+                    $("<img />")
+                        .bind("load", function() {
+                            $self
+                                .hide()
+                                .attr("src", $self.data(settings.data_attribute))
+                                [settings.effect](settings.effect_speed);
+                            self.loaded = true;
+
+                            /* Remove image from array so it is not looped next time. */
+                            var temp = $.grep(elements, function(element) {
+                                return !element.loaded;
+                            });
+                            elements = $(temp);
+
+                            if (settings.load) {
+                                var elements_left = elements.length;
+                                settings.load.call(self, elements_left, settings);
+                            }
+                        })
+                        .attr("src", $self.data(settings.data_attribute));
+                }
+            });
+
+            /* When wanted event is triggered load original image */
+            /* by triggering appear.                              */
+            if (0 !== settings.event.indexOf("scroll")) {
+                $self.bind(settings.event, function(event) {
+                    if (!self.loaded) {
+                        $self.trigger("appear");
+                    }
+                });
+            }
+        });
+
+        /* Check if something appears when window is resized. */
+        $window.bind("resize", function(event) {
+            update();
+        });
+
+        /* Force initial check if images should appear. */
+        update();
+        
+        return this;
+    };
+
+    /* Convenience methods in jQuery namespace.           */
+    /* Use as  $.belowthefold(element, {threshold : 100, container : window}) */
+
+    $.belowthefold = function(element, settings) {
+        var fold;
+        
+        if (settings.container === undefined || settings.container === window) {
+            fold = $window.height() + $window.scrollTop();
+        } else {
+            fold = $container.offset().top + $container.height();
+        }
+
+        return fold <= $(element).offset().top - settings.threshold;
+    };
+    
+    $.rightoffold = function(element, settings) {
+        var fold;
+
+        if (settings.container === undefined || settings.container === window) {
+            fold = $window.width() + $window.scrollLeft();
+        } else {
+            fold = $container.offset().left + $container.width();
+        }
+
+        return fold <= $(element).offset().left - settings.threshold;
+    };
+        
+    $.abovethetop = function(element, settings) {
+        var fold;
+        
+        if (settings.container === undefined || settings.container === window) {
+            fold = $window.scrollTop();
+        } else {
+            fold = $container.offset().top;
+        }
+
+        return fold >= $(element).offset().top + settings.threshold  + $(element).height();
+    };
+    
+    $.leftofbegin = function(element, settings) {
+        var fold;
+        
+        if (settings.container === undefined || settings.container === window) {
+            fold = $window.scrollLeft();
+        } else {
+            fold = $container.offset().left;
+        }
+
+        return fold >= $(element).offset().left + settings.threshold + $(element).width();
+    };
+
+    $.inviewport = function(element, settings) {
+         return !$.rightofscreen(element, settings) && !$.leftofscreen(element, settings) && 
+                !$.belowthefold(element, settings) && !$.abovethetop(element, settings);
+     };
+
+    /* Custom selectors for your convenience.   */
+    /* Use as $("img:below-the-fold").something() */
+
+    $.extend($.expr[':'], {
+        "below-the-fold" : function(a) { return $.belowthefold(a, {threshold : 0, container: window}); },
+        "above-the-top"  : function(a) { return !$.belowthefold(a, {threshold : 0, container: window}); },
+        "right-of-screen": function(a) { return $.rightoffold(a, {threshold : 0, container: window}); },
+        "left-of-screen" : function(a) { return !$.rightoffold(a, {threshold : 0, container: window}); },
+        "in-viewport"    : function(a) { return !$.inviewport(a, {threshold : 0, container: window}); },
+        /* Maintain BC for couple of versions. */
+        "above-the-fold" : function(a) { return !$.belowthefold(a, {threshold : 0, container: window}); },
+        "right-of-fold"  : function(a) { return $.rightoffold(a, {threshold : 0, container: window}); },
+        "left-of-fold"   : function(a) { return !$.rightoffold(a, {threshold : 0, container: window}); }
+    });
+
+})(jQuery, window);