jekyllplusadmin 1.0.0

data/lib/jekyll/readers/collection_reader.rb

@@ -0,0 +1,20 @@
+module Jekyll
+  class CollectionReader
+    SPECIAL_COLLECTIONS = %w(posts data).freeze
+
+    attr_reader :site, :content
+    def initialize(site)
+      @site = site
+      @content = {}
+    end
+
+    # Read in all collections specified in the configuration
+    #
+    # Returns nothing.
+    def read
+      site.collections.each do |_, collection|
+        collection.read unless SPECIAL_COLLECTIONS.include?(collection.label)
+      end
+    end
+  end
+end

data/lib/jekyll/readers/data_reader.rb

@@ -0,0 +1,69 @@
+module Jekyll
+  class DataReader
+    attr_reader :site, :content
+    def initialize(site)
+      @site = site
+      @content = {}
+    end
+
+    # Read all the files in <source>/<dir>/_drafts and create a new Draft
+    # object with each one.
+    #
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns nothing.
+    def read(dir)
+      base = site.in_source_dir(dir)
+      read_data_to(base, @content)
+      @content
+    end
+
+    # Read and parse all yaml files under <dir> and add them to the
+    # <data> variable.
+    #
+    # dir - The string absolute path of the directory to read.
+    # data - The variable to which data will be added.
+    #
+    # Returns nothing
+    def read_data_to(dir, data)
+      return unless File.directory?(dir) && (!site.safe || !File.symlink?(dir))
+
+      entries = Dir.chdir(dir) do
+        Dir['*.{yaml,yml,json,csv}'] + Dir['*'].select { |fn| File.directory?(fn) }
+      end
+
+      entries.each do |entry|
+        path = @site.in_source_dir(dir, entry)
+        next if File.symlink?(path) && site.safe
+
+        key = sanitize_filename(File.basename(entry, '.*'))
+        if File.directory?(path)
+          read_data_to(path, data[key] = {})
+        else
+          data[key] = read_data_file(path)
+        end
+      end
+    end
+
+    # Determines how to read a data file.
+    #
+    # Returns the contents of the data file.
+    def read_data_file(path)
+      case File.extname(path).downcase
+      when '.csv'
+        CSV.read(path, {
+                         :headers => true,
+                         :encoding => site.config['encoding']
+                     }).map(&:to_hash)
+      else
+        SafeYAML.load_file(path)
+      end
+    end
+
+    def sanitize_filename(name)
+      name.gsub!(/[^\w\s-]+/, '')
+      name.gsub!(/(^|\b\s)\s+($|\s?\b)/, '\\1\\2')
+      name.gsub(/\s+/, '_')
+    end
+  end
+end

data/lib/jekyll/readers/layout_reader.rb

@@ -0,0 +1,53 @@
+module Jekyll
+  class LayoutReader
+    attr_reader :site
+    def initialize(site)
+      @site = site
+      @layouts = {}
+    end
+
+    def read
+      layout_entries.each do |f|
+        @layouts[layout_name(f)] = Layout.new(site, layout_directory, f)
+      end
+
+      @layouts
+    end
+
+    def layout_directory
+      @layout_directory ||= (layout_directory_in_cwd || layout_directory_inside_source)
+    end
+
+    private
+
+    def layout_entries
+      entries = []
+      within(layout_directory) do
+        entries = EntryFilter.new(site).filter(Dir['**/*.*'])
+      end
+      entries
+    end
+
+    def layout_name(file)
+      file.split(".")[0..-2].join(".")
+    end
+
+    def within(directory)
+      return unless File.exist?(directory)
+      Dir.chdir(directory) { yield }
+    end
+
+    def layout_directory_inside_source
+      site.in_source_dir(site.config['layouts_dir'])
+    end
+
+    def layout_directory_in_cwd
+      dir = Jekyll.sanitized_path(Dir.pwd, site.config['layouts_dir'])
+      if File.directory?(dir) && !site.safe
+        dir
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/jekyll/readers/page_reader.rb

@@ -0,0 +1,21 @@
+module Jekyll
+  class PageReader
+    attr_reader :site, :dir, :unfiltered_content
+    def initialize(site, dir)
+      @site = site
+      @dir = dir
+      @unfiltered_content = []
+    end
+
+    # Read all the files in <source>/<dir>/ for Yaml header and create a new Page
+    # object for each file.
+    #
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns an array of static pages.
+    def read(files)
+      files.map { |page| @unfiltered_content << Page.new(@site, @site.source, @dir, page) }
+      @unfiltered_content.select { |page| site.publisher.publish?(page) }
+    end
+  end
+end

