jekyll-manager 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0d0ed1d6abe3190db2e01c9b5f6f1e161c94ac67
+  data.tar.gz: 95725959f6f2d1f3bc41e8d31c4f4dc7044ea198
+SHA512:
+  metadata.gz: 8adc158be57c256dfd4182efd28f351324beec4c56ff1e37aa974a842d944143dc8b7009be239856e07f616490677ae95c3ebca5787e65ab8bfb52d305b9dcc4
+  data.tar.gz: 208927717049efaa4e0a435078dcf8036c33a42eefbc07c206eadf457d1fce3a1bd044e0ffaa2948ceb7c54a345fe23c5028c5c2cecc614a12feb009fcbea0d4

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright 2016-2017 Mert Kahyaoğlu and the Jekyll Admin contributors
+Copyright 2017 Ashwin Maroli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,63 @@
+[![Gem Version](https://img.shields.io/gem/v/jekyll-manager.svg)](https://rubygems.org/gems/jekyll-manager)
+[![Build Status](https://travis-ci.org/ashmaroli/jekyll-manager.svg?branch=master)](https://travis-ci.org/ashmaroli/jekyll-manager)
+[![Build status](https://ci.appveyor.com/api/projects/status/biop1r6ae524xlm2/branch/master?svg=true)](https://ci.appveyor.com/project/ashmaroli/jekyll-manager/branch/master)
+[![Coverage Status](https://coveralls.io/repos/github/ashmaroli/jekyll-manager/badge.svg?branch=master)](https://coveralls.io/github/ashmaroli/jekyll-manager?branch=master)
+[![NPM Dependencies](https://david-dm.org/ashmaroli/jekyll-manager.svg)](https://david-dm.org/ashmaroli/jekyll-manager)
+
+Forked from the official Jekyll plugin [Jekyll Admin](https://github.com/jekyll/jekyll-admin), Jekyll Manager provides users with a traditional CMS-style graphical interface to author content and administer Jekyll sites.<br/>
+The project is divided into two parts. A Ruby-based HTTP API that handles Jekyll and filesystem operations, and a Javascript-based front end, built on that API.
+
+![screenshot of Jekyll Manager](/screenshot.png)
+
+## Installation
+
+Refer to the [installing plugins](https://jekyllrb.com/docs/plugins/#installing-a-plugin) section of Jekyll's documentation and install the `jekyll-manager` plugin as you would any other plugin. Here's the short version:
+
+1. Add the following to your site's Gemfile:
+
+    ```ruby
+    gem 'jekyll-manager', group: :jekyll_plugins
+    ```
+
+2. Run `bundle install`
+
+## Usage
+
+1. Start Jekyll as you would normally (`bundle exec jekyll serve`)
+2. Navigate to `http://localhost:4000/admin` to access the administrative interface
+
+
+## Divergence
+
+Jekyll Manager is an open source project, forked from the official Jekyll plugin [Jekyll Admin](https://github.com/jekyll/jekyll-admin), and repackaged with some alterations and additions, a few of which, may eventually be included in the official version.
+
+### Notable alterations:
+
+  * Sidebar routes cannot be manually hidden. They're rendered based on whether Jekyll has read-in at least one file of the concerned type.
+  * Routes to Collections other than Posts are hidden within a collapsed list-item by default.
+  * Metadata fields for front matter are hidden with a collapsed section by default.
+  * Input path fields show / require the full `relative_path` of the requested file.
+  * Minor style changes.
+  * Other miscellaneous changes.
+
+### Additional Features:
+
+  * A basic dashboard that provides insight on the current site and a means to add files to cetain empty content types (*Pages, Posts, Data Files, Static Files*).
+  * Draft posts can be created and edited via the admin interface provided your config file has `show_drafts: true`
+  * Template files (files within `_layouts`, `_includes`, `_sass` and `assets` at the root of your site) can be edited via the interface.
+  * Template files (and files within any directory) within a theme-gem can be *viewed* and copied over to the source directory for editing.
+  * Ability to select layouts for a document based on available layouts in the Site.
+  * Special metadata field for tags.
+
+
+## Contributing
+
+Unless your contribution improves the changes outlined above or updates this repo's documentation, we'd appreciate it if you propose those changes at the upstream repo. Upstream changes *may* eventually find their way here after being altered as
+required.
+
+Interested in contributing to Jekyll Manager anyways?. See [the contributing instructions](.github/CONTRIBUTING.md), and [the development docs](http://ashmaroli.github.io/jekyll-manager/development/) for more information.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/jekyll-admin.rb

@@ -0,0 +1,47 @@
+# Default Sinatra to "production" mode (surpress errors) unless
+# otherwise specified by the `RACK_ENV` environmental variable.
+# Must be done prior to requiring Sinatra, or we'll get a LoadError
+# as it looks for sinatra/cross-origin, which is development only
+ENV["RACK_ENV"] = "production" if ENV["RACK_ENV"].to_s.empty?
+
+require "oj" # Optimized JSON. https://github.com/ohler55/oj
+require "jekyll"
+require "base64"
+require "webrick"
+require "sinatra"
+require "fileutils"
+require "sinatra/base"
+require "sinatra/json"
+require "addressable/uri"
+require "sinatra/reloader"
+require "sinatra/namespace"
+
+module JekyllAdmin
+  autoload :APIable,          "jekyll-admin/apiable"
+  autoload :DataFile,         "jekyll-admin/data_file"
+  autoload :Directory,        "jekyll-admin/directory"
+  autoload :FileHelper,       "jekyll-admin/file_helper"
+  autoload :PageWithoutAFile, "jekyll-admin/page_without_a_file"
+  autoload :PathHelper,       "jekyll-admin/path_helper"
+  autoload :Server,           "jekyll-admin/server"
+  autoload :StaticServer,     "jekyll-admin/static_server"
+  autoload :URLable,          "jekyll-admin/urlable"
+  autoload :Version,          "jekyll-admin/version"
+
+  def self.site
+    @site ||= begin
+      site = Jekyll.sites.first
+      site.future = true
+      site
+    end
+  end
+end
+
+# Monkey Patches
+require_relative "./jekyll/commands/serve"
+require_relative "./jekyll/commands/build"
+
+[Jekyll::Page, Jekyll::Document, Jekyll::StaticFile, Jekyll::Collection].each do |klass|
+  klass.include JekyllAdmin::APIable
+  klass.include JekyllAdmin::URLable
+end

data/lib/jekyll-admin/apiable.rb

@@ -0,0 +1,167 @@
+module JekyllAdmin
+  # Abstract module to be included in Convertible and Document to provide
+  # additional, API-specific functionality without duplicating logic
+  module APIable
+
+    CONTENT_FIELDS = %w(next previous content excerpt).freeze
+
+    # Returns a hash suitable for use as an API response.
+    #
+    # For Documents and Pages:
+    #
+    # 1. Adds the file's raw content to the `raw_content` field
+    # 2. Adds the file's raw YAML front matter to the `front_matter` field
+    #
+    # For Static Files it addes the Base64 `encoded_content` field
+    #
+    # Options:
+    #
+    # include_content - if true, includes the content in the respond, false by default
+    #                   to support mapping on indexes where we only want metadata
+    #
+    #
+    # Returns a hash (which can then be to_json'd)
+    def to_api(include_content: false)
+      output = hash_for_api
+      output = output.merge(url_fields)
+
+      # Include content, if requested, otherwise remove it
+      if include_content
+        output = output.merge(content_fields)
+      else
+        CONTENT_FIELDS.each { |field| output.delete(field) }
+      end
+
+      # Documents have duplicate output and content fields, Pages do not
+      # Since it's an API, use `content` in both for consistency
+      output.delete("output")
+
+      # By default, calling to_liquid on a collection will return a docs
+      # array with each rendered document, which we don't want.
+      if is_a?(Jekyll::Collection)
+        output.delete("docs")
+        output["entries_url"] = entries_url
+      end
+
+      if is_a?(Jekyll::Document)
+        output["name"] = basename
+        output["modified_time"] = mtime
+        output["relative_path"] = relative_path.sub("_drafts/", "") if draft?
+      end
+
+      if is_a?(Jekyll::StaticFile)
+        output["from_theme"] = from_theme_gem?
+      end
+
+      output
+    end
+
+    private
+
+    # Pages don't have a hash method, but Documents do
+    def file_path
+      if is_a?(Jekyll::Document)
+        path
+      else
+        File.join(@base, @dir, name)
+      end
+    end
+
+    def from_theme_gem?
+      @base == site.in_theme_dir
+    end
+
+    # StaticFiles don't have `attr_accesor` set for @site or @name
+    def site
+      @site
+    end
+
+    def name
+      @name
+    end
+
+    def mtime
+      @mtime ||= File.stat(file_path).mtime
+    end
+
+    def file_contents
+      @file_contents ||= File.read(file_path, file_read_options) if file_exists?
+    end
+
+    def file_read_options
+      Jekyll::Utils.merged_file_read_opts(site, {})
+    end
+
+    def front_matter
+      return unless file_exists?
+      @front_matter ||= if file_contents =~ Jekyll::Document::YAML_FRONT_MATTER_REGEXP
+                          SafeYAML.load(Regexp.last_match(1))
+                        else
+                          {}
+                        end
+    end
+
+    def raw_content
+      return unless file_exists?
+      @raw_content ||= if file_contents =~ Jekyll::Document::YAML_FRONT_MATTER_REGEXP
+                         $POSTMATCH
+                       else
+                         file_contents
+                       end
+    end
+
+    def encoded_content
+      @encoded_content ||= Base64.encode64(file_contents) if file_exists?
+    end
+
+    def file_exists?
+      return @file_exists if defined? @file_exists
+      @file_exists = File.exist?(file_path)
+    end
+
+    # Base hash from which to generate the API output
+    def hash_for_api
+      output = to_liquid
+      if output.respond_to?(:hash_for_json)
+        output.hash_for_json
+      else
+        output.to_h
+      end
+    end
+
+    # Returns a hash of content fields for inclusion in the API output
+    def content_fields
+      output = {}
+
+      # Include file content-related fields
+      if is_a?(Jekyll::StaticFile)
+        output["encoded_content"] = encoded_content
+      elsif is_a?(JekyllAdmin::DataFile)
+        output["content"] = content
+        output["raw_content"] = raw_content
+      else
+        output["raw_content"] = raw_content
+        output["front_matter"] = front_matter
+      end
+
+      # Include next and previous documents non-recursively
+      if is_a?(Jekyll::Document)
+        %w(next previous).each do |direction|
+          method = "#{direction}_doc".to_sym
+          doc = public_send(method)
+          output[direction] = doc.to_api if doc
+        end
+      end
+
+      output
+    end
+
+    def url_fields
+      return {} unless respond_to?(:http_url) && respond_to?(:api_url)
+      {
+        "http_url" => http_url,
+        "api_url"  => api_url,
+      }
+    end
+  end
+end

data/lib/jekyll-admin/data_file.rb

@@ -0,0 +1,103 @@
+module JekyllAdmin
+  class DataFile
+    METHODS_FOR_LIQUID = %w(path relative_path slug ext title).freeze
+    EXTENSIONS = %w(yaml yml json csv).freeze
+
+    include APIable
+    include URLable
+    include PathHelper
+    extend PathHelper
+
+    attr_reader :id
+
+    # Initialize a new DataFile object
+    #
+    # id - the file ID as passed from the API. This may or may not have an extension
+    def initialize(id)
+      @id ||= File.extname(id).empty? ? "#{id}.yml" : id
+    end
+    alias_method :relative_path, :id
+
+    def exists?
+      @exists ||= File.exist?(absolute_path)
+    end
+
+    # Returns unparsed content as it exists on disk
+    def raw_content
+      @raw_content ||= File.open(absolute_path, "r:UTF-8", &:read)
+    end
+
+    # Returnes (re)parsed content using Jekyll's native parsing mechanism
+    def content
+      @content ||= data_reader.read_data_file(absolute_path)
+    end
+
+    # Returns the file's extension with preceeding `.`
+    def ext
+      @ext ||= if File.extname(id).to_s.empty?
+                 ".yml"
+               else
+                 File.extname(id)
+               end
+    end
+    alias_method :extension, :ext
+
+    # Returns the file's sanitized slug (as used in `site.data[slug]`)
+    def slug
+      @slug ||= data_reader.sanitize_filename(basename)
+    end
+
+    # Returns the human-readable title of the data file
+    def title
+      @title ||= Jekyll::Utils.titleize_slug(slug.tr("_", "-"))
+    end
+
+    # Returns path relative to site source
+    def path
+      ensure_leading_slash(File.join(DataFile.data_dir, relative_path))
+    end
+
+    def absolute_path
+      sanitized_path(path)
+    end
+    alias_method :file_path, :absolute_path
+
+    # Mimics Jekyll's native to_liquid functionality by returning a hash
+    # of data file metadata
+    def to_liquid
+      @to_liquid ||= METHODS_FOR_LIQUID.map { |key| [key, public_send(key)] }.to_h
+    end
+
+    def self.all
+      data_dir = Jekyll.sanitized_path(JekyllAdmin.site.source, DataFile.data_dir)
+      data_dir = Pathname.new(data_dir)
+      Dir["#{data_dir}/**/*.{#{EXTENSIONS.join(",")}}"].map do |path|
+        new(Pathname.new(path).relative_path_from(data_dir).to_s)
+      end
+    end
+
+    # Relative path to data directory within site source
+    def self.data_dir
+      JekyllAdmin.site.config["data_dir"]
+    end
+
+    private
+
+    def data_reader
+      @data_reader = Jekyll::DataReader.new(JekyllAdmin.site)
+    end
+
+    def basename
+      @basename ||= File.basename(id, ".*")
+    end
+
+    def basename_with_extension
+      [basename, extension].join
+    end
+    alias_method :filename, :basename_with_extension
+
+    def namespace
+      "data"
+    end
+  end
+end

data/lib/jekyll-admin/directory.rb

@@ -0,0 +1,73 @@
+module JekyllAdmin
+  class Directory
+    extend Forwardable
+    def_delegator :@path, :basename, :name
+    def_delegator :@path, :mtime, :modified_time
+    attr_reader :path, :splat, :content_type, :base
+
+    include Enumerable
+    include JekyllAdmin::URLable
+    include JekyllAdmin::APIable
+
+    TYPE = :directory
+
+    # Arguments:
+    #
+    # path - full path of the directory which its entries will be listed
+    #
+    # base - passes site.source to generate `relative_path` needed for `to_api`
+    #
+    # content_type - type of the requested directory entries, this is used to generate
+    # API endpoint of the directory along with `splat`
+    #
+    # splat - the requested directory path relative to content namespace
+    def initialize(path, base: nil, content_type: nil, splat: nil)
+      @base = Pathname.new base
+      @content_type = content_type
+      @splat = Pathname.new splat
+      @path = Pathname.new path
+    end
+
+    def to_liquid
+      {
+        :name          => name,
+        :modified_time => modified_time,
+        :path          => relative_path,
+        :type          => TYPE,
+      }
+    end
+
+    def relative_path
+      if content_type == "drafts"
+        path.relative_path_from(base).to_s.sub("_drafts/", "")
+      else
+        path.relative_path_from(base).to_s
+      end
+    end
+
+    def resource_path
+      types = %w(pages data drafts static_files templates theme)
+      if types.include?(content_type)
+        "/#{content_type}/#{splat}/#{name}"
+      else
+        "/collections/#{content_type}/entries/#{splat}/#{name}"
+      end
+    end
+    alias_method :url, :resource_path
+
+    def http_url
+      nil
+    end
+
+    def directories
+      path.entries.map do |entry|
+        next if [".", ".."].include? entry.to_s
+        next unless path.join(entry).directory?
+        self.class.new(
+          path.join(entry),
+          :base => base, :content_type => content_type, :splat => splat
+        )
+      end.compact!
+    end
+  end
+end