alula 0.2.3 → 0.4.0b

data/lib/alula/core_ext/tags/image.rb

@@ -0,0 +1,48 @@
+require 'alula/core_ext/tag'
+require 'mini_exiftool'
+require 'hashie/mash'
+
+module Alula
+  class ImageTag < Tag
+    def prepare
+      @info = {}
+
+      @options["classes"] ||= []
+      @options["title"] ||= @options["alternative"]
+      @options["alternative"] ||= @options["title"]
+      @options["classes"] += [@options["align"] || "left"]
+    end
+    
+    def content
+      hires = hires_url(@source, :image)
+      tag = "<a href=\"#{attachment_url(@source, :image)}\""
+      tag += " data-hires=\"#{hires}\"" if context.site.config.attachments["image"]["hires"] and hires
+      tag += ">"
+      tag += imagetag(@source, :thumbnail)
+      tag += "</a>"
+    end
+    
+    def imagetag(source, type, opts = {})
+      src = attachment_url(source, type)
+      hires = hires_url(source, type)
+      
+      classes = opts.delete(:classes) || @options["classes"]
+      
+      tag = "<img"
+      tag += " alt=\"#{@options["alternative"]}\"" if @options["alternative"]
+      tag += " title=\"#{@options["title"]}\"" if @options["title"]
+      tag += " class=\"#{classes.join(" ")}\""
+      if context.site.config.attachments.image.lazyload
+        tag += " src=\"#{asset_url("grey.gif")}\""
+        tag += " data-original=\"#{src}\""
+      else
+        tag += " src=\"#{src}\""
+      end
+      tag += " data-hires=\"#{hires}\"" if context.site.config.attachments.image.hires and hires
+      tag += " width=\"#{info(source, type).width}\" height=\"#{info(source, type).height}\""
+      tag += " />"
+    end
+  end
+end
+
+Alula::Tag.register :image, Alula::ImageTag

data/lib/alula/core_ext/tags/locale.rb

@@ -0,0 +1,17 @@
+module Alula
+  class LocaleTag < Block
+    def prepare
+      @lang = @markup.strip
+    end
+    
+    def render(context)
+      if @lang == context.locale
+        super
+      else
+        ''
+      end
+    end
+  end
+end
+
+Alula::Tag.register :locale, Alula::LocaleTag

data/lib/alula/core_ext/tags/video.rb

