jekyllplusadmin 1.0.0

data/lib/jekyll/collection.rb

@@ -0,0 +1,205 @@
+module Jekyll
+  class Collection
+    attr_reader :site, :label, :metadata
+    attr_writer :docs
+
+    # Create a new Collection.
+    #
+    # site - the site to which this collection belongs.
+    # label - the name of the collection
+    #
+    # Returns nothing.
+    def initialize(site, label)
+      @site     = site
+      @label    = sanitize_label(label)
+      @metadata = extract_metadata
+    end
+
+    # Fetch the Documents in this collection.
+    # Defaults to an empty array if no documents have been read in.
+    #
+    # Returns an array of Jekyll::Document objects.
+    def docs
+      @docs ||= []
+    end
+
+    # Override of normal respond_to? to match method_missing's logic for
+    # looking in @data.
+    def respond_to?(method, include_private = false)
+      docs.respond_to?(method.to_sym, include_private) || super
+    end
+
+    # Override of method_missing to check in @data for the key.
+    def method_missing(method, *args, &blck)
+      if docs.respond_to?(method.to_sym)
+        Jekyll.logger.warn "Deprecation:", "#{label}.#{method} should be changed to #{label}.docs.#{method}."
+        Jekyll.logger.warn "", "Called by #{caller.first}."
+        docs.public_send(method.to_sym, *args, &blck)
+      else
+        super
+      end
+    end
+
+    # Fetch the static files in this collection.
+    # Defaults to an empty array if no static files have been read in.
+    #
+    # Returns an array of Jekyll::StaticFile objects.
+    def files
+      @files ||= []
+    end
+
+    # Read the allowed documents into the collection's array of docs.
+    #
+    # Returns the sorted array of docs.
+    def read
+      filtered_entries.each do |file_path|
+        full_path = collection_dir(file_path)
+        next if File.directory?(full_path)
+        if Utils.has_yaml_header? full_path
+          doc = Jekyll::Document.new(full_path, { :site => site, :collection => self })
+          doc.read
+          if site.publisher.publish?(doc) || !write?
+            docs << doc
+          else
+            Jekyll.logger.debug "Skipped From Publishing:", doc.relative_path
+          end
+        else
+          relative_dir = Jekyll.sanitized_path(relative_directory, File.dirname(file_path)).chomp("/.")
+          files << StaticFile.new(site, site.source, relative_dir, File.basename(full_path), self)
+        end
+      end
+      docs.sort!
+    end
+
+    # All the entries in this collection.
+    #
+    # Returns an Array of file paths to the documents in this collection
+    #   relative to the collection's directory
+    def entries
+      return [] unless exists?
+      @entries ||=
+        Utils.safe_glob(collection_dir, ["**", "*.*"]).map do |entry|
+          entry["#{collection_dir}/"] = ''
+          entry
+        end
+    end
+
+    # Filtered version of the entries in this collection.
+    # See `Jekyll::EntryFilter#filter` for more information.
+    #
+    # Returns a list of filtered entry paths.
+    def filtered_entries
+      return [] unless exists?
+      @filtered_entries ||=
+        Dir.chdir(directory) do
+          entry_filter.filter(entries).reject do |f|
+            path = collection_dir(f)
+            File.directory?(path) || (File.symlink?(f) && site.safe)
+          end
+        end
+    end
+
+    # The directory for this Collection, relative to the site source.
+    #
+    # Returns a String containing the directory name where the collection
+    #   is stored on the filesystem.
+    def relative_directory
+      @relative_directory ||= "_#{label}"
+    end
+
+    # The full path to the directory containing the collection.
+    #
+    # Returns a String containing th directory name where the collection
+    #   is stored on the filesystem.
+    def directory
+      @directory ||= site.in_source_dir(relative_directory)
+    end
+
+    # The full path to the directory containing the collection, with
+    #   optional subpaths.
+    #
+    # *files - (optional) any other path pieces relative to the
+    #           directory to append to the path
+    #
+    # Returns a String containing th directory name where the collection
+    #   is stored on the filesystem.
+    def collection_dir(*files)
+      return directory if files.empty?
+      site.in_source_dir(relative_directory, *files)
+    end
+
+    # Checks whether the directory "exists" for this collection.
+    # The directory must exist on the filesystem and must not be a symlink
+    #   if in safe mode.
+    #
+    # Returns false if the directory doesn't exist or if it's a symlink
+    #   and we're in safe mode.
+    def exists?
+      File.directory?(directory) && !(File.symlink?(directory) && site.safe)
+    end
+
+    # The entry filter for this collection.
+    # Creates an instance of Jekyll::EntryFilter.
+    #
+    # Returns the instance of Jekyll::EntryFilter for this collection.
+    def entry_filter
+      @entry_filter ||= Jekyll::EntryFilter.new(site, relative_directory)
+    end
+
+    # An inspect string.
+    #
+    # Returns the inspect string
+    def inspect
+      "#<Jekyll::Collection @label=#{label} docs=#{docs}>"
+    end
+
+    # Produce a sanitized label name
+    # Label names may not contain anything but alphanumeric characters,
+    #   underscores, and hyphens.
+    #
+    # label - the possibly-unsafe label
+    #
+    # Returns a sanitized version of the label.
+    def sanitize_label(label)
+      label.gsub(/[^a-z0-9_\-\.]/i, '')
+    end
+
+    # Produce a representation of this Collection for use in Liquid.
+    # Exposes two attributes:
+    #   - label
+    #   - docs
+    #
+    # Returns a representation of this collection for use in Liquid.
+    def to_liquid
+      Drops::CollectionDrop.new self
+    end
+
+    # Whether the collection's documents ought to be written as individual
+    #   files in the output.
+    #
+    # Returns true if the 'write' metadata is true, false otherwise.
+    def write?
+      !!metadata.fetch('output', false)
+    end
+
+    # The URL template to render collection's documents at.
+    #
+    # Returns the URL template to render collection's documents at.
+    def url_template
+      @url_template ||= metadata.fetch('permalink') do
+        Utils.add_permalink_suffix("/:collection/:path", site.permalink_style)
+      end
+    end
+
+    # Extract options for this collection from the site configuration.
+    #
+    # Returns the metadata for this collection
+    def extract_metadata
+      if site.config['collections'].is_a?(Hash)
+        site.config['collections'][label] || {}
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/jekyll/command.rb

