bunto 1.0.0

data/lib/bunto/tags/post_url.rb

@@ -0,0 +1,88 @@
+module Bunto
+  module Tags
+    class PostComparer
+      MATCHER = /^(.+\/)*(\d+-\d+-\d+)-(.*)$/
+
+      attr_reader :path, :date, :slug, :name
+
+      def initialize(name)
+        @name = name
+        all, @path, @date, @slug = *name.sub(/^\//, "").match(MATCHER)
+        raise ArgumentError.new("'#{name}' does not contain valid date and/or title.") unless all
+
+        @name_regex = /^#{path}#{date}-#{slug}\.[^.]+/
+      end
+
+      def ==(other)
+        other.basename.match(@name_regex)
+      end
+
+      def deprecated_equality(other)
+        date = Utils.parse_date(name, "'#{name}' does not contain valid date and/or title.")
+        slug == post_slug(other) &&
+          date.year  == other.date.year &&
+          date.month == other.date.month &&
+          date.day   == other.date.day
+      end
+
+      private
+      # Construct the directory-aware post slug for a Bunto::Post
+      #
+      # other - the Bunto::Post
+      #
+      # Returns the post slug with the subdirectory (relative to _posts)
+      def post_slug(other)
+        path = other.basename.split("/")[0...-1].join("/")
+        if path.nil? || path == ""
+          other.data['slug']
+        else
+          path + '/' + other.data['slug']
+        end
+      end
+    end
+
+    class PostUrl < Liquid::Tag
+      def initialize(tag_name, post, tokens)
+        super
+        @orig_post = post.strip
+        begin
+          @post = PostComparer.new(@orig_post)
+        rescue
+          raise ArgumentError.new <<-eos
+Could not parse name of post "#{@orig_post}" in tag 'post_url'.
+
+Make sure the post exists and the name is correct.
+eos
+        end
+      end
+
+      def render(context)
+        site = context.registers[:site]
+
+        site.posts.docs.each do |p|
+          return p.url if @post == p
+        end
+
+        # New matching method did not match, fall back to old method
+        # with deprecation warning if this matches
+
+        site.posts.docs.each do |p|
+          next unless @post.deprecated_equality p
+          Bunto::Deprecator.deprecation_message "A call to '{{ post_url #{@post.name} }}' did not match " \
+            "a post using the new matching method of checking name " \
+            "(path-date-slug) equality. Please make sure that you " \
+            "change this tag to match the post's name exactly."
+          return p.url
+        end
+
+        raise ArgumentError.new <<-eos
+Could not find post "#{@orig_post}" in tag 'post_url'.
+
+Make sure the post exists and the name is correct.
+eos
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('post_url', Bunto::Tags::PostUrl)

data/lib/bunto/url.rb

@@ -0,0 +1,136 @@
+require 'uri'
+
+# Public: Methods that generate a URL for a resource such as a Post or a Page.
+#
+# Examples
+#
+#   URL.new({
+#     :template => /:categories/:title.html",
+#     :placeholders => {:categories => "ruby", :title => "something"}
+#   }).to_s
+#
+module Bunto
+  class URL
+    # options - One of :permalink or :template must be supplied.
+    #           :template     - The String used as template for URL generation,
+    #                           for example "/:path/:basename:output_ext", where
+    #                           a placeholder is prefixed with a colon.
+    #           :placeholders - A hash containing the placeholders which will be
+    #                           replaced when used inside the template. E.g.
+    #                           { "year" => Time.now.strftime("%Y") } would replace
+    #                           the placeholder ":year" with the current year.
+    #           :permalink    - If supplied, no URL will be generated from the
+    #                           template. Instead, the given permalink will be
+    #                           used as URL.
+    def initialize(options)
+      @template     = options[:template]
+      @placeholders = options[:placeholders] || {}
+      @permalink    = options[:permalink]
+
+      if (@template || @permalink).nil?
+        raise ArgumentError, "One of :template or :permalink must be supplied."
+      end
+    end
+
+    # The generated relative URL of the resource
+    #
+    # Returns the String URL
+    def to_s
+      sanitize_url(generated_permalink || generated_url)
+    end
+
+    # Generates a URL from the permalink
+    #
+    # Returns the _unsanitized String URL
+    def generated_permalink
+      (@generated_permalink ||= generate_url(@permalink)) if @permalink
+    end
+
+    # Generates a URL from the template
+    #
+    # Returns the unsanitized String URL
+    def generated_url
+      @generated_url ||= generate_url(@template)
+    end
+
+    # Internal: Generate the URL by replacing all placeholders with their
+    # respective values in the given template
+    #
+    # Returns the unsanitized String URL
+    def generate_url(template)
+      if @placeholders.is_a? Drops::UrlDrop
+        generate_url_from_drop(template)
+      else
+        generate_url_from_hash(template)
+      end
+    end
+
+    def generate_url_from_hash(template)
+      @placeholders.inject(template) do |result, token|
+        break result if result.index(':').nil?
+        if token.last.nil?
+          # Remove leading '/' to avoid generating urls with `//`
+          result.gsub(/\/:#{token.first}/, '')
+        else
+          result.gsub(/:#{token.first}/, self.class.escape_path(token.last))
+        end
+      end
+    end
+
+    def generate_url_from_drop(template)
+      template.gsub(/:([a-z_]+)/.freeze) do |match|
+        replacement = @placeholders.public_send(match.sub(':'.freeze, ''.freeze))
+        if replacement.nil?
+          ''.freeze
+        else
+          self.class.escape_path(replacement)
+        end
+      end.gsub(/\/\//.freeze, '/'.freeze)
+    end
+
+    # Returns a sanitized String URL, stripping "../../" and multiples of "/",
+    # as well as the beginning "/" so we can enforce and ensure it.
+
+    def sanitize_url(str)
+      "/" + str.gsub(/\/{2,}/, "/").gsub(/\.+\/|\A\/+/, "")
+    end
+
+    # Escapes a path to be a valid URL path segment
+    #
+    # path - The path to be escaped.
+    #
+    # Examples:
+    #
+    #   URL.escape_path("/a b")
+    #   # => "/a%20b"
+    #
+    # Returns the escaped path.
+    def self.escape_path(path)
+      # Because URI.escape doesn't escape '?', '[' and ']' by default,
+      # specify unsafe string (except unreserved, sub-delims, ":", "@" and "/").
+      #
+      # URI path segment is defined in RFC 3986 as follows:
+      #   segment       = *pchar
+      #   pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
+      #   unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
+      #   pct-encoded   = "%" HEXDIG HEXDIG
+      #   sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
+      #                 / "*" / "+" / "," / ";" / "="
+      URI.escape(path, /[^a-zA-Z\d\-._~!$&'()*+,;=:@\/]/).encode('utf-8')
+    end
+
+    # Unescapes a URL path segment
+    #
+    # path - The path to be unescaped.
+    #
+    # Examples:
+    #
+    #   URL.unescape_path("/a%20b")
+    #   # => "/a b"
+    #
+    # Returns the unescaped path.
+    def self.unescape_path(path)
+      URI.unescape(path.encode('utf-8'))
+    end
+  end
+end

data/lib/bunto/utils.rb

@@ -0,0 +1,287 @@
+module Bunto
+  module Utils
+    extend self
+    autoload :Platforms, 'bunto/utils/platforms'
+    autoload :Ansi, "bunto/utils/ansi"
+
+    # Constants for use in #slugify
+    SLUGIFY_MODES = %w(raw default pretty)
+    SLUGIFY_RAW_REGEXP = Regexp.new('\\s+').freeze
+    SLUGIFY_DEFAULT_REGEXP = Regexp.new('[^[:alnum:]]+').freeze
+    SLUGIFY_PRETTY_REGEXP = Regexp.new("[^[:alnum:]._~!$&'()+,;=@]+").freeze
+
+    # Takes an indented string and removes the preceding spaces on each line
+
+    def strip_heredoc(str)
+      str.gsub(/^[ \t]{#{(str.scan(/^[ \t]*(?=\S)/).min || "").size}}/, "")
+    end
+
+    # Takes a slug and turns it into a simple title.
+
+    def titleize_slug(slug)
+      slug.split("-").map! do |val|
+        val.capitalize!
+      end.join(" ")
+    end
+
+    # Non-destructive version of deep_merge_hashes! See that method.
+    #
+    # Returns the merged hashes.
+    def deep_merge_hashes(master_hash, other_hash)
+      deep_merge_hashes!(master_hash.dup, other_hash)
+    end
+
+    # Merges a master hash with another hash, recursively.
+    #
+    # master_hash - the "parent" hash whose values will be overridden
+    # other_hash  - the other hash whose values will be persisted after the merge
+    #
+    # This code was lovingly stolen from some random gem:
+    # http://gemjack.com/gems/tartan-0.1.1/classes/Hash.html
+    #
+    # Thanks to whoever made it.
+    def deep_merge_hashes!(target, overwrite)
+      target.merge!(overwrite) do |key, old_val, new_val|
+        if new_val.nil?
+          old_val
+        else
+          mergable?(old_val) && mergable?(new_val) ? deep_merge_hashes(old_val, new_val) : new_val
+        end
+      end
+
+      if target.respond_to?(:default_proc) && overwrite.respond_to?(:default_proc) && target.default_proc.nil?
+        target.default_proc = overwrite.default_proc
+      end
+
+      target
+    end
+
+    def mergable?(value)
+      value.is_a?(Hash) || value.is_a?(Drops::Drop)
+    end
+
+    # Read array from the supplied hash favouring the singular key
+    # and then the plural key, and handling any nil entries.
+    #
+    # hash - the hash to read from
+    # singular_key - the singular key
+    # plural_key - the plural key
+    #
+    # Returns an array
+    def pluralized_array_from_hash(hash, singular_key, plural_key)
+      [].tap do |array|
+        array << (value_from_singular_key(hash, singular_key) || value_from_plural_key(hash, plural_key))
+      end.flatten.compact
+    end
+
+    def value_from_singular_key(hash, key)
+      hash[key] if hash.key?(key) || (hash.default_proc && hash[key])
+    end
+
+    def value_from_plural_key(hash, key)
+      if hash.key?(key) || (hash.default_proc && hash[key])
+        val = hash[key]
+        case val
+        when String
+          val.split
+        when Array
+          val.compact
+        end
+      end
+    end
+
+    def transform_keys(hash)
+      result = {}
+      hash.each_key do |key|
+        result[yield(key)] = hash[key]
+      end
+      result
+    end
+
+    # Apply #to_sym to all keys in the hash
+    #
+    # hash - the hash to which to apply this transformation
+    #
+    # Returns a new hash with symbolized keys
+    def symbolize_hash_keys(hash)
+      transform_keys(hash) { |key| key.to_sym rescue key }
+    end
+
+    # Apply #to_s to all keys in the Hash
+    #
+    # hash - the hash to which to apply this transformation
+    #
+    # Returns a new hash with stringified keys
+    def stringify_hash_keys(hash)
+      transform_keys(hash) { |key| key.to_s rescue key }
+    end
+
+    # Parse a date/time and throw an error if invalid
+    #
+    # input - the date/time to parse
+    # msg - (optional) the error message to show the user
+    #
+    # Returns the parsed date if successful, throws a FatalException
+    # if not
+    def parse_date(input, msg = "Input could not be parsed.")
+      Time.parse(input).localtime
+    rescue ArgumentError
+      raise Errors::FatalException.new("Invalid date '#{input}': " + msg)
+    end
+
+    # Determines whether a given file has
+    #
+    # Returns true if the YAML front matter is present.
+    def has_yaml_header?(file)
+      !!(File.open(file, 'rb') { |f| f.readline } =~ /\A---\s*\r?\n/)
+    rescue EOFError
+      false
+    end
+
+    # Slugify a filename or title.
+    #
+    # string - the filename or title to slugify
+    # mode - how string is slugified
+    # cased - whether to replace all  uppercase letters with their
+    # lowercase counterparts
+    #
+    # When mode is "none", return the given string.
+    #
+    # When mode is "raw", return the given string,
+    # with every sequence of spaces characters replaced with a hyphen.
+    #
+    # When mode is "default" or nil, non-alphabetic characters are
+    # replaced with a hyphen too.
+    #
+    # When mode is "pretty", some non-alphabetic characters (._~!$&'()+,;=@)
+    # are not replaced with hyphen.
+    #
+    # If cased is true, all uppercase letters in the result string are
+    # replaced with their lowercase counterparts.
+    #
+    # Examples:
+    #   slugify("The _config.yml file")
+    #   # => "the-config-yml-file"
+    #
+    #   slugify("The _config.yml file", "pretty")
+    #   # => "the-_config.yml-file"
+    #
+    #   slugify("The _config.yml file", "pretty", true)
+    #   # => "The-_config.yml file"
+    #
+    # Returns the slugified string.
+    def slugify(string, mode: nil, cased: false)
+      mode ||= 'default'
+      return nil if string.nil?
+
+      unless SLUGIFY_MODES.include?(mode)
+        return cased ? string : string.downcase
+      end
+
+      # Replace each character sequence with a hyphen
+      re =
+        case mode
+        when 'raw'
+          SLUGIFY_RAW_REGEXP
+        when 'default'
+          SLUGIFY_DEFAULT_REGEXP
+        when 'pretty'
+          # "._~!$&'()+,;=@" is human readable (not URI-escaped) in URL
+          # and is allowed in both extN and NTFS.
+          SLUGIFY_PRETTY_REGEXP
+        end
+
+      # Strip according to the mode
+      slug = string.gsub(re, '-')
+
+      # Remove leading/trailing hyphen
+      slug.gsub!(/^\-|\-$/i, '')
+
+      slug.downcase! unless cased
+      slug
+    end
+
+    # Add an appropriate suffix to template so that it matches the specified
+    # permalink style.
+    #
+    # template - permalink template without trailing slash or file extension
+    # permalink_style - permalink style, either built-in or custom
+    #
+    # The returned permalink template will use the same ending style as
+    # specified in permalink_style.  For example, if permalink_style contains a
+    # trailing slash (or is :pretty, which indirectly has a trailing slash),
+    # then so will the returned template.  If permalink_style has a trailing
+    # ":output_ext" (or is :none, :date, or :ordinal) then so will the returned
+    # template.  Otherwise, template will be returned without modification.
+    #
+    # Examples:
+    #   add_permalink_suffix("/:basename", :pretty)
+    #   # => "/:basename/"
+    #
+    #   add_permalink_suffix("/:basename", :date)
+    #   # => "/:basename:output_ext"
+    #
+    #   add_permalink_suffix("/:basename", "/:year/:month/:title/")
+    #   # => "/:basename/"
+    #
+    #   add_permalink_suffix("/:basename", "/:year/:month/:title")
+    #   # => "/:basename"
+    #
+    # Returns the updated permalink template
+    def add_permalink_suffix(template, permalink_style)
+      case permalink_style
+      when :pretty
+        template << "/"
+      when :date, :ordinal, :none
+        template << ":output_ext"
+      else
+        template << "/" if permalink_style.to_s.end_with?("/")
+        template << ":output_ext" if permalink_style.to_s.end_with?(":output_ext")
+      end
+      template
+    end
+
+    # Work the same way as Dir.glob but seperating the input into two parts
+    # ('dir' + '/' + 'pattern') to make sure the first part('dir') does not act
+    # as a pattern.
+    #
+    # For example, Dir.glob("path[/*") always returns an empty array,
+    # because the method fails to find the closing pattern to '[' which is ']'
+    #
+    # Examples:
+    #   safe_glob("path[", "*")
+    #   # => ["path[/file1", "path[/file2"]
+    #
+    #   safe_glob("path", "*", File::FNM_DOTMATCH)
+    #   # => ["path/.", "path/..", "path/file1"]
+    #
+    #   safe_glob("path", ["**", "*"])
+    #   # => ["path[/file1", "path[/folder/file2"]
+    #
+    # dir      - the dir where glob will be executed under
+    #           (the dir will be included to each result)
+    # patterns - the patterns (or the pattern) which will be applied under the dir
+    # flags    - the flags which will be applied to the pattern
+    #
+    # Returns matched pathes
+    def safe_glob(dir, patterns, flags = 0)
+      return [] unless Dir.exist?(dir)
+      pattern = File.join(Array patterns)
+      return [dir] if pattern.empty?
+      Dir.chdir(dir) do
+        Dir.glob(pattern, flags).map { |f| File.join(dir, f) }
+      end
+    end
+
+    # Returns merged option hash for File.read of self.site (if exists)
+    # and a given param
+    def merged_file_read_opts(site, opts)
+      merged = (site ? site.file_read_opts : {}).merge(opts)
+      if merged["encoding"] && !merged["encoding"].start_with?("bom|")
+        merged["encoding"].insert(0, "bom|")
+      end
+      merged
+    end
+
+  end
+end