cloudcannon-jekyll 0.1.0 → 0.3.2

data/lib/cloudcannon-jekyll/_cloudcannon/details-3.0-4.x.json

@@ -1,26 +1,27 @@
 {
-	"time": {{ site.time | jsonify }},
+	"time": {{ site.time | date_to_xmlschema | cc_jsonify }},
 	"cloudcannon": {
 		"name": "cloudcannon-jekyll",
-		"version": {{ gem_version | jsonify }}
+		"version": {{ gem_version | cc_jsonify }}
 	},
 	"generator": {
 		"name": "jekyll",
-		"version": {{ jekyll.version | jsonify }},
-		"environment": {{ jekyll.env | jsonify }},
+		"version": {{ jekyll.version | cc_jsonify }},
+		"environment": {{ jekyll.env | cc_jsonify }},
 		"metadata": {
-			"markdown": {{ site.markdown | cc_safe_jsonify }},
-			"kramdown": {{ site.kramdown | cc_safe_jsonify }},
-			"commonmark": {{ site.commonmark | cc_safe_jsonify }}
+			"markdown": {{ site.markdown | cc_jsonify }},
+			"kramdown": {{ site.kramdown | cc_jsonify }},
+			"commonmark": {{ site.commonmark | cc_jsonify }}
 		}
 	},{% if site.cloudcannon.data.first %}{% assign data_seen = false %}
 	"data": {
-		{% for data in site.data %}{% assign key = data[0] %}{% if site.cloudcannon.data[key] %}{% if data_seen %},{% endif %}{{ data[0] | cc_safe_jsonify }}: {{ data[1] | cc_safe_jsonify }}{% assign data_seen = true %}{% endif %}{% endfor %}},
-	{% elsif site.cloudcannon.data %}"data": {{ site.data | cc_safe_jsonify }},{% endif %}
+		{% for data in site.data %}{% assign key = data[0] %}{% if site.cloudcannon.data[key] %}{% if data_seen %},{% endif %}{{ data[0] | cc_jsonify }}: {{ data[1] | cc_jsonify }}{% assign data_seen = true %}{% endif %}{% endfor %}},
+	{% elsif site.cloudcannon.data %}"data": {{ site.data | cc_jsonify }},{% endif %}
 	"collections": {
-		{% for collection in site.collections %}"{{ collection.label | xml_escape }}": {{ collection.docs | cc_safe_jsonify }}{% unless forloop.last %},{% endunless %}
+		"drafts": {{ drafts | cc_jsonify }}{% if site.collections.size > 0 %},{% endif %}
+		{% for collection in site.collections %}"{{ collection.label | xml_escape }}": {{ collection.docs | cc_jsonify }}{% unless forloop.last %},{% endunless %}
 		{% endfor %}
 	},
-	"pages": {{ site.pages | cc_safe_jsonify }},
-	"static": {{ site.static_files | cc_static_files_jsonify }}
+	"pages": {{ site.pages | cc_jsonify }},
+	"static-pages": {{ site.static_files | cc_static_files_jsonify }}
 }

data/lib/cloudcannon-jekyll/_cloudcannon/details.json

@@ -1,17 +1,17 @@
 {
-	"time": {{ site.time | jsonify }},
+	"time": {{ site.time | date_to_xmlschema | cc_jsonify }},
 	"cloudcannon": {
 		"name": "cloudcannon-jekyll",
-		"version": {{ gem_version | jsonify }}
+		"version": {{ gem_version | cc_jsonify }}
 	},
 	"generator": {
 		"name": "jekyll",
-		"version": {{ jekyll.version | jsonify }},
-		"environment": {{ jekyll.env | jsonify }},
+		"version": {{ jekyll.version | cc_jsonify }},
+		"environment": {{ jekyll.env | cc_jsonify }},
 		"metadata": {
-			"markdown": {{ site.markdown | cc_safe_jsonify }},
-			"kramdown": {{ site.kramdown | cc_safe_jsonify }},
-			"commonmark": {{ site.commonmark | cc_safe_jsonify }}
+			"markdown": {{ site.markdown | cc_jsonify }},
+			"kramdown": {{ site.kramdown | cc_jsonify }},
+			"commonmark": {{ site.commonmark | cc_jsonify }}
 		}
 	},
 	{% if site.cloudcannon.data.first -%}
@@ -21,20 +21,21 @@
 				{%- assign key = data[0] %}
 				{%- if site.cloudcannon.data[key] %}
 					{%- if data_seen %},{% endif -%}
-					{{ data[0] | cc_safe_jsonify }}: {{ data[1] | cc_safe_jsonify }}
+					{{ data[0] | cc_jsonify }}: {{ data[1] | cc_jsonify }}
 					{%- assign data_seen = true %}
 				{%- endif %}
 			{%- endfor -%}
 		},
 	{% elsif site.cloudcannon.data -%}