@@ -0,0 +1,65 @@
+module Jekyll
+  class Command
+    class << self
+      # A list of subclasses of Jekyll::Command
+      def subclasses
+        @subclasses ||= []
+      end
+
+      # Keep a list of subclasses of Jekyll::Command every time it's inherited
+      # Called automatically.
+      #
+      # base - the subclass
+      #
+      # Returns nothing
+      def inherited(base)
+        subclasses << base
+        super(base)
+      end
+
+      # Run Site#process and catch errors
+      #
+      # site - the Jekyll::Site object
+      #
+      # Returns nothing
+      def process_site(site)
+        site.process
+      rescue Jekyll::Errors::FatalException => e
+        Jekyll.logger.error "ERROR:", "YOUR SITE COULD NOT BE BUILT:"
+        Jekyll.logger.error "", "------------------------------------"
+        Jekyll.logger.error "", e.message
+        exit(1)
+      end
+
+      # Create a full Jekyll configuration with the options passed in as overrides
+      #
+      # options - the configuration overrides
+      #
+      # Returns a full Jekyll configuration
+      def configuration_from_options(options)
+        Jekyll.configuration(options)
+      end
+
+      # Add common options to a command for building configuration
+      #
+      # c - the Jekyll::Command to add these options to
+      #
+      # Returns nothing
+      def add_build_options(c)
+        c.option 'config',  '--config CONFIG_FILE[,CONFIG_FILE2,...]', Array, 'Custom configuration file'
+        c.option 'destination', '-d', '--destination DESTINATION', 'The current folder will be generated into DESTINATION'
+        c.option 'source', '-s', '--source SOURCE', 'Custom source directory'
+        c.option 'future',  '--future', 'Publishes posts with a future date'
+        c.option 'limit_posts', '--limit_posts MAX_POSTS', Integer, 'Limits the number of posts to parse and publish'
+        c.option 'watch',   '-w', '--[no-]watch', 'Watch for changes and rebuild'
+        c.option 'force_polling', '--force_polling', 'Force watch to use polling'
+        c.option 'lsi',     '--lsi', 'Use LSI for improved related posts'
+        c.option 'show_drafts',  '-D', '--drafts', 'Render posts in the _drafts folder'
+        c.option 'unpublished', '--unpublished', 'Render posts that were marked as unpublished'
+        c.option 'quiet',   '-q', '--quiet', 'Silence output.'
+        c.option 'verbose', '-V', '--verbose', 'Print verbose output.'
+        c.option 'incremental', '-I', '--incremental', 'Enable incremental rebuild.'
+      end
+    end
+  end
+end