@@ -0,0 +1,103 @@
+module Alula
+  class VideoTag < Tag
+    def prepare
+      @info = {}
+
+      @options["classes"] ||= []
+      @options["title"] ||= @options["alternative"]
+      @options["alternative"] ||= @options["title"]
+      @options["classes"] += [@options["align"] || "left"]
+    end
+    
+    def content
+      video_tag(@source)
+    end
+    
+    def video_tag(source)
+      poster = source.gsub(/#{File.extname(source)}$/, '.png')
+      info = info(poster, :thumbnail)
+      poster = attachment_url(poster, :thumbnail)
+      
+      tag = "<video"
+      tag += " controls"
+      tag += " class=\"#{(@options["classes"]).join(" ")}\""
+      tag += " width=\"#{info.width}\""
+      tag += " height=\"#{info.height}\""
+      tag += " poster=\"#{poster}\""
+      tag += " preload=\"none\">"
+      
+      sources.each do |source|
+        tag += "  <source src=\"#{source[:url]}\" #{source[:hires] ? "data-quality=\"hd\"" : ""} />"
+      end
+      
+      tag += "</video>"
+    end
+    
+    private
+    
+    def sources
+      @sources ||= begin
+        variants.collect {|variant|
+          name = @source.gsub(/#{File.extname(@source)}$/, variant[:ext])
+          {
+            name: name,
+            path: attachment_path(name, "video"),
+            url: attachment_url(name, "video"),
+            hires: variant[:hires],
+            mobile: variant[:mobile]
+          }
+        }
+      end
+    end
+    
+    def variants
+      @variants ||= begin
+        # Collect all formats
+        variants = Hash[
+          self.context.site.config.attachments.video.formats.collect { |format|
+            [format, {
+              format: format,
+              mobile: false,
+              hires: false }]
+          }
+        ]
+        # Generate mobile variants?
+        if self.context.site.config.attachments.video.mobile
+          variants.merge!(Hash[ variants.collect {|name, fmt| ["#{name}-mobile", fmt.merge({
+            mobile: true,
+          })] } ])
+        end
+        
+        # Generate HD versions
+        if self.context.site.config.attachments.video.hires
+          variants.merge!(Hash[ variants.collect {|name, fmt| ["#{name}-hires", fmt.merge({
+            hires: true,
+          })] } ])
+        end
+        
+        
+        # Sort by preferred order
+        formats = self.context.site.config.attachments.video.formats
+        variants.sort {|a, b|
+          # Sort by preferred format order
+          c = formats.index(a.last[:format]) <=> formats.index(b.last[:format])
+
+          # Sort HD videos on top
+          c == 0 and c = (a.last[:hires] == b.last[:hires]) ? 0 : (a.last[:hires] ? -1 : 1)
+          
+          # Put mobile low
+          c == 0 and c = (a.last[:mobile] == b.last[:mobile]) ? 0 : (a.last[:mobile] ? 1 : -1)
+          
+          c
+        }.collect{|name, format|
+          ext = (format[:mobile] ? "-mobile" : "") + (format[:hires] ? "-hires" : "") + ".#{format[:format]}"
+
+          {ext: ext, mobile: format[:mobile], hires: format[:hires]}
+        }
+      end
+    end
+    
+  end
+end
+
+Alula::Tag.register :video, Alula::VideoTag

data/lib/alula/generator.rb

@@ -0,0 +1,31 @@
+module Alula
+  class Generator
+    autoload :Paginate, 'alula/generators/paginate'
+    autoload :FeedBuilder, 'alula/generators/feedbuilder'
+    autoload :Sitemap, 'alula/generators/sitemap'
+    
+    attr_reader :options
+    attr_reader :site
+    
+    def self.load(opts)
+      type = opts.delete(:type)
+      options = opts.delete(:options)
+      
+      # Try to find our generator
+      cls_name = self.constants.select {|t| t.to_s.downcase == type.downcase}.first
+      if cls_name
+        cls = self.const_get(cls_name)
+        gen = cls.new(options, opts)
+      end
+    end
+    
+    def initialize(options, opts)
+      @options = options
+      @site = opts.delete(:site)
+    end
+    
+    def substitutes(locale, item)
+      {}
+    end
+  end
+end

data/lib/alula/generators/feedbuilder.rb

@@ -0,0 +1,44 @@
+require 'builder' # As suggested by tilt
+
+module Alula
+  class Generator::FeedBuilder < Generator
+    def generate
+      # Loop all languages and count posts per language
+      @languages = {}
+      self.site.content.posts.each do |post|
+        post.languages.each do |lang|
+          @languages[lang] ||= []
+          @languages[lang] << post
+        end
+      end
+      titles = Hash[@languages.collect {|lang, x| [lang, I18n.t("feedbuilder.recent_posts", locale: lang)]}]
+      posts = Hash[
+        @languages.collect do |lang, posts|
+          [ lang, posts.slice(0, self.options.items) ]
+        end
+      ]
+      
+      @feed_page = Alula::Content::Page.new({
+        generator: self,
+        posts: posts,
+        title: titles,
+        name: "feed.xml",
+        slug: "feed",
+        template: self.options.template || "/:locale/:name",
+        site: self.site,
+        layout: "feed",
+      },
+      :previous => ->(locale) { nil },
+      :next => ->(locale) { nil },
+      :navigation => ->(locale) { nil },
+      )
+      self.site.content.pages << @feed_page
+      
+      # Add link to head
+      Alula::Plugin.addon(:head, ->(context) {
+        "<link rel=\"alternate\" type=\"application/rss+xml\" title=\"RSS\" href=\"#{context.url_for(@feed_page.url(context.locale))}\">"
+      })
+      # -# %link{rel: "alternate", type: "application/rss+xml", title: "RSS", href: "/feed.xml"}
+    end
+  end
+end

data/lib/alula/generators/paginate.rb

@@ -0,0 +1,88 @@
+module Alula
+  class Generator::Paginate < Generator
+    def generate
+      # Loop all languages and count posts per language
+      @languages = {}
+      self.site.content.posts.each do |post|
+        post.languages.each do |lang|
+          @languages[lang] ||= []
+          @languages[lang] << post
+        end
+      end
+      
+      # Maximum amount of posts
+      num_posts = self.site.content.posts.count
+      # Maximum number of required pages
+      pages = (num_posts / self.options.items).ceil
+      
+      (0..pages).each do |page|
+        languages = @languages.select { |lang, posts| posts.count > page * self.options.items }
+        posts = Hash[
+          languages.collect do |lang, posts|
+            [ lang, posts.slice(page * self.options.items, self.options.items) ]
+          end
+        ]
+        titles = Hash[
+          languages.collect {|lang, x| [lang, I18n.t("paginate.title", locale: lang, page: (page + 1))]}
+        ]
+
+        self.site.content.pages << Alula::Content::Page.new({
+          generator: self,
+          posts: posts,
+          pagenum: (page + 1),
+          pages: (pages + 1),
+          title: titles,
+          name: "page-#{(page + 1)}",
+          slug: "page-#{(page + 1)}",
+          template: self.options.template,
+          site: self.site,
+          view: self.options.view || "paginate",
+        },
+        :previous => ->(locale) {
+          pos = self.navigation(locale).index(self)
+          if pos and pos < (self.navigation(locale).count - 1)
+            self.navigation(locale)[pos + 1]
+          else
+            nil
+          end
+        },
+        :next => ->(locale) {
+          pos = self.navigation(locale).index(self)
+          if pos and pos > 0
+            self.navigation(locale)[pos - 1]
+          else
+            nil
+          end
+        },
+        :navigation => ->(locale) {
+          locale ||= self.current_locale || self.site.config.locale
+          @navigation[locale] ||= self.site.content.pages.select { |item| item.metadata.generator == self.generator and item.languages.include?(locale) }
+        }
+        )
+      end
+    end
+    
+    def substitutes(locale, item)
+      {
+        "page" => item.metadata.pagenum.to_s,
+      }
+    end
+    
+    # def generate_content
+    #   # Generate pagination and pages
+    #   num_posts = @site.content.posts.count
+    #   pages = (num_posts / options.items).ceil
+    #   
+    #   (0..pages).each do |pagenum|
+    #     pagename = "page#{pagenum}"
+    #     
+    #     @site.generated << Alula::Content::Page.new({
+    #       site: @site,
+    #       posts: @site.content.posts.slice(options.items * pagenum, options.items),
+    #       current_page: (pagenum + 1),
+    #       name: pagename,
+    #     })
+    #   end
+    # end
+  end
+end

data/lib/alula/generators/sitemap.rb

@@ -0,0 +1,26 @@
+require 'builder' # For Tilt
+
+module Alula
+  class Generator::Sitemap < Generator
+    def generate
+      self.site.content.pages << Alula::Content::Page.new({
+        generator: self,
+        urls: ->(context) {
+          (context.site.content.posts + context.site.content.pages).collect { |content|
+            content.languages.collect{|lang| {
+              url: content.url(lang),
+              lastmod: content.last_modified,
+              priority: content.generator.nil? ? 0.5 : 0.3,
+            }
+          }}.flatten
+          },
+        title: "Sitemap",
+        name: "sitemap.xml",
+        slug: "sitemap",
+        template: self.options.template || "/:locale/:name",
+        site: self.site,
+        layout: "sitemap",
+      })
+    end
+  end
+end

data/lib/alula/helpers.rb

@@ -0,0 +1,2 @@
+# require 'alula/helpers/assets'
+Dir[File.join(File.dirname(__FILE__), "helpers", "*.rb")].each {|f| require f}

data/lib/alula/helpers/addons.rb

@@ -0,0 +1,12 @@
+module Alula
+  module Helpers
+    def addons(type)
+      content = ""
+      Alula::Plugin.addons[type].each do |addon|
+        content += addon.respond_to?(:call) ? addon.call(self).to_s : addon
+      end
+      
+      content
+    end
+  end
+end

data/lib/alula/helpers/assets.rb

@@ -0,0 +1,56 @@
+module Alula
+  module Helpers
+    def stylesheet_link(name = "style", opts = {})
+      name += ".css" if File.extname(name).empty?
+      options = opts.collect{|name,value| !!value == value ? (value ? "#{name}" : "") : "#{name}=\"#{value}\"" }.join(" ")
+      
+      if asset_url(name)
+        # Inline?
+        if self.environment[name].pathname.size > 10
+          "<link rel=\"stylesheet\" href=\"#{asset_url(name)}\" type=\"text/css\" #{options}/>"
+        else
+          content = self.environment[name].pathname.read
+          "<style type=\"text/css\" #{options}>#{content}</style>"
+        end
+      end
+    end
+    
+    def javascript_link(name = "script", opts = {})
+      name += ".js" if File.extname(name).empty?
+      case Alula::Plugin.script_load_mode
+      when :async
+        opts[:async] = true
+      when :defer
+        opts[:defer] = true
+      end
+      options = opts.collect{|name,value| !!value == value ? (value ? "#{name}" : "") : "#{name}=\"#{value}\"" }.join(" ")
+      
+      if asset_url(name)
+        # Inline?
+        if self.environment[name].pathname.size > 10
+          "<script #{options} src=\"#{asset_url(name)}\"></script>"
+        else
+          content = self.environment[name].pathname.read
+          "<script #{options}>#{content}</script>"
+        end
+      end      
+    end
+    
+    def asset_path(name)
+      return if name.nil?
+
+      if self.environment[name]
+        # Get asset URL
+        asset_path = File.join("assets", self.environment[name].digest_path)
+      end
+    end
+    
+    def asset_url(name)
+      return if name.nil?
+
+      if self.environment[name]
+        self.site.cdn.url_for(asset_path(name), file: self.environment[name].pathname.to_s)
+      end
+    end
+  end
+end

data/lib/alula/helpers/url_helpers.rb

@@ -0,0 +1,16 @@
+module Alula
+  module Helpers
+    def url_for(name)
+      File.join(self.site.config.url, name)
+    end
+    
+    def link_to(content, url, attributes = {})
+      tag = "<a"
+      tag += " href=\"#{url}\""
+      attributes.each do |name, value|
+        tag += " #{name}=\"#{value}\""
+      end
+      tag += ">#{content}</a>"
+    end
+  end
+end