bunto 1.0.0

data/lib/bunto/static_file.rb

@@ -0,0 +1,141 @@
+module Bunto
+  class StaticFile
+    # The cache of last modification times [path] -> mtime.
+    @@mtimes = {}
+
+    attr_reader :relative_path, :extname
+
+    # Initialize a new StaticFile.
+    #
+    # site - The Site.
+    # base - The String path to the <source>.
+    # dir  - The String path between <source> and the file.
+    # name - The String filename of the file.
+    def initialize(site, base, dir, name, collection = nil)
+      @site = site
+      @base = base
+      @dir  = dir
+      @name = name
+      @collection = collection
+      @relative_path = File.join(*[@dir, @name].compact)
+      @extname = File.extname(@name)
+    end
+
+    # Returns source file path.
+    def path
+      File.join(*[@base, @dir, @name].compact)
+    end
+
+    # Obtain destination path.
+    #
+    # dest - The String path to the destination dir.
+    #
+    # Returns destination file path.
+    def destination(dest)
+      @site.in_dest_dir(*[dest, destination_rel_dir, @name].compact)
+    end
+
+    def destination_rel_dir
+      if @collection
+        File.dirname(url)
+      else
+        @dir
+      end
+    end
+
+    def modified_time
+      @modified_time ||= File.stat(path).mtime
+    end
+
+    # Returns last modification time for this file.
+    def mtime
+      modified_time.to_i
+    end
+
+    # Is source path modified?
+    #
+    # Returns true if modified since last write.
+    def modified?
+      @@mtimes[path] != mtime
+    end
+
+    # Whether to write the file to the filesystem
+    #
+    # Returns true unless the defaults for the destination path from
+    # _config.yml contain `published: false`.
+    def write?
+      defaults.fetch('published', true)
+    end
+
+    # Write the static file to the destination directory (if modified).
+    #
+    # dest - The String path to the destination dir.
+    #
+    # Returns false if the file was not modified since last time (no-op).
+    def write(dest)
+      dest_path = destination(dest)
+
+      return false if File.exist?(dest_path) && !modified?
+      @@mtimes[path] = mtime
+
+      FileUtils.mkdir_p(File.dirname(dest_path))
+      FileUtils.rm(dest_path) if File.exist?(dest_path)
+      FileUtils.cp(path, dest_path)
+      File.utime(@@mtimes[path], @@mtimes[path], dest_path)
+
+      true
+    end
+
+    # Reset the mtimes cache (for testing purposes).
+    #
+    # Returns nothing.
+    def self.reset_cache
+      @@mtimes = {}
+      nil
+    end
+
+    def to_liquid
+      {
+        "extname"       => extname,
+        "modified_time" => modified_time,
+        "path"          => File.join("", relative_path)
+      }
+    end
+
+    def placeholders
+      {
+        :collection => @collection.label,
+        :path => relative_path[
+          @collection.relative_directory.size..relative_path.size],
+        :output_ext => '',
+        :name => '',
+        :title => ''
+      }
+    end
+
+    # Applies a similar URL-building technique as Bunto::Document that takes
+    # the collection's URL template into account. The default URL template can
+    # be overriden in the collection's configuration in _config.yml.
+    def url
+      @url ||= if @collection.nil?
+                 relative_path
+               else
+                 ::Bunto::URL.new({
+                   :template => @collection.url_template,
+                   :placeholders => placeholders
+                 })
+               end.to_s.gsub(/\/$/, '')
+    end
+
+    # Returns the type of the collection if present, nil otherwise.
+    def type
+      @type ||= @collection.nil? ? nil : @collection.label.to_sym
+    end
+
+    # Returns the front matter defaults defined for the file's URL and/or type
+    # as defined in _config.yml.
+    def defaults
+      @defaults ||= @site.frontmatter_defaults.all url, type
+    end
+  end
+end

data/lib/bunto/stevenson.rb

@@ -0,0 +1,58 @@
+module Bunto
+  class Stevenson < ::Logger
+    def initialize
+      @progname = nil
+      @level = DEBUG
+      @default_formatter = Formatter.new
+      @logdev = $stdout
+      @formatter = proc do |_, _, _, msg|
+        "#{msg}"
+      end
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      severity ||= UNKNOWN
+      @logdev = set_logdevice(severity)
+
+      if @logdev.nil? || severity < @level
+        return true
+      end
+      progname ||= @progname
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = @progname
+        end
+      end
+      @logdev.puts(
+        format_message(format_severity(severity), Time.now, progname, message))
+      true
+    end
+
+    # Log a +WARN+ message
+    def warn(progname = nil, &block)
+      add(WARN, nil, progname.yellow, &block)
+    end
+
+    # Log an +ERROR+ message
+    def error(progname = nil, &block)
+      add(ERROR, nil, progname.red, &block)
+    end
+
+    def close
+      # No LogDevice in use
+    end
+
+    private
+
+    def set_logdevice(severity)
+      if severity > INFO
+        $stderr
+      else
+        $stdout
+      end
+    end
+  end
+end

data/lib/bunto/tags/highlight.rb