data/lib/jekyll/commands/build.rb

@@ -0,0 +1,77 @@
+module Jekyll
+  module Commands
+    class Build < Command
+      class << self
+        # Create the Mercenary command for the Jekyll CLI for this Command
+        def init_with_program(prog)
+          prog.command(:build) do |c|
+            c.syntax      'build [options]'
+            c.description 'Build your site'
+            c.alias :b
+
+            add_build_options(c)
+
+            c.action do |_, options|
+              options["serving"] = false
+              Jekyll::Commands::Build.process(options)
+            end
+          end
+        end
+
+        # Build your jekyll site
+        # Continuously watch if `watch` is set to true in the config.
+        def process(options)
+          # Adjust verbosity quickly
+          Jekyll.logger.adjust_verbosity(options)
+
+          options = configuration_from_options(options)
+          site = Jekyll::Site.new(options)
+
+          if options.fetch('skip_initial_build', false)
+            Jekyll.logger.warn "Build Warning:", "Skipping the initial build. This may result in an out-of-date site."
+          else
+            build(site, options)
+          end
+
+          if options.fetch('detach', false)
+            Jekyll.logger.info "Auto-regeneration:", "disabled when running server detached."
+          elsif options.fetch('watch', false)
+            watch(site, options)
+          else
+            Jekyll.logger.info "Auto-regeneration:", "disabled. Use --watch to enable."
+          end
+        end
+
+        # Build your Jekyll site.
+        #
+        # site - the Jekyll::Site instance to build
+        # options - A Hash of options passed to the command
+        #
+        # Returns nothing.
+        def build(site, options)
+          t = Time.now
+          source      = options['source']
+          destination = options['destination']
+          incremental = options['incremental']
+          Jekyll.logger.info "Source:", source
+          Jekyll.logger.info "Destination:", destination
+          Jekyll.logger.info "Incremental build:", (incremental ? "enabled" : "disabled. Enable with --incremental")
+          Jekyll.logger.info "Generating..."
+          process_site(site)
+          Jekyll.logger.info "", "done in #{(Time.now - t).round(3)} seconds."
+        end
+
+        # Private: Watch for file changes and rebuild the site.
+        #
+        # site - A Jekyll::Site instance
+        # options - A Hash of options passed to the command
+        #
+        # Returns nothing.
+        def watch(_site, options)
+          External.require_with_graceful_fail 'jekyll-watch'
+          Jekyll::Watcher.watch(options)
+        end
+      end # end of class << self
+    end
+  end
+end

data/lib/jekyll/commands/clean.rb

@@ -0,0 +1,42 @@
+module Jekyll
+  module Commands
+    class Clean < Command
+      class << self
+        def init_with_program(prog)
+          prog.command(:clean) do |c|
+            c.syntax 'clean [subcommand]'
+            c.description 'Clean the site (removes site output and metadata file) without building.'
+
+            add_build_options(c)
+
+            c.action do |_, options|
+              Jekyll::Commands::Clean.process(options)
+            end
+          end
+        end
+
+        def process(options)
+          options = configuration_from_options(options)
+          destination = options['destination']
+          metadata_file = File.join(options['source'], '.jekyll-metadata')
+
+          if File.directory? destination
+            Jekyll.logger.info "Cleaning #{destination}..."
+            FileUtils.rm_rf(destination)
+            Jekyll.logger.info "", "done."
+          else
+            Jekyll.logger.info "Nothing to do for #{destination}."
+          end
+
+          if File.file? metadata_file
+            Jekyll.logger.info "Removing #{metadata_file}..."
+            FileUtils.rm_rf(metadata_file)
+            Jekyll.logger.info "", "done."
+          else
+            Jekyll.logger.info "Nothing to do for #{metadata_file}."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/commands/doctor.rb

