jekyll-admin-josercc 0.5.2

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,57 @@
+module JekyllAdmin
+  class Server < Sinatra::Base
+    namespace "/configuration" do
+      get do
+        json({
+          :content     => parsed_configuration,
+          :raw_content => raw_configuration,
+        })
+      end
+
+      put do
+        write_file(configuration_path, configuration_body)
+        json request_payload
+      end
+
+      private
+
+      def overrides
+        {
+          "source" => sanitized_path("/"),
+        }
+      end
+
+      # Computed configuration, with updates and defaults
+      def configuration
+        @configuration ||= Jekyll.configuration(overrides)
+      end
+
+      # Configuration data, as read by Jekyll
+      def parsed_configuration
+        configuration.read_config_file(configuration_path)
+      end
+
+      # Raw configuration content, as it sits on disk
+      def raw_configuration
+        File.read(
+          configuration_path,
+          Jekyll::Utils.merged_file_read_opts(site, {})
+        )
+      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
+      # Instead of extracting `raw_content` directly from the `request_payload`,
+      #   assign the data to a new variable and then extract the `raw_content`
+      #   from it to circumvent CORS violation in `development` mode.
+      def configuration_body
+        payload = request_payload
+        payload["raw_content"]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+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 "/*?/?: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
+        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
+
+      # returns relative path of root level directories that contain data files
+      def directory_paths
+        DataFile.all.map { |p| File.dirname(p.relative_path).split("/")[0] }.uniq
+      end
+
+      def directory_pages
+        DataFile.all.find_all do |p|
+          sanitized_path(File.dirname(p.path)) == directory_path
+        end
+      end
+
+      def entries
+        args = {
+          :base         => sanitized_path(DataFile.data_dir),
+          :content_type => "data",
+          :splat        => splats.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 data files
+        if splats.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
+
+      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
+
+      def splats
+        params["splat"] || ["/"]
+      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/server.rb

@@ -0,0 +1,100 @@
+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(restored_front_matter).strip
+                 .gsub(": 'null'", ": null") # restore null values
+             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
+
+    # verbose 'null' values in front matter
+    def restored_front_matter
+      front_matter.map do |key, value|
+        value = "null" if value.nil?
+        [key, value]
+      end.to_h
+    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/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)
+        "/data/#{relative_path}"
+      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.5.2".freeze
+end

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