jekyll-liquid-plus 1.0.0

data/lib/jekyll-liquid-plus/helpers/conditional.rb

@@ -0,0 +1,43 @@
+module LiquidPlus
+  class Conditional
+    EXPRESSION = /(.+?)\s+(unless|if)\s+(.+)/i
+    TERNARY = /(.*?)\(\s*(.+?)\s+\?\s+(.+?)\s+:\s+(.+?)\s*\)(.+)?/
+
+    class << self
+      def parse(markup, context)
+        strip_expression(markup, context) if evaluate_expression markup, context
+      end
+
+      def strip_expression(markup, context = false)
+        if markup =~ TERNARY
+          # Pick winner from ternary statement
+          result = evaluate_ternary($2, $3, $4, context)
+          markup = "#{$1} #{result} #{$5}"
+        end
+        markup =~ EXPRESSION ? $1 : markup
+      end
+
+      def evaluate_ternary(expression, if_true, if_false, context)
+        evaluate('if', expression, context) ? if_true : if_false
+      end
+
+      def evaluate_expression(markup, context)
+        if markup =~ EXPRESSION
+          evaluate($2, $3.gsub(/ \|\| /, ' or '), context)
+        else
+          true
+        end
+      end
+
+      def evaluate(type, expression, context)
+        tag = if type == 'if'
+          Liquid::If.new('if', expression, ["true","{% endif %}"])
+        elsif type == 'unless'
+          Liquid::Unless.new('unless', expression, ["true","{% endunless %}"])
+        end
+        tag.render(context) != ''
+      end
+    end
+  end
+end
+

data/lib/jekyll-liquid-plus/helpers/include.rb

@@ -0,0 +1,46 @@
+require File.join File.expand_path('../../', __FILE__), 'helpers/path'
+
+module LiquidPlus
+  class Include
+    LOCALS = /(.*?)(([\w-]+)\s*=\s*(?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|([\w\.-]+)))(.*)?/
+
+    class << self
+
+      def render(markup, context)
+
+        markup, params = split_params markup
+        file = Path.parse(markup, context, '_includes')
+
+        if file
+          if File.exist? Path.expand(File.join('_includes', file), context)
+            markup = file
+            markup += params if params
+            tag = Jekyll::Tags::IncludeTag.new('', markup, [])
+            tag.render(context)
+          else
+            dir = '_includes'
+            dir = File.join dir, File.dirname(file) unless File.dirname(file) == '.'
+
+            msg  = "From #{context.registers[:page]['path']}: "
+            msg += "File '#{file}' not found"
+            msg += " in '#{dir}/' directory"
+
+            puts msg.red
+            return msg
+          end
+        end
+      end
+
+      def split_params(markup)
+        params = nil
+        if markup =~ LOCALS
+          params = ' ' + $2
+          markup = $1 + $7
+        end
+        [markup, params]
+      end
+
+    end
+  end
+end
+

data/lib/jekyll-liquid-plus/helpers/path.rb

@@ -0,0 +1,73 @@
+require File.join File.expand_path('../../', __FILE__), 'helpers/conditional'
+
+module LiquidPlus
+  class Path
+    class << self
+
+      # 
+      def parse(markup, context, path=nil)
+        files = Conditional.parse(markup, context)
+        if files
+          select(files, context, path)
+        end
+      end
+
+      # Allow paths to begin from the directory of the context page
+      #
+      # Input: 
+      #  - file: "file.html"
+      #  - context: A Jekyll context object
+      #
+      #  Returns the full path to a file
+      #
+      def expand(file, context)
+        root = context.registers[:site].source
+        if file =~ /^\.\/(.+)/
+          local_dir = File.dirname context.registers[:page]['path']
+          File.join root, local_dir, $1
+        else
+          File.join root, file
+        end
+      end
+      
+      # Find the first file which exists
+      #
+      # Input: 
+      #  - file: "file.html || some_var || path/to/file.md" - a list of files
+      #  - context: A Jekyll context object
+      #  - path: e.g. "_includes" - a directory to prepend to the path
+      #
+      # Return the first file path which exists, or the last if none exist
+      # If the last path is 'none' this returns false
+      #
+      def select(files, context, path)
+        files = get_paths(files, context)
+        files.each_with_index do |f, i|
+          file = path ? File.join(path, f) : f
+          if File.exist? expand(file, context)
+            return f
+          # If "file.html || none" is passed, fail gracefully
+          elsif i == files.size - 1
+            return f.downcase == 'none' ? false : f
+          end
+        end
+      end
+
+      # Read file paths from context variables if necessary
+      #
+      # Input: 
+      #  - file: file.html || some_var || path/to/file.md
+      #  - context: A Jekyll context object
+      #
+      # Returns a list of file paths
+      #
+      def get_paths(files, context)
+        files = files.split(/ (\|\||or) /).map do |file|
+          file = file.strip
+          context[file].nil? ? file : context[file]
+        end
+      end
+    end
+  end
+end
+

