bridgetown-core 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bdc825b903ba9de033edc8fcce7b94f871cd6c98b4c267856316a5f842f0c6d
-  data.tar.gz: d8aa948572f48e2450059cd47ac3d6766d6cc43494ebe771f9859a01bcb9bb9c
+  metadata.gz: 01abda216c9aa5c096d73906bd6b76e516f42286a37039a99d8894497b1896b4
+  data.tar.gz: 5dabe33f2ec5614a3637b2880c471e460699ed1f65399abf0b17ab6d92889ceb
 SHA512:
-  metadata.gz: 3d2fd4b262ca60a39b3b3799caddb655c48808c336e5c266c55a06886a3e64e2bc54dbd54cc5f338b08bb089d10bfa9a7fec0c95bddbaded541d60b56615461e
-  data.tar.gz: 2c5b6899c86c1a48662b0d7229ac65bfacf487a88444f6b2b0bc3481ad668e3ccf11fcb7bef14b37ec375c07d92dcc1e1120067104b575fda9945349e811e6c0
+  metadata.gz: 637885282a2398b8715aa05fbed070999a05a0256507a73110591f68eafa0d854acc9831078263e59213dd8b3e4eed11b9838b69620f71653af4d45b4f06555b
+  data.tar.gz: da314910ec05c60a3a70b960a5b4a27d45adb68ef019e54366d0c35304023545d4b4d046602b8dcdbdc9055ac00dcd94c96aa665c41bd4c555a08d9639c9875b

data/Rakefile

@@ -0,0 +1,42 @@
+require "bundler/gem_tasks"
+
+$LOAD_PATH.unshift File.expand_path("lib", __dir__)
+require "bridgetown-core/version"
+
+Dir.glob("rake/**.rake").each { |f| import f }
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  "bridgetown-core"
+end
+
+def version
+  Bridgetown::VERSION
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{Gem::Version.new(version)}.gem"
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+task :spec => :test
+require "rake/testtask"
+Rake::TestTask.new(:test) do |test|
+  test.libs << "lib" << "test"
+  test.pattern = "test/**/test_*.rb"
+  test.verbose = true
+end

data/bridgetown-core.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "lib/bridgetown-core/version"
+
+Gem::Specification.new do |s|
+  s.name          = "bridgetown-core"
+  s.version       = Bridgetown::VERSION
+  s.license       = "MIT"
+  s.author        = "Bridgetown Team"
+  s.email         = "maintainers@bridgetownrb.com"
+  s.homepage      = "https://bridgetownrb.com"
+  s.summary       = "A Webpack-aware, Ruby-based static site generator for the modern Jamstack era"
+  s.description   = "Bridgetown is a Webpack-aware, Ruby-powered static site generator for the modern Jamstack era"
+
+  s.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(benchmark|features|script|test)/})
+  end
+  s.executables   = ["bridgetown"]
+  s.bindir        = "bin"
+  s.require_paths = ["lib"]
+
+  s.metadata      = {
+    "source_code_uri" => "https://github.com/bridgetownrb/bridgetown",
+    "bug_tracker_uri" => "https://github.com/bridgetownrb/bridgetown/issues",
+    "changelog_uri"   => "https://github.com/bridgetownrb/bridgetown/releases",
+    "homepage_uri"    => s.homepage,
+  }
+
+  s.rdoc_options     = ["--charset=UTF-8"]
+
+  s.required_ruby_version     = ">= 2.4.0"
+  s.required_rubygems_version = ">= 2.7.0"
+
+  s.add_runtime_dependency("addressable",           "~> 2.4")
+  s.add_runtime_dependency("colorator",             "~> 1.0")
+  s.add_runtime_dependency("i18n",                  "~> 1.0")
+  s.add_runtime_dependency("kramdown",              "~> 2.1")
+  s.add_runtime_dependency("kramdown-parser-gfm",   "~> 1.0")
+  s.add_runtime_dependency("liquid",                "~> 4.0")
+  s.add_runtime_dependency("listen",                "~> 3.0")
+  s.add_runtime_dependency("mercenary",             "~> 0.4.0")
+  s.add_runtime_dependency("pathutil",              "~> 0.9")
+  s.add_runtime_dependency("rouge",                 "~> 3.0")
+  s.add_runtime_dependency("safe_yaml",             "~> 1.0")
+  s.add_runtime_dependency("terminal-table",        "~> 1.8")
+end

