jekyll-docs 3.6.1.0 → 3.6.2

data/lib/jekyll/tags/link.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Tags
+    class Link < Liquid::Tag
+      class << self
+        def tag_name
+          self.name.split("::").last.downcase
+        end
+      end
+
+      def initialize(tag_name, relative_path, tokens)
+        super
+
+        @relative_path = relative_path.strip
+      end
+
+      def render(context)
+        site = context.registers[:site]
+
+        site.each_site_file do |item|
+          return item.url if item.relative_path == @relative_path
+          # This takes care of the case for static files that have a leading /
+          return item.url if item.relative_path == "/#{@relative_path}"
+        end
+
+        raise ArgumentError, <<-MSG
+Could not find document '#{@relative_path}' in tag '#{self.class.tag_name}'.
+
+Make sure the document exists and the path is correct.
+MSG
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag(Jekyll::Tags::Link.tag_name, Jekyll::Tags::Link)

data/lib/jekyll/tags/post_url.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Tags
+    class PostComparer
+      MATCHER = %r!^(.+/)*(\d+-\d+-\d+)-(.*)$!
+
+      attr_reader :path, :date, :slug, :name
+
+      def initialize(name)
+        @name = name
+
+        all, @path, @date, @slug = *name.sub(%r!^/!, "").match(MATCHER)
+        unless all
+          raise Jekyll::Errors::InvalidPostNameError,
+            "'#{name}' does not contain valid date and/or title."
+        end
+
+        escaped_slug = Regexp.escape(slug)
+        @name_regex = %r!^_posts/#{path}#{date}-#{escaped_slug}\.[^.]+|
+          ^#{path}_posts/?#{date}-#{escaped_slug}\.[^.]+!x
+      end
+
+      def post_date
+        @post_date ||= Utils.parse_date(date,
+          "\"#{date}\" does not contain valid date and/or title.")
+      end
+
+      def ==(other)
+        other.relative_path.match(@name_regex)
+      end
+
+      def deprecated_equality(other)
+        slug == post_slug(other) &&
+          post_date.year  == other.date.year &&
+          post_date.month == other.date.month &&
+          post_date.day   == other.date.day
+      end
+
+      private
+      # Construct the directory-aware post slug for a Jekyll::Post
+      #
+      # other - the Jekyll::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 => e
+          raise Jekyll::Errors::PostURLError, <<-MSG
+Could not parse name of post "#{@orig_post}" in tag 'post_url'.
+
+Make sure the post exists and the name is correct.
+
+#{e.class}: #{e.message}
+MSG
+        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
+          Jekyll::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 Jekyll::Errors::PostURLError, <<-MSG
+Could not find post "#{@orig_post}" in tag 'post_url'.
+
+Make sure the post exists and the name is correct.
+MSG
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag("post_url", Jekyll::Tags::PostUrl)

data/lib/jekyll/theme.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Theme
+    extend Forwardable
+    attr_reader :name
+    def_delegator :gemspec, :version, :version
+
+    def initialize(name)
+      @name = name.downcase.strip
+      configure_sass
+    end
+
+    def root
+      # Must use File.realpath to resolve symlinks created by rbenv
+      # Otherwise, Jekyll.sanitized path with prepend the unresolved root
+      @root ||= File.realpath(gemspec.full_gem_path)
+    rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
+      nil
+    end
+
+    def includes_path
+      path_for "_includes".freeze
+    end
+
+    def layouts_path
+      path_for "_layouts".freeze
+    end
+
+    def sass_path
+      path_for "_sass".freeze
+    end
+
+    def assets_path
+      path_for "assets".freeze
+    end
+
+    def configure_sass
+      return unless sass_path
+      require "sass"
+      Sass.load_paths << sass_path
+    end
+
+    def runtime_dependencies
+      gemspec.runtime_dependencies
+    end
+
+    private
+
+    def path_for(folder)
+      path = realpath_for(folder)
+      path if path && File.directory?(path)
+    end
+
+    def realpath_for(folder)
+      File.realpath(Jekyll.sanitized_path(root, folder.to_s))
+    rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
+      nil
+    end
+
+    def gemspec
+      @gemspec ||= Gem::Specification.find_by_name(name)
+    rescue Gem::LoadError
+      raise Jekyll::Errors::MissingDependencyException,
+        "The #{name} theme could not be found."
+    end
+  end
+end