data/lib/jekyll-liquid-plus/helpers/var.rb

@@ -0,0 +1,47 @@
+require File.join File.expand_path('../../', __FILE__), 'helpers/conditional'
+
+module LiquidPlus
+  class Var
+    SYNTAX = /(#{Liquid::VariableSignature}+)\s*(=|\+=|\|\|=)\s*(.*)\s*/o
+
+    class << self
+      def parse(markup, context)
+        if markup = Conditional.parse(markup, context)
+          if markup =~ SYNTAX
+            @to = $1
+            @operator = $2
+            @from = $3
+
+            value = get_value(@from, context)
+
+            if @operator == '+=' and !context.scopes.last[@to].nil?
+              context.scopes.last[@to] += value
+            elsif @operator == '=' or (@operator == '||=' and context.scopes.last[@to].nil?)
+              context.scopes.last[@to] = value
+            end
+            context
+          else
+            raise SyntaxError.new("Syntax Error in 'assign' - Valid syntax: assign [var] = [source]")
+          end
+        end
+      end
+
+      def determine_value(vars, context)
+        vars.each do |var|
+          rendered = var.render(context)
+          return rendered unless rendered.nil?
+        end
+        nil
+      end
+
+      def get_value(vars, context)
+        vars = vars.gsub(/ or /, ' || ')
+        vars = vars.strip.split(/ \|\| /).map do |v|
+          Liquid::Variable.new(v.strip)
+        end
+        determine_value(vars, context)
+      end
+    end
+  end
+end
+

data/lib/jekyll-liquid-plus/tags/assign.rb

@@ -0,0 +1,19 @@
+require File.join File.expand_path('../../', __FILE__), 'helpers/var'
+
+module LiquidPlus
+  class AssignTag < Liquid::Tag
+
+    def initialize(tag_name, markup, tokens)
+      @markup = markup
+      super
+    end
+
+    def render(context)
+      if c = Var.parse(@markup, context)
+        context = c
+      end
+      ''
+    end
+  end
+end
+

data/lib/jekyll-liquid-plus/tags/capture.rb

@@ -0,0 +1,34 @@
+require File.join File.expand_path('../../', __FILE__), 'helpers/conditional'
+
+module LiquidPlus
+  class CaptureTag < Liquid::Block
+    WORD_REGEX = '[[:word:]]'
+    SYNTAX = /(#{WORD_REGEX}+)\s*(\+=|\|\|=)?/o
+
+    def initialize(tag_name, markup, tokens)
+      @markup = markup
+      super
+    end
+
+    def render(context)
+      if @markup = Conditional.parse(@markup, context)
+        if @markup.strip =~ SYNTAX
+          @to = $1
+          @operator = $2
+
+          output = super
+          if @operator == '+=' and !context.scopes.last[@to].nil?
+            context.scopes.last[@to] += output.strip 
+          elsif @operator.nil? or (@operator == '||=' and context.scopes.last[@to].nil?)
+            context.scopes.last[@to] = output.strip
+          end
+
+        else
+          raise SyntaxError.new("Syntax Error in 'capture' - Valid syntax: capture [var]")
+        end
+      end
+      ''
+    end
+  end
+end
+

data/lib/jekyll-liquid-plus/tags/include.rb

@@ -0,0 +1,16 @@
+require File.join File.expand_path('../../', __FILE__), 'helpers/include'
+
+module LiquidPlus
+  class IncludeTag < Liquid::Tag
+
+    def initialize(tag_name, markup, tokens)
+      @markup = markup.strip
+      super
+    end
+
+    def render(context)
+      Include.render(@markup, context)
+    end
+  end
+end
+

data/lib/jekyll-liquid-plus/tags/render.rb

@@ -0,0 +1,133 @@
+# Title: Render Partial Tag for Jekyll
+# Author: Brandon Mathis
+# Description: Import files on your filesystem into any blog post and render them inline.
+# Note: Paths are relative to the source directory, if you import a file with yaml front matter, the yaml will be stripped out.
+#
+# Syntax {% render_partial path/to/file %}
+#
+# Example 1:
+# {% render_partial about/_bio.markdown %}
+#
+# This will import source/about/_bio.markdown and render it inline.
+# In this example I used an underscore at the beginning of the filename to prevent Jekyll
+# from generating an about/bio.html (Jekyll doesn't convert files beginning with underscores)
+#
+# Example 2:
+# {% render_partial ../README.markdown %}
+#
+# You can use relative pathnames, to include files outside of the source directory.
+# This might be useful if you want to have a page for a project's README without having
+# to duplicated the contents
+#
+#
+
+require File.join File.expand_path('../../', __FILE__), 'helpers/path'
+require File.join File.expand_path('../../', __FILE__), 'helpers/include'
+require 'jekyll'
+require 'yaml'
+require 'pathname'
+
+module Jekyll
+
+  # Create a new page class to allow partials to trigger Jekyll Page Hooks.
+  class ConvertiblePage
+    include Convertible
+    
+    attr_accessor :name, :content, :site, :ext, :output, :data
+    
+    def initialize(site, name, content)
+      @site     = site
+      @name     = name
+      @ext      = File.extname(name)
+      @content  = content
+      @data     = { layout: "no_layout" } # hack
+      
+    end
+    
+    def render(payload, info)
+      do_layout(payload, { no_layout: nil })
+    end
+  end
+end
+
+module LiquidPlus
+  class RenderTag < Liquid::Tag
+    def initialize(tag_name, markup, tokens)
+      @markup = markup.strip
+      super
+    end
+
+    def parse_markup
+      # If raw, strip from the markup as not to confuse the Path syntax parsing
+      if @markup =~ /^(\s*raw\s)?(.+?)(\sraw\s*)?$/
+        @markup = $2.strip
+        @raw = true unless $1.nil? and $3.nil?
+      end
+
+      # Separate params from markup
+      @markup, @params = Include.split_params(@markup)
+    end
+
+    def get_path(context)
+      if file = Path.parse(@markup, context)
+        path = Pathname.new Path.expand(file, context)
+        @markup = file
+        path
+      end
+    end
+
+    def render(context)
+      parse_markup
+      path = get_path(context)
+      if path and File.exist? path
+
+        Dir.chdir(File.dirname(path)) do
+          content = path.read
+          
+          #Strip out yaml header from partials
+          if content =~ /\A-{3}(.+[^\A])-{3}\n(.+)/m
+            @local_vars = YAML.safe_load($1.strip)
+            content = $2.strip
+          end
+
+          if @raw
+            content
+          else
+            content = parse_params(content, context) if @params or @local_vars
+
+            p = Jekyll::ConvertiblePage.new(context.registers[:site], path, content)
+            payload = { 'page' => context.registers[:page], 'site' => context.registers[:site] }
+            p.render(payload, { registers: context.registers })
+            p.output.strip
+          end
+        end
+      elsif path
+        name = File.basename(path)
+        dir  = path.to_s.sub(context.registers[:site].source + '/', '')
+
+        msg  = "From #{context.registers[:page]['path']}: "
+        msg += "File '#{name}' not found"
+        msg += " in '#{dir}' directory" unless name == dir
+
+        puts msg.red
+        return msg
+      end
+    end
+
+    def parse_params(content, context)
+      if @params
+        markup = @markup + @params
+      end
+      partial = Liquid::Template.parse(content)
+
+      context.stack do
+        c = context
+        c['render'] = Jekyll::Tags::IncludeTag.new('', markup, []).parse_params(context) if @params
+        c['page'] = c['page'].deep_merge(@local_vars) if @local_vars and @local_vars.keys.size > 0
+        content = partial.render(c)
+      end
+      content
+    end
+  end
+end
+

data/lib/jekyll-liquid-plus/tags/return.rb

@@ -0,0 +1,20 @@
+require File.join File.expand_path('../../', __FILE__), 'helpers/var'
+
+module LiquidPlus
+  class ReturnTag < Liquid::Tag
+
+    def initialize(tag_name, markup, tokens)
+      @markup = markup.strip
+      super
+    end
+
+    def render(context)
+      if @markup = Conditional.parse(@markup, context)
+        Var.get_value(@markup, context)
+      else
+        ''
+      end
+    end
+  end
+end
+

data/lib/jekyll-liquid-plus/tags/wrap.rb

@@ -0,0 +1,36 @@
+require File.join File.expand_path('../../', __FILE__), 'helpers/include'
+require File.join File.expand_path('../../', __FILE__), 'tags/render'
+
+module LiquidPlus
+  class WrapTag < Liquid::Block
+    HAS_CONTENT = /(.*?)({=\s*yield\s*})(.*)/im
+
+    def initialize(tag_name, markup, tokens)
+      @tag = tag_name
+      @markup = markup.strip
+      super
+    end
+
+    def render(context)
+      if super.strip =~ HAS_CONTENT
+        front = $1
+        back = $3
+
+        partial = if @tag == 'wrap'
+          RenderTag.new('', @markup, []).render(context)
+        elsif @tag == 'wrap_include'
+          Include.render(@markup, context)
+        end
+
+        if partial
+          front + partial.strip + back
+        else
+          ''
+        end
+      else
+        raise SyntaxError.new("Syntax Error in '#{@tag}' - Valid syntax: {% wrap_include template/file.html %}\n[<div>]{= yield }[</div>]\n{% end#{@tag} %}")
+      end
+    end
+  end
+end
+