@@ -0,0 +1,114 @@
+module Jekyll
+  module Commands
+    class Doctor < Command
+      class << self
+        def init_with_program(prog)
+          prog.command(:doctor) do |c|
+            c.syntax 'doctor'
+            c.description 'Search site and print specific deprecation warnings'
+            c.alias(:hyde)
+
+            c.option '--config CONFIG_FILE[,CONFIG_FILE2,...]', Array, 'Custom configuration file'
+
+            c.action do |_, options|
+              Jekyll::Commands::Doctor.process(options)
+            end
+          end
+        end
+
+        def process(options)
+          site = Jekyll::Site.new(configuration_from_options(options))
+          site.read
+
+          if healthy?(site)
+            Jekyll.logger.info "Your test results", "are in. Everything looks fine."
+          else
+            abort
+          end
+        end
+
+        def healthy?(site)
+          [
+            fsnotify_buggy?(site),
+            !deprecated_relative_permalinks(site),
+            !conflicting_urls(site),
+            !urls_only_differ_by_case(site)
+          ].all?
+        end
+
+        def deprecated_relative_permalinks(site)
+          if site.config['relative_permalinks']
+            Jekyll::Deprecator.deprecation_message "Your site still uses relative" \
+                                " permalinks, which was removed in" \
+                                " Jekyll v3.0.0."
+            return true
+          end
+        end
+
+        def conflicting_urls(site)
+          conflicting_urls = false
+          urls = {}
+          urls = collect_urls(urls, site.pages, site.dest)
+          urls = collect_urls(urls, site.posts.docs, site.dest)
+          urls.each do |url, paths|
+            next unless paths.size > 1
+            conflicting_urls = true
+            Jekyll.logger.warn "Conflict:", "The URL '#{url}' is the destination" \
+              " for the following pages: #{paths.join(", ")}"
+          end
+          conflicting_urls
+        end
+
+        def fsnotify_buggy?(_site)
+          return true unless Utils::Platforms.osx?
+          if Dir.pwd != `pwd`.strip
+            Jekyll.logger.error "  " + <<-STR.strip.gsub(/\n\s+/, "\n  ")
+              We have detected that there might be trouble using fsevent on your
+              operating system, you can read https://github.com/thibaudgg/rb-fsevent/wiki/no-fsevents-fired-(OSX-bug)
+              for possible work arounds or you can work around it immediately
+              with `--force-polling`.
+            STR
+
+            false
+          end
+
+          true
+        end
+
+        def urls_only_differ_by_case(site)
+          urls_only_differ_by_case = false
+          urls = case_insensitive_urls(site.pages + site.docs_to_write, site.dest)
+          urls.each do |case_insensitive_url, real_urls|
+            next unless real_urls.uniq.size > 1
+            urls_only_differ_by_case = true
+            Jekyll.logger.warn "Warning:", "The following URLs only differ" \
+              " by case. On a case-insensitive file system one of the URLs" \
+              " will be overwritten by the other: #{real_urls.join(", ")}"
+          end
+          urls_only_differ_by_case
+        end
+
+        private
+        def collect_urls(urls, things, destination)
+          things.each do |thing|
+            dest = thing.destination(destination)
+            if urls[dest]
+              urls[dest] << thing.path
+            else
+              urls[dest] = [thing.path]
+            end
+          end
+          urls
+        end
+
+        def case_insensitive_urls(things, destination)
+          things.inject({}) do |memo, thing|
+            dest = thing.destination(destination)
+            (memo[dest.downcase] ||= []) << dest
+            memo
+          end
+        end
+      end
+    end
+  end
+end