jekyll-obsidian-site 0.2.0

data/website/lib/jekyll_obsidian/cli.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "runtime"
+require_relative "initializer"
+
+module JekyllObsidian
+  class CLI
+    def self.run(arguments = ARGV)
+      new.run(arguments.dup)
+    end
+
+    def run(arguments)
+      command = arguments.shift || "--help"
+      if %w[--version -v].include?(command)
+        puts "jekyll-obsidian #{VERSION} (#{GEM_NAME})"
+        return 0
+      end
+      if %w[--help -h help].include?(command)
+        puts "Usage: jekyll-obsidian <init|build|dev|clean> [options]"
+        puts "Configuration: .github/jekyll-obsidian.yml"
+        puts "Run jekyll-obsidian COMMAND --help for command options."
+        return 0
+      end
+      raise ArgumentError, "unknown command: #{command}" unless %w[init build dev clean].include?(command)
+
+      options = {}
+      parser = OptionParser.new do |parser|
+        parser.banner = "Usage: jekyll-obsidian #{command} [options]"
+        if command == "init"
+          parser.on("--source PATH", "Content directory relative to the repository (default: docs)") { |value| options[:source] = value }
+        end
+        if %w[init build dev].include?(command)
+          parser.on("--theme minimal|docs", %w[minimal docs], "Site theme (default: configuration, or minimal)") { |value| options[:theme] = value }
+        end
+        if %w[build dev].include?(command)
+          parser.on("--baseurl PATH", "Site path, such as /project") { |value| options[:baseurl] = value }
+        end
+        if command == "build"
+          parser.on("--url ORIGIN", "Production origin, such as https://example.com") { |value| options[:url] = value }
+        end
+        if command == "dev"
+          parser.on("--host HOST", "Preview host (default: 127.0.0.1)") { |value| options[:host] = value }
+          parser.on("--port PORT", Integer, "Preview port (default: 58000)") do |value|
+            raise ArgumentError, "port must be between 1 and 65535" unless (1..65_535).cover?(value)
+            options[:port] = value
+          end
+          parser.separator "Watching is always enabled. Builds are complete and atomic."
+          parser.separator "Jekyll --watch and --incremental are not supported."
+        end
+        parser.on("-h", "--help", "Show this help") { puts parser; return 0 }
+      end
+      parser.parse!(arguments)
+      raise ArgumentError, "unexpected argument: #{arguments.first}" unless arguments.empty?
+
+      if command == "init"
+        created = Initializer.run(root: Dir.pwd, **options)
+        puts(created.empty? ? "Site files already exist." : "Created #{created.join(", ")}")
+        puts "Edit .github/jekyll-obsidian.yml, then push to GitHub or run jekyll-obsidian dev."
+        puts "For GitHub Pages, select Settings > Pages > Source > GitHub Actions."
+        return 0
+      end
+
+      runtime = Runtime.new(root: Runtime.discover_root)
+      case command
+      when "build"
+        puts "Built #{runtime.build(**options)}"
+      when "dev"
+        require_relative "preview"
+        Preview.new(runtime, **options).run
+      when "clean"
+        runtime.clean
+        puts "Build output is clean."
+      end
+      0
+    rescue OptionParser::ParseError, ArgumentError, Runtime::Error, WorkspaceLayout::Invalid,
+        Jekyll::Errors::FatalException, SystemCallError => exception
+      warn "Error: #{exception.message}"
+      1
+    rescue Interrupt
+      130
+    end
+  end
+end