-		"data": {{ site.data | cc_safe_jsonify }},
+		"data": {{ site.data | cc_jsonify }},
 	{%- endif %}
 	"collections": {
+		"drafts": {{ drafts | cc_jsonify }}{% if site.collections.size > 0 %},{% endif %}
 		{%- for collection in site.collections -%}
-			"{{ collection.label | xml_escape }}": {{ collection.docs | cc_safe_jsonify }}
+			"{{ collection.label | xml_escape }}": {{ collection.docs | cc_jsonify }}
 			{%- unless forloop.last %},{% endunless %}
 		{%- endfor -%}
 	},
-	"pages": {{ site.pages | cc_safe_jsonify }},
-	"static": {{ site.static_files | cc_static_files_jsonify }}
+	"pages": {{ site.pages | cc_jsonify }},
+	"static-pages": {{ site.static_files | cc_static_files_jsonify }}
 }

data/lib/cloudcannon-jekyll/configuration.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module CloudCannonJekyll
+  # Processes Jekyll configuration to enable the plugin is run and fix common issues
   class Configuration
     def self.processed?(site)
       site.instance_variable_get(:@_cloudcannon_jekyll_processed) == true
@@ -16,7 +17,7 @@ module CloudCannonJekyll
       config = config.fix_common_issues if config.respond_to? :fix_common_issues
       config = config.add_default_excludes if config.respond_to? :add_default_excludes
 
-      key = Jekyll::VERSION.start_with?("2") ? "gems" : "plugins"
+      key = Jekyll::VERSION.start_with?("2.") ? "gems" : "plugins"
 
       config[key] = Array(config[key])
       config[key].push("cloudcannon-jekyll") unless config[key].include? "cloudcannon-jekyll"

data/lib/cloudcannon-jekyll/generator.rb

@@ -2,33 +2,133 @@
 
 require "jekyll"
 require "fileutils"
+require_relative "reader"
 
 module CloudCannonJekyll
+  # Generates JSON files containing build config and build output details
   class Generator < Jekyll::Generator
     priority :lowest
 
     def generate(site)
       @site = site
+      @reader = Reader.new(@site)
 
-      details_data = { "gem_version" => CloudCannonJekyll::VERSION }
+      collections_config = @site.config["collections"].dup || {}
 
-      generate_file("details", @site.site_payload.merge(details_data))
-      generate_file("config", @site.site_payload)
+      # Workaround for empty collection configurations
+      collections_config.each_key do |key|
+        collections_config[key] ||= { "output" => false }
+      end
 