@@ -0,0 +1,122 @@
+module Bunto
+  module Tags
+    class HighlightBlock < Liquid::Block
+      include Liquid::StandardFilters
+
+      # The regular expression syntax checker. Start with the language specifier.
+      # Follow that by zero or more space separated options that take one of three
+      # forms: name, name=value, or name="<quoted list>"
+      #
+      # <quoted list> is a space-separated list of numbers
+      SYNTAX = /^([a-zA-Z0-9.+#-]+)((\s+\w+(=(\w+|"([0-9]+\s)*[0-9]+"))?)*)$/
+
+      def initialize(tag_name, markup, tokens)
+        super
+        if markup.strip =~ SYNTAX
+          @lang = Regexp.last_match(1).downcase
+          @highlight_options = {}
+          if defined?(Regexp.last_match(2)) && Regexp.last_match(2) != ''
+            # Split along 3 possible forms -- key="<quoted list>", key=value, or key
+            Regexp.last_match(2).scan(/(?:\w="[^"]*"|\w=\w|\w)+/) do |opt|
+              key, value = opt.split('=')
+              # If a quoted list, convert to array
+              if value && value.include?("\"")
+                value.delete!('"')
+                  value = value.split
+              end
+              @highlight_options[key.to_sym] = value || true
+            end
+          end
+          @highlight_options[:linenos] = "inline" if @highlight_options.key?(:linenos) && @highlight_options[:linenos] == true
+        else
+          raise SyntaxError.new <<-eos
+Syntax Error in tag 'highlight' while parsing the following markup:
+
+  #{markup}
+
+Valid syntax: highlight <lang> [linenos]
+eos
+        end
+      end
+
+      def render(context)
+        prefix = context["highlighter_prefix"] || ""
+        suffix = context["highlighter_suffix"] || ""
+        code = super.to_s.gsub(/\A(\n|\r)+|(\n|\r)+\z/, '')
+
+        is_safe = !!context.registers[:site].safe
+
+        output =
+          case context.registers[:site].highlighter
+          when 'pygments'
+            render_pygments(code, is_safe)
+          when 'rouge'
+            render_rouge(code)
+          else
+            render_codehighlighter(code)
+          end
+
+        rendered_output = add_code_tag(output)
+        prefix + rendered_output + suffix
+      end
+
+      def sanitized_opts(opts, is_safe)
+        if is_safe
+          Hash[[
+            [:startinline, opts.fetch(:startinline, nil)],
+            [:hl_lines,    opts.fetch(:hl_lines, nil)],
+            [:linenos,     opts.fetch(:linenos, nil)],
+            [:encoding,    opts.fetch(:encoding, 'utf-8')],
+            [:cssclass,    opts.fetch(:cssclass, nil)]
+          ].reject { |f| f.last.nil? }]
+        else
+          opts
+        end
+      end
+
+      def render_pygments(code, is_safe)
+        Bunto::External.require_with_graceful_fail('pygments')
+
+        highlighted_code = Pygments.highlight(
+          code,
+          :lexer   => @lang,
+          :options => sanitized_opts(@highlight_options, is_safe)
+        )
+
+        if highlighted_code.nil?
+          Bunto.logger.error "There was an error highlighting your code:"
+          puts
+          Bunto.logger.error code
+          puts
+          Bunto.logger.error "While attempting to convert the above code, Pygments.rb" \
+            " returned an unacceptable value."
+          Bunto.logger.error "This is usually a timeout problem solved by running `bunto build` again."
+          raise ArgumentError.new("Pygments.rb returned an unacceptable value when attempting to highlight some code.")
+        end
+
+        highlighted_code.sub('<div class="highlight"><pre>', '').sub('</pre></div>', '')
+      end
+
+      def render_rouge(code)
+        Bunto::External.require_with_graceful_fail('rouge')
+        formatter = Rouge::Formatters::HTML.new(:line_numbers => @highlight_options[:linenos], :wrap => false)
+        lexer = Rouge::Lexer.find_fancy(@lang, code) || Rouge::Lexers::PlainText
+        formatter.format(lexer.lex(code))
+      end
+
+      def render_codehighlighter(code)
+        h(code).strip
+      end
+
+      def add_code_tag(code)
+        code_attributes = [
+          "class=\"language-#{@lang.to_s.tr('+', '-')}\"",
+          "data-lang=\"#{@lang}\""
+        ].join(" ")
+        "<figure class=\"highlight\"><pre><code #{code_attributes}>#{code.chomp}</code></pre></figure>"
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('highlight', Bunto::Tags::HighlightBlock)

data/lib/bunto/tags/include.rb

@@ -0,0 +1,190 @@
+# encoding: UTF-8
+
+module Bunto
+  module Tags
+    class IncludeTagError < StandardError
+      attr_accessor :path
+
+      def initialize(msg, path)
+        super(msg)
+        @path = path
+      end
+    end
+
+    class IncludeTag < Liquid::Tag
+      attr_reader :includes_dir
+
+      VALID_SYNTAX = /([\w-]+)\s*=\s*(?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|([\w\.-]+))/
+      VARIABLE_SYNTAX = /(?<variable>[^{]*(\{\{\s*[\w\-\.]+\s*(\|.*)?\}\}[^\s{}]*)+)(?<params>.*)/
+
+      def initialize(tag_name, markup, tokens)
+        super
+        matched = markup.strip.match(VARIABLE_SYNTAX)
+        if matched
+          @file = matched['variable'].strip
+          @params = matched['params'].strip
+        else
+          @file, @params = markup.strip.split(' ', 2)
+        end
+        validate_params if @params
+        @tag_name = tag_name
+      end
+
+      def syntax_example
+        "{% #{@tag_name} file.ext param='value' param2='value' %}"
+      end
+
+      def parse_params(context)
+        params = {}
+        markup = @params
+
+        while match = VALID_SYNTAX.match(markup) do
+          markup = markup[match.end(0)..-1]
+
+          value = if match[2]
+                    match[2].gsub(/\\"/, '"')
+                  elsif match[3]
+                    match[3].gsub(/\\'/, "'")
+                  elsif match[4]
+                    context[match[4]]
+                  end
+
+          params[match[1]] = value
+        end
+        params
+      end
+
+      def validate_file_name(file)
+        if file !~ /^[a-zA-Z0-9_\/\.-]+$/ || file =~ /\.\// || file =~ /\/\./
+          raise ArgumentError.new <<-eos
+Invalid syntax for include tag. File contains invalid characters or sequences:
+
+  #{file}
+
+Valid syntax:
+
+  #{syntax_example}
+
+eos
+        end
+      end
+
+      def validate_params
+        full_valid_syntax = Regexp.compile('\A\s*(?:' + VALID_SYNTAX.to_s + '(?=\s|\z)\s*)*\z')
+        unless @params =~ full_valid_syntax
+          raise ArgumentError.new <<-eos
+Invalid syntax for include tag:
+
+  #{@params}
+
+Valid syntax:
+
+  #{syntax_example}
+
+eos
+        end
+      end
+
+      # Grab file read opts in the context
+      def file_read_opts(context)
+        context.registers[:site].file_read_opts
+      end
+
+      # Render the variable if required
+      def render_variable(context)
+        if @file.match(VARIABLE_SYNTAX)
+          partial = context.registers[:site].liquid_renderer.file("(variable)").parse(@file)
+          partial.render!(context)
+        end
+      end
+
+      def tag_includes_dir(context)
+        context.registers[:site].config['includes_dir'].freeze
+      end
+
+      def render(context)
+        site = context.registers[:site]
+        @includes_dir = tag_includes_dir(context)
+        dir = resolved_includes_dir(context)
+
+        file = render_variable(context) || @file
+        validate_file_name(file)
+
+        path = File.join(dir, file)
+        validate_path(path, dir, site.safe)
+
+        # Add include to dependency tree
+        if context.registers[:page] && context.registers[:page].key?("path")
+          site.regenerator.add_dependency(
+            site.in_source_dir(context.registers[:page]["path"]),
+            path
+          )
+        end
+
+        begin
+          partial = load_cached_partial(path, context)
+
+          context.stack do
+            context['include'] = parse_params(context) if @params
+            partial.render!(context)
+          end
+        rescue => e
+          raise IncludeTagError.new e.message, File.join(@includes_dir, @file)
+        end
+      end
+
+      def load_cached_partial(path, context)
+        context.registers[:cached_partials] ||= {}
+        cached_partial = context.registers[:cached_partials]
+
+        if cached_partial.key?(path)
+          cached_partial[path]
+        else
+          cached_partial[path] = context.registers[:site].liquid_renderer.file(path).parse(read_file(path, context))
+        end
+      end
+
+      def resolved_includes_dir(context)
+        context.registers[:site].in_source_dir(@includes_dir)
+      end
+
+      def validate_path(path, dir, safe)
+        if safe && !realpath_prefixed_with?(path, dir)
+          raise IOError.new "The included file '#{path}' should exist and should not be a symlink"
+        elsif !File.exist?(path)
+          raise IOError.new "Included file '#{path_relative_to_source(dir, path)}' not found"
+        end
+      end
+
+      def path_relative_to_source(dir, path)
+        File.join(@includes_dir, path.sub(Regexp.new("^#{dir}"), ""))
+      end
+
+      def realpath_prefixed_with?(path, dir)
+        File.exist?(path) && File.realpath(path).start_with?(dir)
+      end
+
+      # This method allows to modify the file content by inheriting from the class.
+      def read_file(file, context)
+        File.read(file, file_read_opts(context))
+      end
+    end
+
+    class IncludeRelativeTag < IncludeTag
+      def tag_includes_dir(context)
+        '.'.freeze
+      end
+
+      def page_path(context)
+        context.registers[:page].nil? ? includes_dir : File.dirname(context.registers[:page]["path"])
+      end
+
+      def resolved_includes_dir(context)
+        context.registers[:site].in_source_dir(page_path(context))
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('include', Bunto::Tags::IncludeTag)
+Liquid::Template.register_tag('include_relative', Bunto::Tags::IncludeRelativeTag)