cloudcannon-jekyll 2.3.4 → 3.0.0

data/lib/cloudcannon-jekyll/generator.rb

@@ -1,281 +1,53 @@
 # frozen_string_literal: true
 
-require "jekyll"
-require "fileutils"
-require_relative "reader"
+require 'jekyll'
+require 'json'
+require 'fileutils'
+require_relative 'logger'
+require_relative 'config'
+require_relative 'generators/info'
 
 module CloudCannonJekyll
-  # Generates JSON files containing build config and build output details
+  # Generates JSON file with build information
   class Generator < Jekyll::Generator
-    # Override the Jekyll::Plugin spaceship to push our plugin to the very end
     priority :lowest
+
+    # Override the Jekyll::Plugin spaceship to run at the end
     def self.<=>(*)
       1
     end
 
-    # rubocop:disable Metrics/MethodLength
     def generate(site)
-      log "⭐️ Starting #{"cloudcannon-jekyll".blue}"
-
+      Logger.info "⭐️ Starting #{'cloudcannon-jekyll'.blue}"
       @site = site
-      @reader = Reader.new(@site)
-
-      migrate_legacy_config
-      pages = generate_pages
-      collections_config = generate_collections_config(pages)
-      drafts = add_blogging_config(collections_config)
-      add_collection_paths(collections_config)
-
-      collections = generate_collections(collections_config, pages, drafts)
-      remove_empty_collection_config(collections_config, collections)
-
-      add_data_config(collections_config)
-      data = generate_data
-
-      generate_file("info", @site.site_payload.merge({
-        "pwd"                => Dir.pwd,
-        "version"            => "0.0.2",
-        "gem_version"        => CloudCannonJekyll::VERSION,
-        "config"             => @site.config,
-        "collections_config" => collections_config,
-        "collections"        => collections,
-        "data"               => data,
-      }))
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    # rubocop:disable Metrics/CyclomaticComplexity
-    def generate_collections_config(pages)
-      collections = @site.config["collections"]&.dup || {}
-      collections_config = @site.config.dig("cloudcannon", "collections")&.dup || {}
-
-      collections.each_key do |key|
-        # Workaround for empty collection configurations
-        defaults = collections[key] || { "output" => false }
-        collections_config[key] = (collections_config[key] || {}).merge(defaults)
-      end
-
-      unless pages.empty? || collections.key?("pages")
-        pages_defaults = {
-          "output" => true,
-          "filter" => "strict",
-          "path"   => "",
-        }
-
-        collections_config["pages"] = pages_defaults.merge(collections_config["pages"] || {})
-      end
-
-      collections_config
-    end
-
-    # rubocop:disable Metrics/PerceivedComplexity
-    def generate_collections(collections_config, pages, drafts)
-      split_posts = group_by_category_folder(all_posts, "posts")
-      split_drafts = group_by_category_folder(drafts, "drafts")
-
-      collections = {}
-      collections_config.each_key do |key|
-        collections[key] = if key == "posts" || key.end_with?("/posts")
-                             split_posts[key]
-                           elsif key == "drafts" || key.end_with?("/drafts")
-                             split_drafts[key]
-                           else
-                             @site.collections[key]&.docs
-                           end
-
-        collections[key] ||= []
-      end
-
-      has_collection_pages = collections.key?("pages") && !collections["pages"].empty?
-      collections["pages"] = pages unless pages.empty? || has_collection_pages
-      collections
-    end
-    # rubocop:enable Metrics/PerceivedComplexity
-    # rubocop:enable Metrics/CyclomaticComplexity
-
-    def generate_data
-      cc_data = @site.config.dig("cloudcannon", "data")
-      data = if cc_data == true
-               @site.data&.dup
-             elsif cc_data&.is_a?(Hash)
-               @site.data&.select { |key, _| cc_data.key?(key) }
-             end
-
-      data ||= {}
-      data["categories"] ||= @site.categories.keys
-      data["tags"] ||= @site.tags.keys
-
-      data.each_key do |key|
-        log "💾 Processed #{key.bold} data set"
-      end
-
-      data
-    end
-
-    def generate_pages
-      html_pages = @site.pages.select do |page|
-        page.html? || page.url.end_with?("/")
-      end
-
-      static_pages = @site.static_files.select do |static_page|
-        JsonifyFilter::STATIC_EXTENSIONS.include?(static_page.extname)
-      end
-
-      html_pages + static_pages
-    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
-
-    def all_posts
-      posts = @site.posts || @site.collections["posts"]
-      posts.class.method_defined?(:docs) ? posts.docs : posts
-    end
-
-    def group_by_category_folder(collection, key)
-      split_path = "/_#{key}/"
-      collection.group_by do |doc|
-        parts = doc.relative_path.split(split_path)
-        if parts.length > 1
-          "#{parts.first}/#{key}".sub(%r!^\/+!, "")
-        else
-          key
-        end
-      end
-    end
-
-    def add_category_folder_config(collections_config, posts_config = {})
-      seen = {}
-
-      all_posts.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
-
-    def remove_empty_collection_config(collections_config, collections)
-      cc_collections = @site.config.dig("cloudcannon", "collections") || {}
-
-      collections_config.each_key do |key|
-        if collections[key].empty? && !cc_collections.key?(key)
-          log "📂 #{"Ignored".yellow} #{key.bold} collection"
-          collections_config.delete(key)
-        else
-          log "📁 Processed #{key.bold} collection with #{collections[key]&.length || 0} files"
-        end
-      end
-    end
-
-    def migrate_legacy_config
-      add_legacy_explore_groups
-    end
-
-    # Support for the deprecated _explore configuration
-    def add_legacy_explore_groups
-      unless @site.config.key?("_collection_groups")
-        @site.config["_collection_groups"] = @site.config.dig("_explore", "groups")&.dup
-      end
-    end
-
-    # 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 drafts.any? && !collections_config.key?("drafts")
-        collections_config["drafts"] = { "output" => !!@site.show_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|
-        collection["path"] ||= File.join(collections_dir, "_#{key}").sub(%r!^\/+!, "")
-      end
+      config = Config.new(site)
+      generate_file('info', Info.new.generate_info(site, config.read))
     end
 
     def generate_file(filename, data)
       dest = destination_path(filename)
       FileUtils.mkdir_p(File.dirname(dest))
-      File.open(dest, "w") { |file| file.write(file_content(filename, data)) }
+      File.open(dest, 'w') { |file| file.write(file_content(data)) }
       @site.keep_files ||= []
       @site.keep_files << path(filename)
-      log "🏁 Generated #{path(filename).bold} #{"successfully".green}"
-    end
-
-    def log(str)
-      Jekyll.logger.info("CloudCannon:", str)
-    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]\.!
-
-      ""
+      Logger.info "🏁 Generated #{path(filename).bold} #{'successfully'.green}"
     end
 