data/website/lib/jekyll_obsidian/content_policy.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module JekyllObsidian
+  # Owns the publication and content-classification rules for authored notes.
+  # Callers resolve configuration once, then use the same policy while selecting
+  # default-language notes, applying locale overlays, and classifying output.
+  class ContentPolicy
+    ROOT_DIRECTORY = "."
+    DEFAULT_SETTINGS = DeepFreeze.call(
+      "publish_by_default" => [],
+      "default_type" => "page",
+      "directories" => { "post" => ["blog"], "doc" => ["docs"] }
+    )
+    Resolution = ImmutableRecord.define(:policy, :diagnostics)
+
+    class << self
+      def resolve(raw)
+        diagnostics = []
+        settings = normalize(raw, diagnostics)
+        Resolution.new(policy: new(settings), diagnostics: diagnostics)
+      end
+
+      private
+
+      def normalize(raw, diagnostics)
+        unless raw.nil? || raw.is_a?(Hash)
+          diagnostics << diagnostic("invalid_content_config", "content must be a mapping")
+          return DEFAULT_SETTINGS
+        end
+        raw ||= {}
+        unknown = raw.keys.map(&:to_s) - %w[publish_by_default default_type directories]
+        unknown.sort.each do |key|
+          diagnostics << diagnostic("invalid_content_config", "unknown content setting #{key.inspect}")
+        end
+
+        default_type = fetch(raw, "default_type") || DEFAULT_SETTINGS.fetch("default_type")
+        unless FrontMatter::CONTENT_TYPES.include?(default_type)
+          diagnostics << diagnostic(
+            "invalid_content_config",
+            "content.default_type must be one of: #{FrontMatter::CONTENT_TYPES.join(', ')}"
+          )
+          default_type = DEFAULT_SETTINGS.fetch("default_type")
+        end
+
+        publish_by_default = normalize_publish_directories(raw, diagnostics)
+        directories = normalize_content_directories(raw, diagnostics)
+        directories.fetch("post").product(directories.fetch("doc")).each do |post_directory, doc_directory|
+          next unless directory_overlaps?(post_directory, doc_directory)
+
+          diagnostics << diagnostic(
+            "overlapping_content_directories",
+            "post and doc directories overlap: #{post_directory.inspect} and #{doc_directory.inspect}"
+          )
+        end
+
+        DeepFreeze.call(
+          "publish_by_default" => publish_by_default,
+          "default_type" => default_type,
+          "directories" => directories
+        )
+      end
+
+      def normalize_publish_directories(raw, diagnostics)
+        values = if raw.key?("publish_by_default") || raw.key?(:publish_by_default)
+          fetch(raw, "publish_by_default")
+        else
+          DEFAULT_SETTINGS.fetch("publish_by_default")
+        end
+        unless values.is_a?(Array)
+          diagnostics << diagnostic(
+            "invalid_publish_by_default",
+            "content.publish_by_default must be an array"
+          )
+          values = []
+        end
+        values.filter_map do |value|
+          normalize_directory(value, "content.publish_by_default", diagnostics, allow_root: true)
+        end.uniq.sort
+      end
+
+      def normalize_content_directories(raw, diagnostics)
+        directories = if raw.key?("directories") || raw.key?(:directories)
+          fetch(raw, "directories")
+        else
+          DEFAULT_SETTINGS.fetch("directories")
+        end
+        unless directories.is_a?(Hash)
+          diagnostics << diagnostic("invalid_content_directories", "content.directories must be a mapping")
+          directories = {}
+        end
+        unknown = directories.keys.map(&:to_s) - %w[post doc]
+        unknown.sort.each do |key|
+          diagnostics << diagnostic(
+            "invalid_content_directories",
+            "unknown content directory type #{key.inspect}"
+          )
+        end
+
+        %w[post doc].to_h do |type|
+          values = fetch(directories, type) || []
+          unless values.is_a?(Array)
+            diagnostics << diagnostic(
+              "invalid_content_directories",
+              "content.directories.#{type} must be an array"
+            )
+            values = []
+          end
+          normalized = values.filter_map do |value|
+            normalize_directory(value, "content.directories.#{type}", diagnostics, allow_root: false)
+          end.uniq.sort
+          [type, normalized]
+        end
+      end
+
+      def normalize_directory(value, setting, diagnostics, allow_root:)
+        unless FrontMatter.valid_output_text?(value)
+          diagnostics << diagnostic("invalid_content_directory", "#{setting} entries must be strings")
+          return nil
+        end
+        return ROOT_DIRECTORY if allow_root && value == ROOT_DIRECTORY
+
+        if value.empty? || value.start_with?("/", "\\") || value.include?("\\") || value != value.unicode_normalize(:nfc)
+          diagnostics << diagnostic(
+            "invalid_content_directory",
+            "#{setting} entries must be normalized vault-relative POSIX directories"
+          )
+          return nil
+        end
+        segments = value.split("/", -1)
+        if segments.any? { |segment| segment.empty? || segment == "." || segment == ".." }
+          diagnostics << diagnostic(
+            "invalid_content_directory",
+            "#{setting} entries must not contain empty or traversal segments"
+          )
+          return nil
+        end
+        value
+      rescue EncodingError
+        diagnostics << diagnostic("invalid_content_directory", "#{setting} entries must contain valid Unicode")
+        nil
+      end
+
+      def directory_overlaps?(first, second)
+        left = first.downcase(:fold)
+        right = second.downcase(:fold)
+        left == right || left.start_with?("#{right}/") || right.start_with?("#{left}/")
+      end
+
+      def fetch(hash, key)
+        hash.key?(key) ? hash[key] : hash[key.to_sym]
+      end
+
+      def diagnostic(code, message)
+        Diagnostic.new(severity: :error, code: code, message: message, path: nil, span: nil)
+      end
+    end
+
+    private_class_method :new
+
+    attr_reader :settings
+
+    def initialize(settings)
+      @settings = settings
+      @publish_by_default = settings.fetch("publish_by_default")
+      @directories = settings.fetch("directories")
+      @default_type = settings.fetch("default_type")
+      freeze
+    end
+
+    def publish?(path, properties)
+      return false if properties["publish"] == false
+      return true if properties["publish"] == true
+
+      @publish_by_default.any? { |directory| inside_directory?(path, directory) }
+    end
+
+    def classify(path, properties)
+      return "page" if path == "index.md"
+      return properties["content_type"] if properties["content_type"]
+
+      directory = File.dirname(path)
+      @directories.each do |type, configured|
+        return type if configured.any? { |prefix| directory == prefix || directory.start_with?("#{prefix}/") }
+      end
+      @default_type
+    end
+
+    private
+
+    def inside_directory?(path, directory)
+      directory == ROOT_DIRECTORY || path.start_with?("#{directory}/")
+    end
+  end
+end