data/lib/jekyll/theme_builder.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+class Jekyll::ThemeBuilder
+  SCAFFOLD_DIRECTORIES = %w(
+    assets _layouts _includes _sass
+  ).freeze
+
+  attr_reader :name, :path, :code_of_conduct
+
+  def initialize(theme_name, opts)
+    @name = theme_name.to_s.tr(" ", "_").gsub(%r!_+!, "_")
+    @path = Pathname.new(File.expand_path(name, Dir.pwd))
+    @code_of_conduct = !!opts["code_of_conduct"]
+  end
+
+  def create!
+    create_directories
+    create_starter_files
+    create_gemspec
+    create_accessories
+    initialize_git_repo
+  end
+
+  private
+
+  def root
+    @root ||= Pathname.new(File.expand_path("../", __dir__))
+  end
+
+  def template_file(filename)
+    [
+      root.join("theme_template", "#{filename}.erb"),
+      root.join("theme_template", filename.to_s),
+    ].find(&:exist?)
+  end
+
+  def template(filename)
+    erb.render(template_file(filename).read)
+  end
+
+  def erb
+    @erb ||= ERBRenderer.new(self)
+  end
+
+  def mkdir_p(directories)
+    Array(directories).each do |directory|
+      full_path = path.join(directory)
+      Jekyll.logger.info "create", full_path.to_s
+      FileUtils.mkdir_p(full_path)
+    end
+  end
+
+  def write_file(filename, contents)
+    full_path = path.join(filename)
+    Jekyll.logger.info "create", full_path.to_s
+    File.write(full_path, contents)
+  end
+
+  def create_directories
+    mkdir_p(SCAFFOLD_DIRECTORIES)
+  end
+
+  def create_starter_files
+    %w(page post default).each do |layout|
+      write_file("_layouts/#{layout}.html", template("_layouts/#{layout}.html"))
+    end
+  end
+
+  def create_gemspec
+    write_file("Gemfile", template("Gemfile"))
+    write_file("#{name}.gemspec", template("theme.gemspec"))
+  end
+
+  def create_accessories
+    accessories = %w(README.md LICENSE.txt)
+    accessories << "CODE_OF_CONDUCT.md" if code_of_conduct
+    accessories.each do |filename|
+      write_file(filename, template(filename))
+    end
+  end
+
+  def initialize_git_repo
+    Jekyll.logger.info "initialize", path.join(".git").to_s
+    Dir.chdir(path.to_s) { `git init` }
+    write_file(".gitignore", template("gitignore"))
+  end
+
+  def user_name
+    @user_name ||= `git config user.name`.chomp
+  end
+
+  def user_email
+    @user_email ||= `git config user.email`.chomp
+  end
+
+  class ERBRenderer
+    extend Forwardable
+
+    def_delegator :@theme_builder, :name, :theme_name
+    def_delegator :@theme_builder, :user_name, :user_name
+    def_delegator :@theme_builder, :user_email, :user_email
+
+    def initialize(theme_builder)
+      @theme_builder = theme_builder
+    end
+
+    def jekyll_version_with_minor
+      Jekyll::VERSION.split(".").take(2).join(".")
+    end
+
+    def theme_directories
+      SCAFFOLD_DIRECTORIES
+    end
+
+    def render(contents)
+      ERB.new(contents).result binding
+    end
+  end
+end

data/lib/jekyll/url.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "addressable/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 Jekyll
+  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(%r!/:#{token.first}!, "")
+        else
+          result.gsub(%r!:#{token.first}!, self.class.escape_path(token.last))
+        end
+      end
+    end
+
+    # We include underscores in keys to allow for 'i_month' and so forth.
+    # This poses a problem for keys which are followed by an underscore
+    # but the underscore is not part of the key, e.g. '/:month_:day'.
+    # That should be :month and :day, but our key extraction regexp isn't
+    # smart enough to know that so we have to make it an explicit
+    # possibility.
+    def possible_keys(key)
+      if key.end_with?("_")
+        [key, key.chomp("_")]
+      else
+        [key]
+      end
+    end
+
+    def generate_url_from_drop(template)
+      template.gsub(%r!:([a-z_]+)!) do |match|
+        pool = possible_keys(match.sub(":", ""))
+
+        winner = pool.find { |key| @placeholders.key?(key) }
+        if winner.nil?
+          raise NoMethodError,
+            "The URL template doesn't have #{pool.join(" or ")} keys. "\
+              "Check your permalink template!"
+        end
+
+        value = @placeholders[winner]
+        value = "" if value.nil?
+        replacement = self.class.escape_path(value)
+
+        match.sub(":#{winner}", replacement)
+      end.gsub(%r!//!, "/".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(%r!/{2,}!, "/").gsub(%r!\.+/|\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    = "!" / "$" / "&" / "'" / "(" / ")"
+      #                 / "*" / "+" / "," / ";" / "="
+      path = Addressable::URI.encode(path)
+      path.encode("utf-8").sub("#", "%23")
+    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)
+      Addressable::URI.unencode(path.encode("utf-8"))
+    end
+  end
+end