data/lib/bridgetown-core.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift __dir__ # For use/testing when no gem is installed
+
+# Require all of the Ruby files in the given directory.
+#
+# path - The String relative path from here to the directory.
+#
+# Returns nothing.
+def require_all(path)
+  glob = File.join(__dir__, path, "*.rb")
+  Dir[glob].sort.each do |f|
+    require f
+  end
+end
+
+# rubygems
+require "rubygems"
+
+# stdlib
+require "forwardable"
+require "fileutils"
+require "time"
+require "English"
+require "pathname"
+require "logger"
+require "set"
+require "csv"
+require "json"
+
+# 3rd party
+require "pathutil"
+require "addressable/uri"
+require "safe_yaml/load"
+require "liquid"
+require "kramdown"
+require "colorator"
+require "i18n"
+
+SafeYAML::OPTIONS[:suppress_warnings] = true
+
+module Bridgetown
+  # internal requires
+  autoload :Cleaner,             "bridgetown-core/cleaner"
+  autoload :Collection,          "bridgetown-core/collection"
+  autoload :Configuration,       "bridgetown-core/configuration"
+  autoload :Convertible,         "bridgetown-core/convertible"
+  autoload :Deprecator,          "bridgetown-core/deprecator"
+  autoload :Document,            "bridgetown-core/document"
+  autoload :EntryFilter,         "bridgetown-core/entry_filter"
+  autoload :Errors,              "bridgetown-core/errors"
+  autoload :Excerpt,             "bridgetown-core/excerpt"
+  autoload :External,            "bridgetown-core/external"
+  autoload :FrontmatterDefaults, "bridgetown-core/frontmatter_defaults"
+  autoload :Hooks,               "bridgetown-core/hooks"
+  autoload :Layout,              "bridgetown-core/layout"
+  autoload :Cache,               "bridgetown-core/cache"
+  autoload :CollectionReader,    "bridgetown-core/readers/collection_reader"
+  autoload :DataReader,          "bridgetown-core/readers/data_reader"
+  autoload :LayoutReader,        "bridgetown-core/readers/layout_reader"
+  autoload :PostReader,          "bridgetown-core/readers/post_reader"
+  autoload :PageReader,          "bridgetown-core/readers/page_reader"
+  autoload :StaticFileReader,    "bridgetown-core/readers/static_file_reader"
+  autoload :LogAdapter,          "bridgetown-core/log_adapter"
+  autoload :Page,                "bridgetown-core/page"
+  autoload :PageWithoutAFile,    "bridgetown-core/page_without_a_file"
+  autoload :PathManager,         "bridgetown-core/path_manager"
+  autoload :PluginManager,       "bridgetown-core/plugin_manager"
+  autoload :Publisher,           "bridgetown-core/publisher"
+  autoload :Reader,              "bridgetown-core/reader"
+  autoload :Regenerator,         "bridgetown-core/regenerator"
+  autoload :RelatedPosts,        "bridgetown-core/related_posts"
+  autoload :Renderer,            "bridgetown-core/renderer"
+  autoload :LiquidRenderer,      "bridgetown-core/liquid_renderer"
+  autoload :LogWriter,           "bridgetown-core/log_writer"
+  autoload :Site,                "bridgetown-core/site"
+  autoload :StaticFile,          "bridgetown-core/static_file"
+  autoload :URL,                 "bridgetown-core/url"
+  autoload :Utils,               "bridgetown-core/utils"
+  autoload :VERSION,             "bridgetown-core/version"
+  autoload :Watcher,             "bridgetown-core/watcher"
+
+  # extensions
+  require "bridgetown-core/plugin"
+  require "bridgetown-core/converter"
+  require "bridgetown-core/generator"
+  require "bridgetown-core/command"
+  require "bridgetown-core/liquid_extensions"
+  require "bridgetown-core/filters"
+
+  require "bridgetown-core/drops/drop"
+  require "bridgetown-core/drops/document_drop"
+  require_all "bridgetown-core/commands"
+  require_all "bridgetown-core/converters"
+  require_all "bridgetown-core/converters/markdown"
+  require_all "bridgetown-core/drops"
+  require_all "bridgetown-core/generators"
+  require_all "bridgetown-core/tags"
+
+  class << self
+    # Public: Tells you which Bridgetown environment you are building in so
+    # you can skip tasks if you need to.
+
+    def env
+      ENV["BRIDGETOWN_ENV"] || "development"
+    end
+
+    # Public: Generate a Bridgetown configuration Hash by merging the default
+    # options with anything in bridgetown.config.yml, and adding the given
+    # options on top.
+    #
+    # override - A Hash of config directives that override any options in both
+    #            the defaults and the config file.
+    #            See Bridgetown::Configuration::DEFAULTS for a
+    #            list of option names and their defaults.
+    #
+    # Returns the final configuration Hash.
+    def configuration(override = {})
+      config = Configuration.new
+      override = Configuration[override].stringify_keys
+      unless override.delete("skip_config_files")
+        config = config.read_config_files(config.config_files(override))
+      end
+
+      # Merge DEFAULTS < bridgetown.config.yml < override
+      Configuration.from(Utils.deep_merge_hashes(config, override)).tap do |obj|
+        set_timezone(obj["timezone"]) if obj["timezone"]
+      end
+    end
+
+    # Public: Set the TZ environment variable to use the timezone specified
+    #
+    # timezone - the IANA Time Zone
+    #
+    # Returns nothing
+    # rubocop:disable Naming/AccessorMethodName
+    def set_timezone(timezone)
+      ENV["TZ"] = if Utils::Platforms.really_windows?
+                    Utils::WinTZ.calculate(timezone)
+                  else
+                    timezone
+                  end
+    end
+    # rubocop:enable Naming/AccessorMethodName
+
+    # Public: Fetch the logger instance for this Bridgetown process.
+    #
+    # Returns the LogAdapter instance.
+    def logger
+      @logger ||= LogAdapter.new(LogWriter.new, (ENV["BRIDGETOWN_LOG_LEVEL"] || :info).to_sym)
+    end
+
+    # Public: Set the log writer.
+    #         New log writer must respond to the same methods
+    #         as Ruby's interal Logger.
+    #
+    # writer - the new Logger-compatible log transport
+    #
+    # Returns the new logger.
+    def logger=(writer)
+      @logger = LogAdapter.new(writer, (ENV["BRIDGETOWN_LOG_LEVEL"] || :info).to_sym)
+    end
+
+    # Public: An array of sites
+    #
+    # Returns the Bridgetown sites created.
+    def sites
+      @sites ||= []
+    end
+
+    # Public: Ensures the questionable path is prefixed with the base directory
+    #         and prepends the questionable path with the base directory if false.
+    #
+    # base_directory - the directory with which to prefix the questionable path
+    # questionable_path - the path we're unsure about, and want prefixed
+    #
+    # Returns the sanitized path.
+    def sanitized_path(base_directory, questionable_path)
+      return base_directory if base_directory.eql?(questionable_path)
+
+      clean_path = questionable_path.dup
+      clean_path.insert(0, "/") if clean_path.start_with?("~")
+      clean_path = File.expand_path(clean_path, "/")
+
+      return clean_path if clean_path.eql?(base_directory)
+
+      # remove any remaining extra leading slashes not stripped away by calling
+      # `File.expand_path` above.
+      clean_path.squeeze!("/")
+
+      if clean_path.start_with?(base_directory.sub(%r!\z!, "/"))
+        clean_path
+      else
+        clean_path.sub!(%r!\A\w:/!, "/")
+        File.join(base_directory, clean_path)
+      end
+    end
+
+    # Conditional optimizations
+    Bridgetown::External.require_if_present("liquid/c")
+  end
+end

