alula 0.2.3 → 0.4.0b

data/lib/alula/contents/metadata.rb

@@ -0,0 +1,73 @@
+module Alula
+  class Content
+    class Metadata
+      def initialize(default = {})
+        default.each do |key, value|
+          self.send("#{key}=", value)
+        end
+      end
+      
+      def load(payload)
+        meta = YAML.load(payload)
+        meta.each do |key, value|
+          # Check for localisations
+          self.send("#{key}=", value)
+        end
+      end
+      
+      def respond_to?(name)
+        # Accept all setters
+        return true if name.to_s =~ /=$/
+        
+        return true if instance_variable_defined?("@#{name}")
+        
+        super
+      end
+      
+      def method_missing(meth, *args, &blk)
+        if meth[/=$/]
+          instance_variable_set("@#{meth[0..-2]}", *args)
+        else
+          # Localisation support
+          value = instance_variable_get("@#{meth}")
+          if value.kind_of?(Hash)
+            # Try environment & locale first
+            if value.has_key?(environment) and value[environment].kind_of?(Hash)
+              return value[environment][args[0]] if value[environment].has_key?(args[0])
+              return value[environment][base_locale] if value[environment].has_key?(base_locale)
+              return value[environment]
+            else
+              # Try locales
+              return value[args[0]] if value.has_key?(args[0])
+              return value[base_locale] if value.has_key?(base_locale)
+              return value[environment] if value.has_key?(environment)
+            end
+          end
+          
+          value
+        end
+      end
+    
+      # Custom accessors
+      def date=(date)
+        begin
+          if date.kind_of?(String)
+            @date = Time.parse(date)
+          else
+            @date = date
+          end
+        rescue ArgumentError => e
+          @date = nil
+        end
+      end
+
+      def languages(locale = nil)
+        if @title.kind_of?(Hash)
+          @title.keys
+        else
+          [base_locale]
+        end
+      end
+    end
+  end
+end

data/lib/alula/contents/page.rb

@@ -0,0 +1,9 @@
+require 'alula/contents/item'
+
+module Alula
+  class Content
+    class Page < Item
+      has_payload
+    end
+  end
+end

data/lib/alula/contents/post.rb

@@ -0,0 +1,32 @@
+require 'alula/contents/item'
+
+module Alula
+  class Content
+    class Post < Item
+      has_payload
+      
+      def previous(locale = nil)
+        pos = self.navigation(locale).index(self)
+        if pos and pos < (self.navigation(locale).count - 1)
+          self.navigation(locale)[pos + 1]
+        else
+          nil
+        end
+      end
+      
+      def next(locale = nil)
+        pos = self.navigation(locale).index(self)
+        if pos and pos > 0
+          self.navigation(locale)[pos - 1]
+        else
+          nil
+        end
+      end
+      
+      def navigation(locale = nil)
+        locale ||= self.current_locale || self.site.config.locale
+        @navigation[locale] ||= self.site.content.posts.select { |item| item.languages.include?(locale) }        
+      end
+    end
+  end
+end

data/lib/alula/context.rb

@@ -0,0 +1,72 @@
+require 'liquid/context'
+
+module Alula
+  class Context
+    def initialize(default = {})
+      @data = {}
+      default.each do |key, value|
+        @data[key.to_s] = value
+      end
+    end
+
+    def []=(key, value)
+      key = key.to_s
+      if value.kind_of?(Hash)
+        value = Context.new value
+      end
+      @data[key] = value
+    end
+
+    def [](key)
+      key = key.to_s
+      if @data[key].kind_of?(Hash)
+        @data[key] = Context.new @data[key]
+      end
+      @data[key]
+    end
+
+    def data=(new_data)
+      @data = new_data
+    end
+    
+    def respond_to?(name)
+      if name.to_s =~ /=$/ and @data.key?(name.to_s[0..-2])
+        true
+      elsif @data.key?(name)
+        true
+      else
+        super
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      if meth.to_s =~ /=$/
+        self.send(:[]=, meth.to_s[0..-2], *args)
+      elsif @data.key?(meth.to_s)
+        self.send(:[], meth.to_s)
+      else
+        nil
+      end
+    end
+
+    def to_liquid
+      @liquid ||= begin
+        liquid = Liquid::Context.new(
+          nil,  # Environments
+          nil,  # Outer Scope
+          {:proxy => self}, # Registers
+          true) # Rethrow errors
+        liquid.class.class_eval do
+          def method_missing(meth, *args, &blk)
+            if registers[:proxy].respond_to?(meth.to_s)
+              registers[:proxy].send(meth, *args)
+            else
+              super
+            end
+          end
+        end
+        @liquid = liquid
+      end
+    end
+  end
+end

