jekyll-admin 0.8.0 → 0.10.2

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

@@ -1,82 +1,84 @@
-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_without_process 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
+# frozen_string_literal: true
+
+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_without_process 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         => site.in_source_dir(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/{draft.rb → drafts.rb}

@@ -1,110 +1,114 @@
-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_without_process 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
+# frozen_string_literal: true
+
+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 new?
+          ensure_not_overwriting_existing_file
+        elsif renamed?
+          ensure_requested_file
+          ensure_not_overwriting_existing_file
+          delete_file_without_process 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" }
+        posts[1].docs.find_all { |d| d.output_ext == ".html" && d.draft? } if posts
+      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.in_source_dir("_drafts"),
+          :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 = Jekyll::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 → pages.rb}

@@ -1,90 +1,109 @@
-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_without_process 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
+# frozen_string_literal: true
+
+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 new?
+          ensure_not_overwriting_existing_file
+        elsif renamed?
+          ensure_requested_file
+          ensure_not_overwriting_existing_file
+          delete_file_without_process 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 = Jekyll::PageWithoutAFile.new(
+          site,
+          site.source,
+          "",
+          request_payload["path"] || filename
+        )
+        page.data = request_payload["front_matter"]
+        page.html?
+      end
+
+      def pages
+        site.pages.select { |p| html_page_at_source?(p) }
+      end
+
+      # Test if a given page is *physically located* within the source directory and outputs
+      # to an HTML file.
+      # We don't want *virtual pages* that are generated via plugins.
+      def html_page_at_source?(page)
+        return false unless page.html?
+
+        # If page is not an instance of a `Jekyll::Page` subclass, then it needs additional
+        # inspection.
+        # Can't use `is_a?(Jekyll::Page)` here because it returns true for subclass instances
+        return true if page.class == Jekyll::Page
+
+        File.exist?(site.in_source_dir(page.relative_path))
+      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