-      @site.keep_files ||= []
-      @site.keep_files << path("details")
-      @site.keep_files << path("config")
+      payload = @site.site_payload.merge({
+        "gem_version" => CloudCannonJekyll::VERSION,
+      })
+
+      drafts = add_blogging_config(collections_config)
+      add_collection_paths(collections_config)
+      add_data_config(collections_config)
+
+      generate_file("config", payload.merge({
+        "pwd"         => Dir.pwd,
+        "config"      => @site.config,
+        "collections" => collections_config,
+      }))
+
+      generate_file("details", payload.merge({
+        "drafts" => drafts,
+      }))
+    end
+
+    def collections_dir
+      return "" if Jekyll::VERSION.start_with? "2."
+
+      @site.config["collections_dir"] || ""
+    end
+
+    def data_dir
+      @site.config["data_dir"] || "_data"
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def add_category_folder_config(collections_config, posts_config = {})
+      posts = @site.posts || @site.collections["posts"]
+      docs = posts.class.method_defined?(:docs) ? posts.docs : posts
+      seen = {}
+
+      docs.map do |post|
+        parts = post.relative_path.split("/_posts/")
+        path = parts.first
+
+        # Ignore unless it's an unseen category folder post
+        next if parts.length < 2 || path.empty? || seen[path]
+
+        # Could check this to ensure raw files exist since posts can be generated without files
+        # next if @reader.read_posts(parts[0]).empty?
+
+        seen[path] = true
+        folder = path.sub(%r!^\/+!, "")
+        collections_path = "#{collections_dir}/#{folder}".gsub(%r!\/+!, "/").sub(%r!^\/+!, "")
+
+        collections_config["#{folder}/posts"] = posts_config.merge({
+          "_path" => "#{collections_path}/_posts",
+        })
+
+        # Adding the category draft config like this isn't ideal, since you could have drafts
+        #  without posts, but it's a decent trade off vs looking for _drafts folders
+        collections_config["#{folder}/drafts"] = posts_config.merge({
+          "_path" => "#{collections_path}/_drafts",
+        })
+
+        path
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # Add data to collections config if raw data files exist
+    def add_data_config(collections_config)
+      data_files = @reader.read_data(data_dir)
+      collections_config["data"] = { "_path" => data_dir } if data_files&.keys&.any?
+    end
+
+    # Add posts/drafts to collections config
+    def add_blogging_config(collections_config)
+      collections_config["posts"] = { "output" => true } if Jekyll::VERSION.start_with? "2."
+      drafts = @reader.read_drafts(collections_dir)
+
+      if collections_config.key?("posts")
+        collections_config["drafts"] = collections_config["posts"].dup
+      elsif drafts.any?
+        collections_config["drafts"] = {}
+      end
+
+      folders = add_category_folder_config(collections_config, collections_config["posts"])
+      folders.compact.each do |folder|
+        drafts += @reader.read_drafts(folder)
+      end
+
+      drafts
+    end
+
+    # Add _path to each collection config
+    def add_collection_paths(collections_config)
+      collections_config.each do |key, collection|
+        next if collection.key?("_path")
+
+        collection["_path"] = File.join(collections_dir, "_#{key}").sub(%r!^\/+!, "")
+      end
     end
 
     def generate_file(filename, data)
       dest = destination_path(filename)
       FileUtils.mkdir_p(File.dirname(dest))
-      File.open(dest, "w") { |f| f.write(file_content(filename, data)) }
+      File.open(dest, "w") { |file| file.write(file_content(filename, data)) }
+      @site.keep_files ||= []
+      @site.keep_files << path(filename)
     end
 
     def version_path_suffix
       return "-2.x" if Jekyll::VERSION.start_with? "2."
-      return "-3.0-4.x" if Jekyll::VERSION.match? %r!3\.[0-4]\.!
+      return "-3.0-4.x" if %r!3\.[0-4]\.! =~ Jekyll::VERSION
 
       ""
     end
@@ -46,13 +146,13 @@ module CloudCannonJekyll
     end
 
     def file_content(filename, data)
-      json = PageWithoutAFile.new(@site, File.dirname(__FILE__), "", path(filename))
-      json.content = File.read(source_path(filename))
-      json.data["layout"] = nil
-      json.data["sitemap"] = false
-      json.data["permalink"] = "/#{path(filename)}"
-      json.render({}, data)
-      json.output
+      page = PageWithoutAFile.new(@site, File.dirname(__FILE__), "", path(filename))
+      page.content = File.read(source_path(filename))
+      page.data["layout"] = nil
+      page.data["sitemap"] = false
+      page.data["permalink"] = "/#{path(filename)}"
+      page.render({}, data)
+      page.output
     end
   end
 end