data/website/lib/jekyll_obsidian/destination_registry.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module JekyllObsidian
+  # Tracks normalized output destinations while treating a file and any path
+  # below that file as a collision. Each insertion visits only its path
+  # segments, so large sites do not compare every output with every other one.
+  class DestinationRegistry
+    Node = Struct.new(:owner, :descendant_owner, :children, keyword_init: true)
+
+    def initialize
+      @root = node
+    end
+
+    def add(destination, owner)
+      current = @root
+      lineage = [current]
+      destination.split("/").reject(&:empty?).each do |segment|
+        return current.owner if current.owner
+
+        current.children[segment] ||= node
+        current = current.children.fetch(segment)
+        lineage << current
+      end
+
+      return current.owner if current.owner
+      return current.descendant_owner if current.descendant_owner
+
+      current.owner = owner
+      lineage[0...-1].each { |ancestor| ancestor.descendant_owner ||= owner }
+      nil
+    end
+
+    private
+
+    def node
+      Node.new(owner: nil, descendant_owner: nil, children: {})
+    end
+  end
+end

data/website/lib/jekyll_obsidian/directory_indexes.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module JekyllObsidian
+  # Selects the one physical note path that may act as each directory's index.
+  # Publication is deliberately applied later: a private index.md still owns
+  # the physical slot and therefore prevents README.md from taking it over.
+  module DirectoryIndexes
+    PRIMARY_BASENAME = "index.md"
+    FALLBACK_BASENAME = "README.md"
+
+    module_function
+
+    def resolve(note_paths)
+      paths = Array(note_paths).map(&:to_s)
+      selected = {}
+
+      paths.each do |path|
+        selected[File.dirname(path)] = path if File.basename(path) == PRIMARY_BASENAME
+      end
+      paths.each do |path|
+        directory = File.dirname(path)
+        if File.basename(path) == FALLBACK_BASENAME && !selected.key?(directory)
+          selected[directory] = path
+        end
+      end
+
+      DeepFreeze.call(selected)
+    end
+  end
+end