data/lib/jekyll/readers/post_reader.rb

@@ -0,0 +1,62 @@
+module Jekyll
+  class PostReader
+    attr_reader :site, :unfiltered_content
+    def initialize(site)
+      @site = site
+    end
+
+    # Read all the files in <source>/<dir>/_drafts and create a new
+    # Document object with each one.
+    #
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns nothing.
+    def read_drafts(dir)
+      read_publishable(dir, '_drafts', Document::DATELESS_FILENAME_MATCHER)
+    end
+
+    # Read all the files in <source>/<dir>/_posts and create a new Document
+    # object with each one.
+    #
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns nothing.
+    def read_posts(dir)
+      read_publishable(dir, '_posts', Document::DATE_FILENAME_MATCHER)
+    end
+
+    # Read all the files in <source>/<dir>/<magic_dir> and create a new
+    # Document object with each one insofar as it matches the regexp matcher.
+    #
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns nothing.
+    def read_publishable(dir, magic_dir, matcher)
+      read_content(dir, magic_dir, matcher).tap do |docs|
+        docs.each(&:read)
+      end.select do |doc|
+        site.publisher.publish?(doc)
+      end
+    end
+
+    # Read all the content files from <source>/<dir>/magic_dir
+    #   and return them with the type klass.
+    #
+    # dir - The String relative path of the directory to read.
+    # magic_dir - The String relative directory to <dir>,
+    #   looks for content here.
+    # klass - The return type of the content.
+    #
+    # Returns klass type of content files
+    def read_content(dir, magic_dir, matcher)
+      @site.reader.get_entries(dir, magic_dir).map do |entry|
+        next unless entry =~ matcher
+        path = @site.in_source_dir(File.join(dir, magic_dir, entry))
+        Document.new(path, {
+          :site => @site,
+          :collection => @site.posts
+        })
+      end.reject(&:nil?)
+    end
+  end
+end

data/lib/jekyll/readers/static_file_reader.rb

@@ -0,0 +1,21 @@
+module Jekyll
+  class StaticFileReader
+    attr_reader :site, :dir, :unfiltered_content
+    def initialize(site, dir)
+      @site = site
+      @dir = dir
+      @unfiltered_content = []
+    end
+
+    # Read all the files in <source>/<dir>/ for Yaml header and create a new Page
+    # object for each file.
+    #
+    # dir - The String relative path of the directory to read.
+    #
+    # Returns an array of static files.
+    def read(files)
+      files.map { |file| @unfiltered_content << StaticFile.new(@site, @site.source, @dir, file) }
+      @unfiltered_content
+    end
+  end
+end

data/lib/jekyll/regenerator.rb