data/lib/cloudcannon-jekyll/jsonify-filter.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "jekyll"
+
+module CloudCannonJekyll
+  # Filter for converting Jekyll objects into JSON
+  module JsonifyFilter
+    STATIC_EXTENSIONS = [".html", ".htm"].freeze
+
+    CC_JSONIFY_KEY_SWAPS = {
+      "collections" => {
+        "_sort_key"      => "_sort-key",
+        "_subtext_key"   => "_subtext-key",
+        "_image_key"     => "_image-key",
+        "_image_size"    => "_image-size",
+        "_singular_name" => "_singular-name",
+        "_singular_key"  => "_singular-key",
+        "_disable_add"   => "_disable-add",
+        "_add_options"   => "_add-options",
+      },
+    }.freeze
+
+    @simple_types = [
+      String,
+      Numeric,
+      Integer,
+      Float,
+      Date,
+      Time,
+      NilClass,
+      Object.const_defined?("Fixnum") ? Fixnum : nil,
+    ].compact.freeze
+
+    @document_types = [
+      Jekyll::Document,
+      Jekyll::Page,
+      Jekyll::VERSION.start_with?("2.") ? Jekyll::Post : nil,
+    ].compact.freeze
+
+    def self.document_type?(input)
+      @document_types.include?(input.class)
+    end
+
+    def self.simple_type?(input)
+      @simple_types.include?(input.class) || [true, false].include?(input)
+    end
+
+    def self.static_file_to_json(input, depth, max_depth)
+      path = input.relative_path.sub(%r!^\/+!, "")
+      url = Jekyll::VERSION.start_with?("2.") ? "/#{path}" : input.url
+
+      out = [
+        "\"path\": #{JsonifyFilter.to_json(path, depth, max_depth)}",
+        "\"url\": #{JsonifyFilter.to_json(url, depth, max_depth)}",
+      ]
+
+      "{#{out.join(",")}}"
+    end
+
+    def self.document_data_to_a(data, prevent, depth, max_depth)
+      prevent += %w(content output next previous excerpt)
+
+      out = data.map do |key, value|
+        next if prevent.include? key
+
+        prevent.push key
+        "#{key.to_json}: #{JsonifyFilter.to_json(value, depth, max_depth)}"
+      end
+
+      out.compact
+    end
+
+    def self.legacy_post_to_json(input, depth, max_depth)
+      prevent = %w(dir name path url date id categories tags)
+
+      out = [
+        "\"name\": #{JsonifyFilter.to_json(input.name, depth, max_depth)}",
+        "\"path\": #{JsonifyFilter.to_json(input.path, depth, max_depth)}",
+        "\"url\": #{JsonifyFilter.to_json(input.url, depth, max_depth)}",
+        "\"date\": #{JsonifyFilter.to_json(input.date, depth, max_depth)}",
+        "\"id\": #{JsonifyFilter.to_json(input.id, depth, max_depth)}",
+        "\"categories\": #{JsonifyFilter.to_json(input.categories, depth, max_depth)}",
+        "\"tags\": #{JsonifyFilter.to_json(input.tags, depth, max_depth)}",
+      ]
+
+      out += JsonifyFilter.document_data_to_a(input.data, prevent, depth, max_depth)
+      "{#{out.join(",")}}"
+    end
+
+    def self.page_to_json(input, depth, max_depth)
+      prevent = %w(dir name path url)
+
+      out = [
+        "\"name\": #{JsonifyFilter.to_json(input.name, depth, max_depth)}",
+        "\"path\": #{JsonifyFilter.to_json(input.path, depth, max_depth)}",
+        "\"url\": #{JsonifyFilter.to_json(input.url, depth, max_depth)}",
+      ]
+
+      # Merge Jekyll Defaults into data for pages (missing at v3.8.5)
+      defaults = input.site.frontmatter_defaults.all(input.relative_path, :pages).tap do |default|
+        default.delete("date")
+      end
+
+      data = Jekyll::Utils.deep_merge_hashes(defaults, input.data)
+
+      out += JsonifyFilter.document_data_to_a(data, prevent, depth, max_depth)
+      "{#{out.join(",")}}"
+    end
+
+    def self.document_to_json(input, depth, max_depth)
+      prevent = %w(dir id relative_path url collection)
+
+      out = [
+        "\"path\": #{JsonifyFilter.to_json(input.relative_path, depth, max_depth)}",
+        "\"url\": #{JsonifyFilter.to_json(input.url, depth, max_depth)}",
+      ]
+
+      collection = input.collection
+      unless collection.nil?
+        collection_json = JsonifyFilter.to_json(collection.label, depth, max_depth)
+        out.push("\"collection\": #{collection_json}")
+      end
+
+      out += JsonifyFilter.document_data_to_a(input.data, prevent, depth, max_depth)
+      "{#{out.join(",")}}"
+    end
+
+    def self.array_to_json(input, depth, max_depth, key_swaps = {})
+      array = input.map do |value|
+        JsonifyFilter.to_json(value, depth, max_depth, key_swaps)
+      end
+
+      "[#{array.join(",")}]"
+    end
+
+    def self.hash_to_json(input, depth, max_depth, key_swaps = {})
+      out = input.map do |key, value|
+        string_key = (key_swaps[key] || key).to_s.to_json
+        "#{string_key}: #{JsonifyFilter.to_json(value, depth, max_depth, key_swaps)}"
+      end
+
+      "{#{out.join(",")}}"
+    end
+
+    def self.config_to_select_data_json(input, depth)
+      prevent = %w(source destination collections_dir cache_dir plugins_dir layouts_dir data_dir
+                   includes_dir collections safe include exclude keep_files encoding markdown_ext
+                   strict_front_matter show_drafts limit_posts future unpublished whitelist
+                   plugins markdown highlighter lsi excerpt_separator incremental detach port host
+                   baseurl show_dir_listing permalink paginate_path timezone quiet verbose defaults
+                   liquid kramdown title url description uploads_dir _comments _options _editor
+                   _explore _source_editor _array_structures maruku redcloth rdiscount redcarpet
+                   gems plugins)
+
+      out = input.map do |key, value|
+        next unless value.is_a?(Array) || value.is_a?(Hash)
+        next if prevent.include? key
+
+        prevent.push key
+        "#{key.to_s.to_json}: #{JsonifyFilter.to_json(value, depth)}"
+      end
+
+      out.compact!
+
+      "{#{out.join(",")}}" if out.any?
+    end
+
+    def self.to_json(input, depth, max_depth = 9, key_swaps = {})
+      depth += 1
+
+      if depth > max_depth || (depth > 3 && JsonifyFilter.document_type?(input))
+        '"MAXIMUM_DEPTH"'
+      elsif JsonifyFilter.simple_type?(input)
+        input.to_json
+      elsif input.is_a?(Jekyll::StaticFile)
+        JsonifyFilter.static_file_to_json(input, depth, max_depth)
+      elsif input.is_a?(Jekyll::Page)
+        JsonifyFilter.page_to_json(input, depth, max_depth)
+      elsif Jekyll::VERSION.start_with?("2.") && input.is_a?(Jekyll::Post)
+        JsonifyFilter.legacy_post_to_json(input, depth, max_depth)
+      elsif input.is_a?(Jekyll::Document)
+        JsonifyFilter.document_to_json(input, depth, max_depth)
+      elsif input.is_a?(Array)
+        JsonifyFilter.array_to_json(input, depth, max_depth, key_swaps)
+      elsif input.is_a?(Hash)
+        JsonifyFilter.hash_to_json(input, depth, max_depth, key_swaps)
+      else
+        input.class.to_s.prepend("UNSUPPORTED:").to_json
+      end
+    end
+
+    def cc_static_files_jsonify(input)
+      out = input.map do |page|
+        JsonifyFilter.to_json(page, 1) if STATIC_EXTENSIONS.include?(page.extname)
+      end
+
+      out.compact!
+
+      "[#{out.join(",")}]"
+    end
+
+    def cc_select_data_jsonify(input)
+      if input.key? "_select_data"
+        JsonifyFilter.to_json(input["_select_data"], 0)
+      else
+        JsonifyFilter.config_to_select_data_json(input, 0)
+      end
+    end
+
+    def cc_jsonify(input, key_swaps_key = nil, max_depth = 8)
+      if CC_JSONIFY_KEY_SWAPS.key? key_swaps_key
+        JsonifyFilter.to_json(input, 0, max_depth, CC_JSONIFY_KEY_SWAPS[key_swaps_key])
+      else
+        JsonifyFilter.to_json(input, 0, max_depth)
+      end
+    end
+  end
+end