data/lib/alula/core_ext.rb

@@ -0,0 +1,5 @@
+require 'alula/core_ext/tag'
+require 'alula/core_ext/filter'
+
+require 'alula/core_ext/manifest'
+require 'alula/core_ext/environment'

data/lib/alula/core_ext/environment.rb

@@ -0,0 +1,20 @@
+require 'sprockets'
+
+module Alula
+  class Environment < Sprockets::Environment
+    def initialize
+      super
+      
+      @used = []
+    end
+    
+    def used
+      @used.uniq
+    end
+    
+    def [](key)
+      @used << key
+      super
+    end
+  end
+end

data/lib/alula/core_ext/filter.rb

@@ -0,0 +1,20 @@
+module Alula
+  class Filter
+    def self.register(name, klass); filters[name.to_s] = klass; end
+    def self.filters; @@filters ||= {}; end
+    def filters; self.class.filters; end
+    
+    def self.load(name, options)
+      if filters[name]
+        filter = filters[name].new(options)
+        return filter
+      end
+    end
+    
+    def initialize(options)
+      @options = options
+    end
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), "filters", "*.rb")].each {|f| require f}

data/lib/alula/core_ext/filters/smilies.rb

@@ -0,0 +1,36 @@
+module Alula
+  class Smilies < Filter
+    MAP = {
+      angel:       %w{:angel: },
+      angry:       %w{:angry: },
+      cool:        %w{:cool: },
+      badguy:      %w{:badguy: },
+      crying:      %w{:crying: ;( ;-( },
+      exclamation: %w{:exclamation: },
+      idea:        %w{:idea: },
+      kiss:        %w{:kiss: :* :-* },
+      laugh:       %w{:laugh: :D :-D },
+      monkey:      %w{:monkey: },
+      plain:       %w{:plain: :| :-| },
+      question:    %w{:question: },
+      tongue:      %w{:tongue: },
+      sad:         %w{:sad: :( :-( },
+      grin:        %w{:grin: },
+      smile:       %w{:smile: :) :-) ^^ ^_^},
+      smirk:       %w{:smirk: },
+      point_right: %w{:point_right: },
+      surprise:    %w{:surprise: },
+      uncertain:   %w{:uncertain: },
+      wink:        %w{:wink: ;) ;-) },
+      worried:     %w{:worried: },
+    }
+    SMILIES = Hash[*MAP.collect{|cls, keys| keys.collect{|key| [key, "<span class=\"smilies-#{cls}\">#{key}</span>"]}}.flatten]
+    SMILIES_RE = Regexp.new(SMILIES.keys.collect{|k| Regexp.escape(k)}.join("|"))
+    
+    def process(content, locale)
+      content.gsub(SMILIES_RE, SMILIES)
+    end
+  end
+end
+
+Alula::Filter.register :smilies, Alula::Smilies

data/lib/alula/core_ext/manifest.rb

@@ -0,0 +1,30 @@
+require 'sprockets/manifest'
+
+module Alula
+  class Manifest < Sprockets::Manifest
+    attr_accessor :progress
+    
+    def assets_with_tracking
+      @_assets ||= AssetTracker.new assets_without_tracking, @progress
+    end
+    alias_method :assets_without_tracking, :assets
+    alias_method :assets, :assets_with_tracking
+    
+    private
+    class AssetTracker
+      def initialize(hash, progress_callback)
+        @hash = hash
+        @progress_cb = progress_callback
+      end
+      
+      def [](key)
+        @hash[key]
+      end
+      
+      def []=(key, value)
+        @hash[key] = value
+        @progress_cb.call if @progress_cb
+      end
+    end
+  end
+end

data/lib/alula/core_ext/tag.rb