@@ -0,0 +1,175 @@
+module Jekyll
+  class Regenerator
+    attr_reader :site, :metadata, :cache
+
+    def initialize(site)
+      @site = site
+
+      # Read metadata from file
+      read_metadata
+
+      # Initialize cache to an empty hash
+      clear_cache
+    end
+
+    # Checks if a renderable object needs to be regenerated
+    #
+    # Returns a boolean.
+    def regenerate?(document)
+      case document
+      when Page
+        document.asset_file? || document.data['regenerate'] ||
+          source_modified_or_dest_missing?(
+            site.in_source_dir(document.relative_path), document.destination(@site.dest)
+          )
+      when Document
+        !document.write? || document.data['regenerate'] ||
+          source_modified_or_dest_missing?(
+            document.path, document.destination(@site.dest)
+          )
+      else
+        source_path = document.respond_to?(:path)        ? document.path                    : nil
+        dest_path   = document.respond_to?(:destination) ? document.destination(@site.dest) : nil
+        source_modified_or_dest_missing?(source_path, dest_path)
+      end
+    end
+
+    # Add a path to the metadata
+    #
+    # Returns true, also on failure.
+    def add(path)
+      return true unless File.exist?(path)
+
+      metadata[path] = {
+        "mtime" => File.mtime(path),
+        "deps" => []
+      }
+      cache[path] = true
+    end
+
+    # Force a path to regenerate
+    #
+    # Returns true.
+    def force(path)
+      cache[path] = true
+    end
+
+    # Clear the metadata and cache
+    #
+    # Returns nothing
+    def clear
+      @metadata = {}
+      clear_cache
+    end
+
+    # Clear just the cache
+    #
+    # Returns nothing
+    def clear_cache
+      @cache = {}
+    end
+
+    # Checks if the source has been modified or the
+    # destination is missing
+    #
+    # returns a boolean
+    def source_modified_or_dest_missing?(source_path, dest_path)
+      modified?(source_path) || (dest_path && !File.exist?(dest_path))
+    end
+
+    # Checks if a path's (or one of its dependencies)
+    # mtime has changed
+    #
+    # Returns a boolean.
+    def modified?(path)
+      return true if disabled?
+
+      # objects that don't have a path are always regenerated
+      return true if path.nil?
+
+      # Check for path in cache
+      if cache.key? path
+        return cache[path]
+      end
+
+      # Check path that exists in metadata
+      data = metadata[path]
+      if data
+        data["deps"].each do |dependency|
+          if modified?(dependency)
+            return cache[dependency] = cache[path] = true
+          end
+        end
+        if File.exist?(path) && data["mtime"].eql?(File.mtime(path))
+          return cache[path] = false
+        else
+          return add(path)
+        end
+      end
+
+      # Path does not exist in metadata, add it
+      return add(path)
+    end
+
+    # Add a dependency of a path
+    #
+    # Returns nothing.
+    def add_dependency(path, dependency)
+      return if metadata[path].nil? || @disabled
+
+      unless metadata[path]["deps"].include? dependency
+        metadata[path]["deps"] << dependency
+        add(dependency) unless metadata.include?(dependency)
+      end
+      regenerate? dependency
+    end
+
+    # Write the metadata to disk
+    #
+    # Returns nothing.
+    def write_metadata
+      unless disabled?
+        File.binwrite(metadata_file, Marshal.dump(metadata))
+      end
+    end
+
+    # Produce the absolute path of the metadata file
+    #
+    # Returns the String path of the file.
+    def metadata_file
+      site.in_source_dir('.jekyll-metadata')
+    end
+
+    # Check if metadata has been disabled
+    #
+    # Returns a Boolean (true for disabled, false for enabled).
+    def disabled?
+      @disabled = !site.incremental? if @disabled.nil?
+      @disabled
+    end
+
+    private
+
+    # Read metadata from the metadata file, if no file is found,
+    # initialize with an empty hash
+    #
+    # Returns the read metadata.
+    def read_metadata
+      @metadata =
+        if !disabled? && File.file?(metadata_file)
+          content = File.binread(metadata_file)
+
+          begin
+            Marshal.load(content)
+          rescue TypeError
+            SafeYAML.load(content)
+          rescue ArgumentError => e
+            Jekyll.logger.warn("Failed to load #{metadata_file}: #{e}")
+            {}
+          end
+        else
+          {}
+        end
+    end
+  end
+end

data/lib/jekyll/related_posts.rb

@@ -0,0 +1,56 @@
+module Jekyll
+  class RelatedPosts
+    class << self
+      attr_accessor :lsi
+    end
+
+    attr_reader :post, :site
+
+    def initialize(post)
+      @post = post
+      @site = post.site
+      Jekyll::External.require_with_graceful_fail('classifier-reborn') if site.lsi
+    end
+
+    def build
+      return [] unless site.posts.docs.size > 1
+
+      if site.lsi
+        build_index
+        lsi_related_posts
+      else
+        most_recent_posts
+      end
+    end
+
+    def build_index
+      self.class.lsi ||= begin
+        lsi = ClassifierReborn::LSI.new(:auto_rebuild => false)
+        display("Populating LSI...")
+
+        site.posts.docs.each do |x|
+          lsi.add_item(x)
+        end
+
+        display("Rebuilding index...")
+        lsi.build_index
+        display("")
+        lsi
+      end
+    end
+
+    def lsi_related_posts
+      self.class.lsi.find_related(post, 11)
+    end
+
+    def most_recent_posts
+      @most_recent_posts ||= (site.posts.docs.reverse - [post]).first(10)
+    end
+
+    def display(output)
+      $stdout.print("\n")
+      $stdout.print(Jekyll.logger.formatted_topic(output))
+      $stdout.flush
+    end
+  end
+end