jekyll-manager 0.1.0

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

@@ -0,0 +1,110 @@
+module JekyllAdmin
+  class Server < Sinatra::Base
+    namespace "/drafts" 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, document_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
+
+      # return all documents in the 'posts' collection that output to an html
+      # file but reside in a separate directory, `<source_dir>/_drafts/`
+      def drafts
+        posts = site.collections.find { |l, _c| l == "posts" }
+        if posts
+          posts[1].docs.find_all { |d| d.output_ext == ".html" && d.draft? }
+        end
+      end
+
+      # return drafts at the same level as directory
+      def directory_drafts
+        drafts.find_all { |d| File.dirname(d.path) == directory_path }
+      end
+
+      def reverse_sorted_drafts
+        directory_drafts.sort_by(&:date).reverse
+      end
+
+      # returns directories at the root of `/_drafts/` that contain drafts
+      def relevant_directory_paths
+        drafts.map { |doc| relative_draft_path(doc).split("/")[0] }.uniq
+      end
+
+      def relative_draft_path(document)
+        File.dirname(document.relative_path.sub("_drafts/", ""))
+      end
+
+      def ensure_directory
+        ensure_drafts
+        render_404 unless Dir.exist?(directory_path)
+      end
+
+      def ensure_drafts
+        render_404 if drafts.nil?
+      end
+
+      def ensure_html_content
+        return if html_content?
+        content_type :json
+        halt 422, json("error_message" => "Invalid file extension for drafts")
+      end
+
+      def entries
+        args = {
+          :base         => site.source,
+          :content_type => "drafts",
+          :splat        => params["splat"].first,
+        }
+        # get the directories inside the requested directory
+        directory = JekyllAdmin::Directory.new(directory_path, args)
+        directories = directory.directories
+
+        # exclude root level directories which do not have drafts
+        if params["splat"].first.empty?
+          directories = directories.select do |d|
+            relevant_directory_paths.include? d.name.to_s
+          end
+        end
+        # merge directories with the drafts at the same level
+        directories.concat(reverse_sorted_drafts)
+      end
+
+      def html_content?
+        draft = JekyllAdmin::PageWithoutAFile.new(
+          site,
+          site.source,
+          "_drafts",
+          request_payload["path"] || filename
+        )
+        draft.data = request_payload["front_matter"]
+        draft.html?
+      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,82 @@
+module JekyllAdmin
+  class Server < Sinatra::Base
+    namespace "/static_files" do
+      get "/index" do
+        json site.static_files.map(&:to_api)
+      end
+
+      get "/?*" do
+        render_404 unless File.exist?(path)
+        if requested_file
+          json requested_file.to_api(:include_content => true)
+        else
+          json entries.map(&:to_api)
+        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
+
+      # returns relative path of root level directories that contain static files
+      def directory_names
+        static_files.map do |f|
+          File.dirname(f.path.sub("#{site.source}/", "")).split("/")[0]
+        end.uniq
+      end
+
+      def directory_files
+        static_files.find_all do |p|
+          sanitized_path(File.dirname(p.path)) == directory_path
+        end
+      end
+
+      def entries
+        args = {
+          :base         => site.source,
+          :content_type => "static_files",
+          :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 static files
+        if params["splat"].first.empty?
+          directories = directories.select do |d|
+            directory_names.include? d.name.to_s
+          end
+        end
+        directories.concat(directory_files)
+      end
+
+      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.select { |f| f.path.start_with? site.source }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+module JekyllAdmin
+  class Server < Sinatra::Base
+    namespace "/templates" do
+      get "/?" do
+        json template_directories.map(&:to_api)
+      end
+
+      get "/*?/?:path.:ext" do
+        ensure_requested_file
+        api_hash = {
+          :name             => filename,
+          :path             => written_path,
+          :http_url         => http_url,
+          :api_url          => url,
+          :has_front_matter => front_matter?(written_path),
+          :front_matter     => front_matter,
+          :raw_content      => raw_content,
+        }
+        api_hash.merge!(front_matter) if front_matter
+        json api_hash
+      end
+
+      get "/?*" do
+        ensure_directory
+        json dirs.reject { |dir| page_entries_in(dir).empty? }
+          .map(&:to_api)
+          .concat(subdir_entries)
+      end
+
+      put "/*?/?:path.:ext" do
+        if renamed?
+          ensure_requested_file
+          delete_file path
+        end
+
+        write_file write_path, template_body
+        json({
+          :name             => filename,
+          :path             => written_path,
+          :raw_content      => request_payload["raw_content"],
+          :http_url         => http_url,
+          :api_url          => url,
+          :has_front_matter => write_front_matter?,
+        }.merge!(payload_front_matter))
+      end
+
+      delete "/*?/?:path.:ext" do
+        ensure_requested_file
+        delete_file path
+        content_type :json
+        status 200
+        halt
+      end
+
+      private
+
+      def source_dir(dir = "")
+        site.in_source_dir(dir)
+      end
+
+      def requested_file
+        @requested_file = path
+      end
+
+      def dirs
+        args = {
+          :base         => site.source,
+          :content_type => "templates",
+          :splat        => splats.first,
+        }
+        Directory.new(directory_path, args).directories
+      end
+
+      def template_directories
+        regex = %r!(assets|_(includes|layouts|sass))!
+        dirs.find_all do |f|
+          f.name.to_s =~ regex
+        end.sort_by!(&:name)
+      end
+
+      def subdir_entries
+        Dir["#{directory_path}/*"]
+          .reject { |e| File.directory?(e) }
+          .reject { |f| site.static_files.map(&:path).include?(f) }
+          .map! do |e|
+          {
+            :name     => File.basename(e),
+            :path     => sanitized_relative_path(e).sub("/#{splats.first}/", ""),
+            :http_url => http_url(e),
+            :api_url  => api_url(e),
+          }
+        end
+      end
+
+      def front_matter?(file)
+        file_path = sanitized_path(file)
+        if file_contents(file_path) =~ Jekyll::Document::YAML_FRONT_MATTER_REGEXP
+          true
+        else
+          false
+        end
+      end
+
+      def write_front_matter?
+        return false unless request_payload["front_matter"]
+        true
+      end
+
+      def front_matter
+        @front_matter ||= if file_contents =~ Jekyll::Document::YAML_FRONT_MATTER_REGEXP
+                            SafeYAML.load(Regexp.last_match(1))
+                          else
+                            {}
+                          end
+      end
+
+      def raw_content
+        @raw_content ||= if file_contents =~ Jekyll::Document::YAML_FRONT_MATTER_REGEXP
+                           $POSTMATCH
+                         else
+                           file_contents
+                         end
+      end
+
+      def payload_front_matter
+        request_payload["front_matter"] || {}
+      end
+
+      def written_path
+        renamed? ? request_payload["path"] : relative_write_path.sub("/", "")
+      end
+
+      def page_body
+        body = if payload_front_matter && !payload_front_matter.empty?
+                 YAML.dump(payload_front_matter).strip
+               else
+                 "---"
+               end
+        body << "\n---\n\n"
+        body << request_payload["raw_content"].to_s
+        body << "\n"
+      end
+
+      def template_body
+        if request_payload["front_matter"]
+          page_body
+        else
+          body = request_payload["raw_content"].to_s
+          body << "\n"
+        end
+      end
+
+      def directory_path
+        source_dir(splats.first)
+      end
+
+      def splats
+        params["splat"] || ["/"]
+      end
+
+      def api_url(entry)
+        File.join(base_url, "_api", "templates", sanitized_relative_path(entry))
+      end
+
+      def http_url(entry = requested_file)
+        if splats.first.include?("assets") && !Jekyll::Utils.has_yaml_header?(entry)
+          File.join(base_url, sanitized_relative_path(entry))
+        end
+      end
+
+      def ensure_requested_file
+        render_404 unless File.exist?(requested_file)
+      end
+
+      def file_contents(file = requested_file)
+        @file_contents ||= File.read(
+          file, Jekyll::Utils.merged_file_read_opts(site, {})
+        )
+      end
+
+      def page_entries_in(dir)
+        dir.path.children.select do |entry|
+          front_matter?(entry) || in_sass_dir?(entry)
+        end
+      end
+
+      # Jekyll does not consider files without front matter, within `_sass`
+      #   to be 'static files' as of Jekyll 3.5.x, ergo they should be
+      #   editable via the admin interface.
+      def in_sass_dir?(entry)
+        parent_dir = File.dirname(File.dirname(entry)).sub(source_dir, "")
+        parent_dir == "_sass"
+      end
+    end
+  end
+end