-    def path(filename, suffix = "")
-      "_cloudcannon/#{filename}#{suffix}.json"
+    def path(filename)
+      "_cloudcannon/#{filename}.json"
     end
 
     def source_path(filename)
-      File.expand_path(path(filename, version_path_suffix), File.dirname(__FILE__))
+      file_path = path(filename)
+      File.expand_path(file_path, File.dirname(__FILE__))
     end
 
     def destination_path(filename)
       Jekyll.sanitized_path(@site.dest, path(filename))
     end
 
-    def file_content(filename, data)
-      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
+    def file_content(data)
+      JSON.pretty_generate(data)
     end
   end
 end

data/lib/cloudcannon-jekyll/generators/collections.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative '../readers/reader'
+require_relative '../logger'
+require_relative 'paths'
+
+module CloudCannonJekyll
+  STATIC_EXTENSIONS = ['.html', '.htm'].freeze
+  IS_JEKYLL_2_X_X = Jekyll::VERSION.start_with?('2.').freeze
+  IS_JEKYLL_3_04_X = Jekyll::VERSION.match?(/3\.[0-4]\./).freeze
+
+  # Helper functions for generating collection configuration and summaries
+  class Collections
+    def initialize(site, config)
+      @site = site
+      @config = config
+      @reader = Reader.new(site)
+      @collections_dir = Paths.collections_dir(site)
+      @data_dir = Paths.data_dir(site)
+      @split_posts = group_by_category_folder(all_posts, 'posts')
+      @split_drafts = group_by_category_folder(all_drafts, 'drafts')
+    end
+
+    def generate_collections_config
+      collections = @site.config['collections'] || {}
+      collections_config = @config['collections_config']&.dup || {}
+
+      return collections_config if @config['collections_config_override']
+
+      if collections.is_a?(Array)
+        collections = collections.each_with_object({}) { |key, memo| memo[key] = {} }
+      end
+
+      defaults = {
+        'data' => {
+          'path' => @data_dir,
+          'output' => false
+        },
+        'posts' => {
+          'output' => true
+        },
+        'drafts' => {
+          'output' => !!@site.show_drafts
+        }
+      }
+
+      unless collections.key?('pages') && !collections['pages'].empty?
+        defaults['pages'] = {
+          'path' => '',
+          'output' => true,
+          'filter' => 'strict'
+        }
+      end
+
+      collection_keys = (defaults.keys + collections.keys).uniq
+
+      collection_keys.each do |key|
+        processed = (defaults[key] || {})
+                    .merge(collections[key] || {})
+                    .merge(collections_config[key] || {})
+
+        processed['output'] ||= false
+        processed['auto_discovered'] = !collections_config.key?(key)
+        processed['path'] ||= File.join(@collections_dir, "_#{key}")
+        processed['path'] = processed['path'].sub(%r{^/+}, '')
+
+        Config.rename_legacy_collection_config_keys(processed)
+
+        collections_config[key] = processed
+      end
+
+      @split_posts.each_key do |key|
+        posts_path = @split_posts[key]&.first&.relative_path&.sub(%r{(^|/)_posts.*}, '\1_posts')
+        next unless posts_path
+
+        defaults = {
+          'auto_discovered' => !collections_config.key?(key),
+          'path' => File.join(@collections_dir, posts_path).sub(%r{^/+}, ''),
+          'output' => true
+        }
+
+        collections_config[key] = defaults.merge(collections_config[key] || {})
+      end
+
+      @split_drafts.each_key do |key|
+        drafts_path = @split_drafts[key]&.first&.relative_path&.sub(%r{(^|/)_drafts.*}, '\1_drafts')
+        next unless drafts_path
+
+        defaults = {
+          'auto_discovered' => !collections_config.key?(key),
+          'path' => File.join(@collections_dir, drafts_path).sub(%r{^/+}, ''),
+          'output' => !!@site.show_drafts
+        }
+
+        collections_config[key] = defaults.merge(collections_config[key] || {})
+      end
+
+      collections_config
+    end
+
+    def drafts_paths
+      paths = @split_posts.keys.map do |key|
+        File.join('/', @collections_dir, key.sub(/posts$/, '_drafts'))
+      end
+
+      paths.empty? ? [File.join('/', @collections_dir, '_drafts')] : paths
+    end
+
+    def generate_collections(collections_config)
+      collections = {}
+
+      collections_config.each_key do |key|
+        next if key == 'data'
+
+        collections[key] = if key == 'posts' || key.end_with?('/posts')
+                             @split_posts[key]
+                           elsif key == 'drafts' || key.end_with?('/drafts')
+                             @split_drafts[key]
+                           else
+                             @site.collections[key]&.docs
+                           end
+
+        collections[key] ||= []
+        collections[key] = collections[key].map do |doc|
+          document_to_json(doc, key)
+        end
+      end
+
+      if collections.key?('pages') && collections['pages'].empty?
+        collections['pages'] = all_pages.map do |doc|
+          document_to_json(doc, 'pages')
+        end
+      end
+
+      collections
+    end
+
+    def remove_empty_collection_config(collections_config, collections)
+      collections_config.each do |key, collection_config|
+        should_delete = if key == 'data'
+                          !data_files?
+                        else
+                          collections[key].empty? && collection_config['auto_discovered']
+                        end
+
+        if should_delete
+          Logger.info "📂 #{'Ignored'.yellow} #{key.bold} collection"
+          collections_config.delete(key)
+        else
+          count = collections[key]&.length || 0
+          Logger.info "📁 Processed #{key.bold} collection with #{count} files"
+        end
+      end
+    end
+
+    def document_type(doc)
+      if IS_JEKYLL_2_X_X && (doc.instance_of?(Jekyll::Post) || doc.instance_of?(Jekyll::Draft))
+        :posts
+      elsif doc.respond_to? :type
+        doc.type
+      elsif doc.respond_to?(:collection)
+        doc.collection.label.to_sym
+      elsif doc.instance_of?(Jekyll::Page)
+        :pages
+      end
+    end
+
+    def legacy_document_data(doc)
+      data = doc.data.merge(
+        {
+          categories: doc.categories,
+          tags: doc.tags,
+          date: doc.date
+        }
+      )
+
+      data['slug'] = doc.slug if doc.respond_to?(:slug)
+      data
+    end
+
+    def legacy_doc?(doc)
+      (IS_JEKYLL_3_04_X && doc.instance_of?(Jekyll::Document) && doc.collection.label == 'posts') ||
+        (IS_JEKYLL_2_X_X && (doc.instance_of?(Jekyll::Draft) || doc.instance_of?(Jekyll::Post)))
+    end
+
+    def document_data(doc)
+      data = if legacy_doc?(doc)
+               legacy_document_data(doc)
+             elsif doc.respond_to?(:data)
+               doc.data
+             else
+               {}
+             end
+
+      defaults = @site.frontmatter_defaults.all(doc.relative_path, document_type(doc))
+      defaults.merge(data)
+    end
+
+    def document_url(doc)
+      doc.respond_to?(:url) ? doc.url : doc.relative_path
+    end
+
+    def document_path(doc)
+      path = if doc.respond_to?(:collection) && doc.collection
+               File.join(@collections_dir, doc.relative_path)
+             else
+               doc.relative_path
+             end
+
+      path.sub(%r{^/+}, '')
+    end
+
+    def document_to_json(doc, collection)
+      base = document_data(doc).merge(
+        {
+          'path' => document_path(doc),
+          'url' => document_url(doc),
+          'collection' => collection
+        }
+      )
+
+      base['id'] = doc.id if doc.respond_to? :id
+      base
+    end
+
+    def all_posts
+      posts = @site.posts || @site.collections['posts']
+      posts.class.method_defined?(:docs) ? posts.docs : posts
+    end
+
+    def all_drafts
+      drafts_paths.reduce([]) do |drafts, drafts_path|
+        base_path = drafts_path.gsub(%r{(^|/)_drafts}, '')
+        drafts + @reader.read_drafts(base_path)
+      end
+    end
+
+    def all_pages
+      html_pages = @site.pages.select do |page|
+        page.html? || page.url.end_with?('/')
+      end
+
+      static_pages = @site.static_files.select do |static_page|
+        STATIC_EXTENSIONS.include?(static_page.extname)
+      end
+
+      html_pages + static_pages
+    end
+
+    def data_files?
+      @reader.read_data(@data_dir)&.keys&.any?
+    end
+
+    def group_by_category_folder(collection, key)
+      split_path = "/_#{key}/"
+      collection.group_by do |doc|
+        parts = doc.relative_path.split(split_path)
+        if parts.length > 1
+          File.join(parts.first, key).sub(%r{^/+}, '')
+        else
+          key
+        end
+      end
+    end
+  end
+end

