jekyll-admin-jekyll34 0.4.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d8124bc411abc6a87061492925eeed477af37be3
+  data.tar.gz: 96b42b2a0e3dbea0fa13d0a3c1992cf5a5f806bc
+SHA512:
+  metadata.gz: 0f90c23700c917732f7c331881c36c96bfcc19b3041b2d3db5d16c61f4de4fcc32695d16e5f86abee191f093d6da2f480371edee4af6fa189fcc0c0b23609261
+  data.tar.gz: 1ac6b6c139cfb3a75d904735ea44ef7787d57777fff95951ac5193631647d01a04731afe3b737f8d5d620398332da07866421284ea0f85d7ea5487d8920a657b

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright 2017 Mert Kahyaoğlu and the Jekyll Admin contributors
+
+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,37 @@
+[![Gem Version](https://img.shields.io/gem/v/jekyll-admin.svg)](https://rubygems.org/gems/jekyll-admin)
+[![Build Status](https://travis-ci.org/jekyll/jekyll-admin.svg?branch=master)](https://travis-ci.org/jekyll/jekyll-admin)
+[![Build status](https://ci.appveyor.com/api/projects/status/biop1r6ae524xlm2/branch/master?svg=true)](https://ci.appveyor.com/project/benbalter/jekyll-admin/branch/master)
+[![NPM Dependencies](https://david-dm.org/jekyll/jekyll-admin.svg)](https://david-dm.org/jekyll/jekyll-admin)
+
+A Jekyll plugin that provides users with a traditional CMS-style graphical interface to author content and administer Jekyll sites. 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 Admin](/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-admin` plugin as you would any other plugin. Here's the short version:
+
+1. Add the following to your site's Gemfile:
+
+    ```ruby
+    gem 'jekyll-admin', 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
+
+## Contributing
+
+Interested in contributing to Jekyll Admin? We’d love your help. Jekyll Admin is an open source project, built one contribution at a time by users like you. See [the contributing instructions](.github/CONTRIBUTING.md), and [the development docs](http://jekyll.github.io/jekyll-admin/development/) for more information.
+
+## Looking for a hosted version?
+
+Jekyll Admin is intended to be run on your computer alongside your local Jekyll installation. If you're looking for a hosted version, we'd recommend checking out [Siteleaf](https://www.siteleaf.com/) a hosted Jekyll editor with deep GitHub integration (whom we'd also like to thank for inspiring parts of Jekyll Admin itself!).
+
+## 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 "json"
+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,153 @@
+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
+      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
+
+    # StaticFiles don't have `attr_accesor` set for @site or @name
+    def site
+      @site
+    end
+
+    def name
+      @name
+    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,91 @@
+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
+
+    alias_method :path, :relative_path
+
+    # 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 ||= id
+    end
+
+    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
+
+    # 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 = sanitized_path DataFile.data_dir
+      Dir["#{data_dir}/*.{#{EXTENSIONS.join(",")}}"].map do |path|
+        new path_without_site_source(path)
+      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,68 @@
+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
+      path.relative_path_from(base).to_s
+    end
+
+    def resource_path
+      if content_type == "pages"
+        "/pages/#{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

data/lib/jekyll-admin/file_helper.rb

@@ -0,0 +1,64 @@
+module JekyllAdmin
+  module FileHelper
+
+    # The file the user requested in the URL
+    def requested_file
+      find_by_path(path)
+    end
+
+    # The file ultimately written to disk
+    # This may be the requested file, or in the case of a rename will be read
+    # from the new path that was actually written to disk
+    def written_file
+      find_by_path(write_path)
+    end
+
+    # Write a file to disk with the given content
+    def write_file(path, content)
+      Jekyll.logger.debug "WRITING:", path
+      path = sanitized_path(path)
+      FileUtils.mkdir_p File.dirname(path)
+      File.write(path, content)
+      site.process
+    end
+
+    # Delete the file at the given path
+    def delete_file(path)
+      Jekyll.logger.debug "DELETING:", path
+      FileUtils.rm_f sanitized_path(path)
+      site.process
+    end
+
+    private
+
+    def ensure_requested_file
+      ensure_file(requested_file)
+    end
+
+    def ensure_written_file
+      ensure_file(written_file)
+    end
+
+    def find_by_path(path)
+      files = case namespace
+              when "collections"
+                collection.docs
+              when "data"
+                DataFile.all
+              when "pages", "static_files"
+                site.public_send(namespace.to_sym)
+              else
+                []
+              end
+      files.find { |f| sanitized_path(f.path) == path }
+    end
+
+    def ensure_file(file)
+      render_404 if file.nil?
+    end
+
+    def ensure_directory
+      render_404 unless Dir.exist?(directory_path)
+    end
+  end
+end

data/lib/jekyll-admin/page_without_a_file.rb

@@ -0,0 +1,7 @@
+module JekyllAdmin
+  class PageWithoutAFile < Jekyll::Page
+    def read_yaml(*)
+      @data ||= {}
+    end
+  end
+end

data/lib/jekyll-admin/path_helper.rb

@@ -0,0 +1,74 @@
+module JekyllAdmin
+  module PathHelper
+    def sanitized_path(path)
+      path = path_without_site_source(path)
+      Jekyll.sanitized_path JekyllAdmin.site.source, path
+    end
+
+    # Returns the basename + extension for the requested file
+    def filename
+      params["ext"] ||= "yml" if namespace == "data"
+      "#{params["path"]}.#{params["ext"]}"
+    end
+
+    # Returns the sanitized path relative to the site source
+    def sanitized_relative_path(path)
+      path_without_site_source sanitized_path(path)
+    end
+
+    # Returns the sanitized absolute path to the requested object
+    def absolute_path
+      sanitized_path File.join(directory_path, filename)
+    end
+    alias_method :path, :absolute_path
+
+    # Returns the sanitized relative path to the requested object
+    def relative_path
+      sanitized_relative_path absolute_path
+    end
+
+    # Returns the sanitized absolute path to write the requested object
+    def write_path
+      if renamed?
+        sanitized_path request_payload["path"]
+      else
+        path
+      end
+    end
+    alias_method :request_path, :write_path
+
+    # Returns the sanitized relative path to write the requested object
+    def relative_write_path
+      sanitized_relative_path write_path
+    end
+
+    # Is this request renaming a file?
+    def renamed?
+      return false unless request_payload["path"]
+      ensure_leading_slash(request_payload["path"]) != relative_path
+    end
+
+    private
+
+    # Returns the path to the requested file's containing directory
+    def directory_path
+      case namespace
+      when "collections"
+        sanitized_path File.join(collection.relative_directory, params["splat"].first)
+      when "data"
+        sanitized_path File.join(DataFile.data_dir)
+      else
+        sanitized_path params["splat"].first
+      end
+    end
+
+    def ensure_leading_slash(input)
+      return input if input.nil? || input.empty? || input.start_with?("/")
+      "/#{input}"
+    end
+
+    def path_without_site_source(path)
+      path.to_s.gsub(%r!\A#{Regexp.escape(JekyllAdmin.site.source)}!, "")
+    end
+  end
+end

data/lib/jekyll-admin/server.rb

@@ -0,0 +1,91 @@
+module JekyllAdmin
+  class Server < Sinatra::Base
+    ROUTES = %w(collections configuration data pages static_files).freeze
+    include JekyllAdmin::PathHelper
+    include JekyllAdmin::FileHelper
+
+    register Sinatra::Namespace
+
+    configure :development do
+      register Sinatra::Reloader
+      enable :logging
+    end
+
+    configure :development, :test do
+      require "sinatra/cross_origin"
+      register Sinatra::CrossOrigin
+      enable  :cross_origin
+      disable :allow_credentials
+      set :allow_methods, %i(delete get options post put)
+    end
+
+    get "/" do
+      json ROUTES.map { |r| ["#{r}_api", URI.join(base_url, "/_api/", r)] }.to_h
+    end
+
+    # CORS preflight
+    options "*" do
+      render_404 unless settings.development? || settings.test?
+      status 204
+    end
+
+    private
+
+    def site
+      JekyllAdmin.site
+    end
+
+    def render_404
+      status 404
+      content_type :json
+      halt
+    end
+
+    def request_payload
+      @request_payload ||= if request_body.to_s.empty?
+                             {}
+                           else
+                             JSON.parse(request_body)
+                           end
+    end
+
+    def base_url
+      "#{request.scheme}://#{request.host_with_port}"
+    end
+
+    def front_matter
+      request_payload["front_matter"]
+    end
+
+    def document_body
+      body = if front_matter && !front_matter.empty?
+               YAML.dump(front_matter).strip
+             else
+               "---"
+             end
+      body << "\n---\n\n"
+      body << request_payload["raw_content"].to_s
+    end
+    alias page_body document_body
+
+    private
+
+    def request_body
+      @request_body ||= begin
+        request.body.rewind
+        request.body.read
+      end
+    end
+
+    def namespace
+      namespace = request.path_info.split("/")[1].to_s.downcase
+      namespace if ROUTES.include?(namespace)
+    end
+  end
+end
+
+require "jekyll-admin/server/collection"
+require "jekyll-admin/server/configuration"
+require "jekyll-admin/server/data"
+require "jekyll-admin/server/page"
+require "jekyll-admin/server/static_file"

data/lib/jekyll-admin/server/collection.rb

@@ -0,0 +1,82 @@
+module JekyllAdmin
+  class Server < Sinatra::Base
+    namespace "/collections" do
+      get do
+        json(site.collections.map { |c| c[1].to_api })
+      end
+
+      get "/:collection_id" do
+        ensure_collection
+        json collection.to_api
+      end
+
+      get "/:collection_id/*?/?:path.:ext" do
+        ensure_requested_file
+        json requested_file.to_api(:include_content => true)
+      end
+
+      get "/:collection_id/entries/?*" do
+        ensure_directory
+        json entries.map(&:to_api)
+      end
+
+      put "/:collection_id/*?/?:path.:ext" do
+        ensure_collection
+
+        if renamed?
+          ensure_requested_file
+          delete_file path
+        end
+
+        write_file write_path, document_body
+        json written_file.to_api(:include_content => true)
+      end
+
+      delete "/:collection_id/*?/?:path.:ext" do
+        ensure_requested_file
+        delete_file path
+        content_type :json
+        status 200
+        halt
+      end
+
+      private
+
+      def collection
+        collection = site.collections.find { |l, _c| l == params["collection_id"] }
+        collection[1] if collection
+      end
+
+      def document_id
+        path = "#{params["splat"].first}/#{filename}"
+        path.gsub(%r!(\d{4})/(\d{2})/(\d{2})/(.*)!, '\1-\2-\3-\4')
+      end
+
+      def directory_docs
+        collection.docs.find_all { |d| File.dirname(d.path) == directory_path }
+      end
+
+      def ensure_collection
+        render_404 if collection.nil?
+      end
+
+      def ensure_directory
+        ensure_collection
+        render_404 unless Dir.exist?(directory_path)
+      end
+
+      def entries
+        args = {
+          :base         => site.source,
+          :content_type => params["collection_id"],
+          :splat        => params["splat"].first,
+        }
+        # get the directories inside the requested directory
+        directory = JekyllAdmin::Directory.new(directory_path, args)
+        directories = directory.directories
+        # merge directories with the documents at the same level
+        directories.concat(directory_docs.sort_by(&:date).reverse)
+      end
+    end
+  end
+end

data/lib/jekyll-admin/server/configuration.rb

@@ -0,0 +1,42 @@
+module JekyllAdmin
+  class Server < Sinatra::Base
+    namespace "/configuration" do
+      get do
+        json raw_configuration.to_liquid
+      end
+
+      put do
+        write_file(configuration_path, configuration_body)
+        json raw_configuration.to_liquid
+      end
+
+      private
+
+      def overrides
+        {
+          "source" => sanitized_path("/"),
+        }
+      end
+
+      # Computed configuration, with updates and defaults
+      def configuration
+        @configuration ||= Jekyll.configuration(overrides)
+      end
+
+      # Raw configuration, as it sits on disk
+      def raw_configuration
+        configuration.read_config_file(configuration_path)
+      end
+
+      # Returns the path to the *first* config file discovered
+      def configuration_path
+        sanitized_path configuration.config_files(overrides).first
+      end
+
+      # The user's uploaded configuration for updates
+      def configuration_body
+        YAML.dump request_payload
+      end
+    end
+  end
+end

data/lib/jekyll-admin/server/data.rb

@@ -0,0 +1,45 @@
+module JekyllAdmin
+  class Server < Sinatra::Base
+    # supported extensions, in order of preference, for now, no .csv
+    EXTENSIONS = %w(yml json).freeze
+
+    namespace "/data" do
+      get do
+        json DataFile.all.map(&:to_api)
+      end
+
+      get "/:path.?:ext?" do
+        ensure_requested_file
+        json requested_file.to_api(:include_content => true)
+      end
+
+      put "/:path.?:ext?" do
+        if renamed?
+          ensure_requested_file
+          delete_file path
+        end
+
+        write_file write_path, data_file_body
+        json written_file.to_api(:include_content => true)
+      end
+
+      delete "/:path.?:ext?" do
+        ensure_requested_file
+        delete_file path
+        content_type :json
+        status 200
+        halt
+      end
+
+      private
+
+      def data_file_body
+        if !request_payload["raw_content"].to_s.empty?
+          request_payload["raw_content"]
+        elsif !request_payload["content"].to_s.empty?
+          YAML.dump(request_payload["content"]).sub(%r!\A---\n!, "")
+        end
+      end
+    end
+  end
+end

data/lib/jekyll-admin/server/page.rb

@@ -0,0 +1,90 @@
+module JekyllAdmin
+  class Server < Sinatra::Base
+    namespace "/pages" do
+      get "/*?/?:path.:ext" do
+        ensure_requested_file
+        json requested_file.to_api(:include_content => true)
+      end
+
+      get "/?*" do
+        ensure_directory
+        json entries.map(&:to_api)
+      end
+
+      put "/*?/?:path.:ext" do
+        ensure_html_content
+
+        if renamed?
+          ensure_requested_file
+          delete_file path
+        end
+
+        write_file write_path, page_body
+
+        json written_file.to_api(:include_content => true)
+      end
+
+      delete "/*?/?:path.:ext" do
+        ensure_requested_file
+        delete_file path
+        content_type :json
+        status 200
+        halt
+      end
+
+      private
+
+      def ensure_html_content
+        return if html_content?
+        content_type :json
+        halt 422, json("error_message" => "Invalid file extension for pages")
+      end
+
+      def html_content?
+        page = JekyllAdmin::PageWithoutAFile.new(
+          site,
+          site.source,
+          "",
+          request_payload["path"] || filename
+        )
+        page.data = request_payload["front_matter"]
+        page.html?
+      end
+
+      def pages
+        site.pages.select(&:html?)
+      end
+
+      def directory_pages
+        pages.find_all do |p|
+          sanitized_path(File.dirname(p.path)) == directory_path
+        end
+      end
+
+      # returns relative path of root level directories that contain pages
+      def directory_paths
+        pages.map { |p| File.dirname(p.path).split("/")[0] }.uniq
+      end
+
+      def entries
+        args = {
+          :base         => site.source,
+          :content_type => "pages",
+          :splat        => params["splat"].first,
+        }
+        # get all directories inside the requested directory
+        directory = JekyllAdmin::Directory.new(directory_path, args)
+        directories = directory.directories
+
+        # exclude root level directories which do not have pages
+        if params["splat"].first.empty?
+          directories = directories.select do |d|
+            directory_paths.include? d.name.to_s
+          end
+        end
+        # merge directories with the pages at the same level
+        directories.concat(directory_pages)
+      end
+    end
+  end
+end

data/lib/jekyll-admin/server/static_file.rb

@@ -0,0 +1,61 @@
+module JekyllAdmin
+  class Server < Sinatra::Base
+    namespace "/static_files" do
+      get do
+        json static_files.map(&:to_api)
+      end
+
+      get "/*" do
+        if requested_file
+          json requested_file.to_api(:include_content => true)
+        elsif !static_files_for_path.empty?
+          json static_files_for_path.map(&:to_api)
+        else
+          render_404
+        end
+      end
+
+      put "/*" do
+        if renamed?
+          ensure_requested_file
+          delete_file path
+        end
+
+        write_file(write_path, static_file_body)
+        json written_file.to_api(:include_content => true)
+      end
+
+      delete "/*" do
+        ensure_requested_file
+        delete_file path
+        content_type :json
+        status 200
+        halt
+      end
+
+      private
+
+      def static_file_body
+        if !request_payload["raw_content"].to_s.empty?
+          request_payload["raw_content"].to_s
+        else
+          Base64.decode64 request_payload["encoded_content"].to_s
+        end
+      end
+
+      def static_files
+        site.static_files
+      end
+
+      def file_list_dir(path) end
+
+      def static_files_for_path
+        # Joined with / to ensure user can't do partial paths
+        base_path = File.join(path, "/")
+        static_files.select do |f|
+          f.path.start_with? base_path
+        end
+      end
+    end
+  end
+end

data/lib/jekyll-admin/static_server.rb

@@ -0,0 +1,24 @@
+module JekyllAdmin
+  class StaticServer < Sinatra::Base
+    set :public_dir, File.expand_path("./public", File.dirname(__FILE__))
+
+    MUST_BUILD_MESSAGE = "Front end not yet built. Run `script/build` to build.".freeze
+
+    # Allow `/admin` and `/admin/`, and `/admin/*` to serve `/public/dist/index.html`
+    get "/*" do
+      send_file index_path
+    end
+
+    # Provide a descriptive error message in dev. if frontend is not build
+    not_found do
+      status 404
+      MUST_BUILD_MESSAGE if settings.development? || settings.test?
+    end
+
+    private
+
+    def index_path
+      @index_path ||= File.join(settings.public_folder, "index.html")
+    end
+  end
+end

data/lib/jekyll-admin/urlable.rb

@@ -0,0 +1,65 @@
+module JekyllAdmin
+  # Abstract module to be included in Convertible and Document to provide
+  # additional, URL-specific functionality without duplicating logic
+  module URLable
+
+    # Absolute URL to the HTTP(S) rendered/served representation of this resource
+    def http_url
+      return if is_a?(Jekyll::Collection) || is_a?(JekyllAdmin::DataFile)
+      return if is_a?(Jekyll::Document) && !collection.write?
+      @http_url ||= Addressable::URI.new(
+        :scheme => scheme, :host => host, :port => port,
+        :path => path_with_base(JekyllAdmin.site.config["baseurl"], url)
+      ).normalize.to_s
+    end
+
+    # Absolute URL to the API representation of this resource
+    def api_url
+      @api_url ||= Addressable::URI.new(
+        :scheme => scheme, :host => host, :port => port,
+        :path => path_with_base("/_api", resource_path)
+      ).normalize.to_s
+    end
+
+    def entries_url
+      return unless is_a?(Jekyll::Collection)
+      "#{api_url}/entries"
+    end
+
+    private
+
+    # URL path relative to `_api/` to retreive the given resource via the API
+    # Note: we can't use a case statement here, because === doesn't like includes
+    def resource_path
+      if is_a?(Jekyll::Document)
+        "/collections/#{relative_path.sub(%r!\A_!, "")}"
+      elsif is_a?(Jekyll::Collection)
+        "/collections/#{label}"
+      elsif is_a?(JekyllAdmin::DataFile)
+        relative_path.sub(%r!\A/#{DataFile.data_dir}!, "/data")
+      elsif is_a?(Jekyll::StaticFile)
+        "/static_files/#{relative_path}"
+      elsif is_a?(Jekyll::Page)
+        "/pages/#{relative_path}"
+      end
+    end
+
+    # URI.join doesn't like joining two relative paths, and File.join may join
+    # with `\` rather than with `/` on windows
+    def path_with_base(base, path)
+      [base, path].join("/").squeeze("/")
+    end
+
+    def scheme
+      JekyllAdmin.site.config["scheme"] || "http"
+    end
+
+    def host
+      JekyllAdmin.site.config["host"].sub("127.0.0.1", "localhost")
+    end
+
+    def port
+      JekyllAdmin.site.config["port"]
+    end
+  end
+end

data/lib/jekyll-admin/version.rb

@@ -0,0 +1,3 @@
+module JekyllAdmin
+  VERSION = "0.4.3".freeze
+end

data/lib/jekyll/commands/build.rb

@@ -0,0 +1,14 @@
+module Jekyll
+  module Commands
+    class Build < Command
+      class << self
+        alias_method :original_build, :build
+
+        def build(site, options)
+          options["watch"] = false
+          original_build(site, options)
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/commands/serve.rb

@@ -0,0 +1,24 @@
+module Jekyll
+  module Commands
+    class Serve < Command
+      class << self
+        def start_up_webrick(opts, destination)
+          server = WEBrick::HTTPServer.new(webrick_opts(opts)).tap { |o| o.unmount("") }
+          server.mount(opts["baseurl"], Servlet, destination, file_handler_opts)
+
+          jekyll_admin_monkey_patch(server)
+
+          Jekyll.logger.info "Server address:", server_address(server, opts)
+          launch_browser server, opts if opts["open_url"]
+          boot_or_detach server, opts
+        end
+
+        def jekyll_admin_monkey_patch(server)
+          server.mount "/admin", Rack::Handler::WEBrick, JekyllAdmin::StaticServer
+          server.mount "/_api",  Rack::Handler::WEBrick, JekyllAdmin::Server
+          Jekyll.logger.info "JekyllAdmin mode:", ENV["RACK_ENV"] || "production"
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,207 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-admin-jekyll34
+version: !ruby/object:Gem::Version
+  version: 0.4.3
+platform: ruby
+authors:
+- Mert Kahyaoğlu
+- GitHub Open Source
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-04-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: sinatra-contrib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.35'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.35'
+- !ruby/object:Gem::Dependency
+  name: sinatra-cross_origin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: Jekyll::Admin is a drop in administrative framework for Jekyll sites.
+email:
+- mertkahyaoglu93@gmail.com
+- opensource@github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/jekyll-admin.rb
+- lib/jekyll-admin/apiable.rb
+- lib/jekyll-admin/data_file.rb
+- lib/jekyll-admin/directory.rb
+- lib/jekyll-admin/file_helper.rb
+- lib/jekyll-admin/page_without_a_file.rb
+- lib/jekyll-admin/path_helper.rb
+- lib/jekyll-admin/server.rb
+- lib/jekyll-admin/server/collection.rb
+- lib/jekyll-admin/server/configuration.rb
+- lib/jekyll-admin/server/data.rb
+- lib/jekyll-admin/server/page.rb
+- lib/jekyll-admin/server/static_file.rb
+- lib/jekyll-admin/static_server.rb
+- lib/jekyll-admin/urlable.rb
+- lib/jekyll-admin/version.rb
+- lib/jekyll/commands/build.rb
+- lib/jekyll/commands/serve.rb
+homepage: https://github.com/honey-be/jekyll-admin-jekyll34
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: wp-admin for Jekyll, but better
+test_files: []