data/lib/bridgetown-core/cache.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Bridgetown
+  class Cache
+    # class-wide base cache
+    @base_cache = {}
+
+    # class-wide directive to write cache to disk is enabled by default
+    @disk_cache_enabled = true
+
+    class << self
+      # class-wide cache location
+      attr_accessor :cache_dir
+
+      # class-wide directive to write cache to disk
+      attr_reader :disk_cache_enabled
+
+      # class-wide base cache reader
+      attr_reader :base_cache
+
+      # Disable Marshaling cached items to disk
+      def disable_disk_cache!
+        @disk_cache_enabled = false
+      end
+
+      # Clear all caches
+      def clear
+        delete_cache_files
+        base_cache.each_value(&:clear)
+      end
+
+      # Compare the current config to the cached config
+      # If they are different, clear all caches
+      #
+      # Returns nothing.
+      def clear_if_config_changed(config)
+        config = config.inspect
+        cache = Bridgetown::Cache.new "Bridgetown::Cache"
+        return if cache.key?("config") && cache["config"] == config
+
+        clear
+        cache = Bridgetown::Cache.new "Bridgetown::Cache"
+        cache["config"] = config
+        nil
+      end
+
+      private
+
+      # Delete all cached items from all caches
+      #
+      # Returns nothing.
+      def delete_cache_files
+        FileUtils.rm_rf(@cache_dir) if disk_cache_enabled
+      end
+    end
+
+    #
+
+    # Get an existing named cache, or create a new one if none exists
+    #
+    # name - name of the cache
+    #
+    # Returns nothing.
+    def initialize(name)
+      @cache = Bridgetown::Cache.base_cache[name] ||= {}
+      @name = name.gsub(%r![^\w\s-]!, "-")
+    end
+
+    # Clear this particular cache
+    def clear
+      delete_cache_files
+      @cache.clear
+    end
+
+    # Retrieve a cached item
+    # Raises if key does not exist in cache
+    #
+    # Returns cached value
+    def [](key)
+      return @cache[key] if @cache.key?(key)
+
+      path = path_to(hash(key))
+      if disk_cache_enabled? && File.file?(path) && File.readable?(path)
+        @cache[key] = load(path)
+      else
+        raise
+      end
+    end
+
+    # Add an item to cache
+    #
+    # Returns nothing.
+    def []=(key, value)
+      @cache[key] = value
+      return unless disk_cache_enabled?
+
+      path = path_to(hash(key))
+      value = new Hash(value) if value.is_a?(Hash) && !value.default.nil?
+      dump(path, value)
+    rescue TypeError
+      Bridgetown.logger.debug "Cache:", "Cannot dump object #{key}"
+    end
+
+    # If an item already exists in the cache, retrieve it.
+    # Else execute code block, and add the result to the cache, and return that result.
+    def getset(key)
+      self[key]
+    rescue StandardError
+      value = yield
+      self[key] = value
+      value
+    end
+
+    # Remove one particular item from the cache
+    #
+    # Returns nothing.
+    def delete(key)
+      @cache.delete(key)
+      File.delete(path_to(hash(key))) if disk_cache_enabled?
+    end
+
+    # Check if `key` already exists in this cache
+    #
+    # Returns true if key exists in the cache, false otherwise
+    def key?(key)
+      # First, check if item is already cached in memory
+      return true if @cache.key?(key)
+      # Otherwise, it might be cached on disk
+      # but we should not consider the disk cache if it is disabled
+      return false unless disk_cache_enabled?
+
+      path = path_to(hash(key))
+      File.file?(path) && File.readable?(path)
+    end
+
+    def disk_cache_enabled?
+      !!Bridgetown::Cache.disk_cache_enabled
+    end
+
+    private
+
+    # Given a hashed key, return the path to where this item would be saved on disk.
+    def path_to(hash = nil)
+      @base_dir ||= File.join(Bridgetown::Cache.cache_dir, @name)
+      return @base_dir if hash.nil?
+
+      File.join(@base_dir, hash[0..1], hash[2..-1]).freeze
+    end
+
+    # Given a key, return a SHA2 hash that can be used for caching this item to disk.
+    def hash(key)
+      Digest::SHA2.hexdigest(key).freeze
+    end
+
+    # Remove all this caches items from disk
+    #
+    # Returns nothing.
+    def delete_cache_files
+      FileUtils.rm_rf(path_to) if disk_cache_enabled?
+    end
+
+    # Load `path` from disk and return the result.
+    # This MUST NEVER be called in Safe Mode
+    # rubocop:disable Security/MarshalLoad
+    def load(path)
+      raise unless disk_cache_enabled?
+
+      cached_file = File.open(path, "rb")
+      value = Marshal.load(cached_file)
+      cached_file.close
+      value
+    end
+    # rubocop:enable Security/MarshalLoad
+
+    # Given a path and a value, save value to disk at path.
+    # This should NEVER be called in Safe Mode
+    #
+    # Returns nothing.
+    def dump(path, value)
+      return unless disk_cache_enabled?
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, "wb") do |cached_file|
+        Marshal.dump(value, cached_file)
+      end
+    end
+  end
+end