data/lib/cloudcannon-jekyll/generators/data.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../logger'
+require_relative 'paths'
+
+module CloudCannonJekyll
+  # Generator functions for site data
+  class Data
+    def initialize(site, config)
+      @site = site
+      @config = config
+    end
+
+    def generate_data
+      data_config = @config['data_config']
+      data = case data_config
+             when true
+               @site.data&.dup
+             when Hash
+               @site.data&.select { |key, _| data_config.key?(key) && data_config[key] }
+             end
+
+      data ||= {}
+      data['categories'] ||= @site.categories.keys
+      data['tags'] ||= @site.tags.keys
+
+      data.each_key do |key|
+        Logger.info "💾 Processed #{key.bold} data set"
+      end
+
+      data
+    end
+  end
+end

data/lib/cloudcannon-jekyll/generators/info.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'jekyll'
+require 'fileutils'
+require_relative '../logger'
+require_relative 'collections'
+require_relative 'data'
+require_relative 'paths'
+
+module CloudCannonJekyll
+  # Generates a summary of a Jekyll site
+  class Info
+    def generate_info(site, config)
+      @site = site
+      @site_config = site.config
+      @config = config
+      @data_dir = Paths.data_dir(site)
+      @collections_dir = Paths.collections_dir(site)
+
+      collections_generator = Collections.new(site, config)
+      collections_config = collections_generator.generate_collections_config
+      collections = collections_generator.generate_collections(collections_config)
+      collections_generator.remove_empty_collection_config(collections_config, collections)
+
+      {
+        time: site.time.iso8601,
+        version: '0.0.3',
+        cloudcannon: generate_cloudcannon,
+        generator: generate_generator,
+        paths: generate_paths,
+        collections_config: collections_config,
+        collection_groups: @config['collection_groups'],
+        collections: collections,
+        data: generate_data,
+        source: @config['source'] || '',
+        timezone: @config['timezone'],
+        base_url: @config['base_url'] || '',
+        editor: @config['editor'],
+        source_editor: @config['source_editor'],
+        _inputs: @config['_inputs'],
+        _editables: @config['_editables'],
+        _select_data: @config['_select_data'],
+        _structures: @config['_structures'],
+
+        # Deprecated
+        _array_structures: @config['_array_structures'],
+        _comments: @config['_comments'],
+        _enabled_editors: @config['_enabled_editors'],
+        _instance_values: @config['_instance_values'],
+        _options: @config['_options'],
+
+        # Jekyll-only
+        defaults: @site_config['defaults']
+      }.compact
+    end
+
+    def generate_data
+      data_generator = Data.new(@site, @config)
+      data_generator.generate_data
+    end
+
+    def generate_cloudcannon
+      {
+        name: 'cloudcannon-jekyll',
+        version: CloudCannonJekyll::VERSION
+      }
+    end
+
+    def generate_paths
+      {
+        static: '',
+        uploads: @config.dig('paths', 'uploads') || 'uploads',
+        data: @data_dir,
+        collections: @collections_dir,
+        layouts: @site_config['layouts_dir'] || '_layouts'
+      }
+    end
+
+    def generate_generator
+      {
+        name: 'jekyll',
+        version: Jekyll::VERSION,
+        environment: Jekyll.env,
+        metadata: {
+          markdown: @site_config['markdown'],
+          kramdown: @site_config['kramdown'],
+          commonmark: @site_config['commonmark']
+        }
+      }
+    end
+  end
+end