@@ -0,0 +1,100 @@
+require 'liquid'
+require 'dimensions'
+
+module Alula
+  module LiquidExt
+    attr_reader :context
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def register(tagname, klass)
+        Liquid::Template.register_tag(tagname.to_s, klass)
+      end
+    end
+    
+    def initialize(tagname, markup, tokens)
+      super
+      
+      @tagname = tagname
+      @markup = markup.strip
+      @tokens = tokens
+      
+      @info = {}
+      @options = {}
+      
+      # Parse tag options
+      if m = /^([\"'][\S\. ]+[\"']|[\S\.]+)(.*)$/.match(@markup)
+        @source = m[1].gsub(/^['"]?([^'"]+)['"]?$/, '\1')
+        @source = "" if @source == '""'
+        @options["source"] = @source unless @source.empty?
+
+        if m[2]
+          m[2].scan(/(\S+):["]?((?:.(?!["]?\s+(?:\S+):|[>"]))+.)["]?/) do |name, value|
+            @options[name] = value
+          end
+        end
+      end
+      
+      prepare if respond_to?("prepare")
+    end
+    
+    def render(context)
+      @context = context
+      if respond_to?("content")
+        content
+      else
+        super
+      end
+    end
+    
+    private
+    def info(source, type = nil)
+      @info["#{source}#{type.to_s}"] ||= begin
+        file = self.context.asset_path(attachment_path(source, type))
+        return Hashie::Mash.new if file.nil?
+        
+        # info = MiniExiftool.new File.join self.context.storage.path(:public), file
+        info = Dimensions.dimensions(File.join(self.context.storage.path(:public), file))
+        info ||= begin
+          _info = MiniExiftool.new File.join(self.context.storage.path(:public), file)
+          [_info.imagewidth, _info.imageheight]
+        end
+        Hashie::Mash.new({
+          width: info[0],
+          height: info[1],
+        })
+      end
+    end
+    
+    def attachment_path(source, type = nil)
+      name = (type.nil?) ? source : File.join(type.to_s, source)
+      self.context.attachments.mapping[name]
+    end
+    
+    def attachment_url(source, type = nil)
+      asset_url(attachment_path(source, type))
+    end
+    
+    def asset_url(name)
+      self.context.asset_url(name)
+    end
+    
+    def hires_url(source, type)
+      hires_source = source.gsub(/(#{File.extname(source)})$/, '-hires\1')
+      attachment_url(hires_source, type)
+    end
+  end
+  
+  class Tag < Liquid::Tag
+    include LiquidExt
+  end
+  
+  class Block < Liquid::Block
+    include LiquidExt
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), "tags", "*.rb")].each {|f| require f}

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

@@ -0,0 +1,28 @@
+module Alula
+  class AttachmentTag < Tag
+    def prepare
+      @classes = []
+      
+      if m = /(["'])?([^"']+)\1?(?: (.+))?/.match(@markup)
+        @source = m[2]
+        @title = File.basename(@source)
+        options = m[3]
+      end
+      
+      if options
+        options.scan(/(\S+):["]?((?:.(?!["]?\s+(?:\S+):|[>"]))+.)["]?/) do |name, value|
+          case name
+          when "title"
+            @title = value
+          end
+        end
+      end
+    end
+    
+    def content
+      "<a href=\"#{attachment_url(@source)}\">#{@title}</a>"
+    end
+  end
+end
+
+Alula::Tag.register :attachment, Alula::AttachmentTag

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

@@ -0,0 +1,21 @@
+module Alula
+  class BlockquoteTag < Block
+    def render(context)
+      quote = super
+      
+      tag = "<blockquote>"
+      tag += quote
+      if @options["author"] or @source
+        tag += "<div class=\"source\">"
+        tag += " &mdash; " if @options["author"] and @source.empty?
+        tag += "<strong>#{@options["author"]}</strong>" if @options["author"]
+        tag += " &mdash; " if @options["author"] and !@source.empty?
+        tag += "<cite>#{@source}</cite>" if @source
+        tag += "</div>"
+      end
+      tag += "</blockquote>"
+    end
+  end
+end
+
+Alula::Tag.register :blockquote, Alula::BlockquoteTag