giblish 2.2.2 → 3.0.1

data/lib/giblish/node_data_provider.rb

@@ -0,0 +1,137 @@
+module Giblish
+  # Provides a unified interface for node data by explicitly composing
+  # multiple providers into a single object.
+  #
+  # Supports dynamic composition - providers can be added after initialization.
+  # Each method explicitly delegates to the first provider that responds to it.
+  class NodeDataProvider
+    def initialize(*providers)
+      @providers = Array(providers).compact
+    end
+
+    def add_provider(provider)
+      @providers << provider
+      self
+    end
+
+    # === Source Node Interface (DocAttrBuilder + AdocSrcProvider) ===
+
+    def document_attributes(src_node, dst_node, dst_top)
+      provider = find_provider(:document_attributes)
+      provider.document_attributes(src_node, dst_node, dst_top)
+    end
+
+    def adoc_source(src_node, dst_node, dst_top)
+      provider = find_provider(:adoc_source)
+      provider.adoc_source(src_node, dst_node, dst_top)
+    end
+
+    def api_options(src_node, dst_node, dst_top)
+      provider = find_provider(:api_options, raise_on_missing: false)
+      return {} unless provider
+      provider.api_options(src_node, dst_node, dst_top)
+    end
+
+    # === Conversion Info Interface (SuccessfulConversion / FailedConversion) ===
+
+    def src_node
+      provider = find_provider(:src_node)
+      provider.src_node
+    end
+
+    def dst_node
+      provider = find_provider(:dst_node)
+      provider.dst_node
+    end
+
+    def dst_top
+      provider = find_provider(:dst_top)
+      provider.dst_top
+    end
+
+    def converted
+      provider = find_provider(:converted)
+      provider.converted
+    end
+
+    def src_rel_path
+      provider = find_provider(:src_rel_path)
+      provider.src_rel_path
+    end
+
+    def src_basename
+      provider = find_provider(:src_basename)
+      provider.src_basename
+    end
+
+    def title
+      provider = find_provider(:title)
+      provider.title
+    end
+
+    def docid
+      provider = find_provider(:docid)
+      provider.docid
+    end
+
+    def to_s
+      provider = find_provider(:to_s)
+      provider.to_s
+    end
+
+    # SuccessfulConversion specific
+    def stderr
+      provider = find_provider(:stderr)
+      provider.stderr
+    end
+
+    def adoc
+      provider = find_provider(:adoc)
+      provider.adoc
+    end
+
+    def dst_rel_path
+      provider = find_provider(:dst_rel_path)
+      provider.dst_rel_path
+    end
+
+    def purpose_str
+      provider = find_provider(:purpose_str)
+      provider.purpose_str
+    end
+
+    # FailedConversion specific
+    def error_msg
+      provider = find_provider(:error_msg)
+      provider.error_msg
+    end
+
+    # === History Interface (FileHistory) ===
+
+    def history
+      provider = find_provider(:history, raise_on_missing: false)
+      return nil unless provider
+      provider.history
+    end
+
+    def branch
+      provider = find_provider(:branch, raise_on_missing: false)
+      return nil unless provider
+      provider.branch
+    end
+
+    def respond_to?(method_name, include_private = false)
+      find_provider(method_name, raise_on_missing: false) ? true : super
+    end
+
+    private
+
+    def find_provider(method_name, raise_on_missing: true)
+      provider = @providers.find { |p| p.respond_to?(method_name) }
+      if provider.nil? && raise_on_missing
+        raise NoMethodError, "None of the providers respond to '#{method_name}'"
+      end
+      provider
+    end
+  end
+end

data/lib/giblish/resourcepaths.rb

@@ -1,4 +1,5 @@
 require "pathname"
+require "gran"
 
 module Giblish
   # Provides relevant paths for layout resources based on the given options
@@ -54,7 +55,7 @@ module Giblish
       return if @src_resource_dir_abs.nil?
 
       # Tweak paths based on the content of a given resource dir
-      file_tree = PathTree.build_from_fs(@src_resource_dir_abs)
+      file_tree = Gran::PathTree.build_from_fs(@src_resource_dir_abs)
 
       @src_style_path_rel = find_style_file(file_tree, cmd_opts.format, cmd_opts.style_name)
       @src_style_path_abs = @src_resource_dir_abs / @src_style_path_rel if @src_style_path_rel
@@ -186,7 +187,7 @@ module Giblish
       return if @asset_regex.nil?
 
       # build a tree with all dirs matching the given regexp
-      st = PathTree.build_from_fs(@srcdir, prune: true) do |p|
+      st = Gran::PathTree.build_from_fs(@srcdir, prune: true) do |p|
         p.directory? && @asset_regex =~ p.to_s
       end
 

data/lib/giblish/search/searchquery.rb

@@ -17,7 +17,7 @@ module Giblish
     end
 
     def css_path
-      @parameters.key?("css-path") && !@parameters["css-path"].empty? ? Pathname.new(@parameters["css-path"]) : nil
+      (@parameters.key?("css-path") && !@parameters["css-path"].empty?) ? Pathname.new(@parameters["css-path"]) : nil
     end
 
     def search_assets_top_rel
@@ -33,9 +33,9 @@ module Giblish
       @parameters.key?("as-regexp")
     end
 
-    def method_missing(meth, *args, &block)
+    def method_missing(meth, ...)
       unless respond_to_missing?(meth)
-        super(meth, *args, &block)
+        super
         return
       end
 

data/lib/giblish/search/textsearcher.rb

@@ -1,7 +1,7 @@
 require "pathname"
 require "json"
+require "gran"
 require_relative "searchquery"
-require_relative "../pathtree"
 
 module Giblish
   # reads all lines in the given file at instantiation and
@@ -21,7 +21,7 @@ module Giblish
     def wash_line(line)
       # remove some asciidoctor format sequences
       # '::', '^|===', '^==', '^--, ':myvar: ...'
-      r = Regexp.new(/(::+|^[=|]+|^--+|^:\w+:.*$)/)
+      r = /(::+|^[=|]+|^--+|^:\w+:.*$)/
       line.gsub(r, "")
     end
   end
@@ -205,7 +205,7 @@ module Giblish
     def build_src_tree
       # setup the tree of source files and pro-actively read in all text
       # into memory
-      src_tree = PathTree.build_from_fs(@assets_fs_path, prune: false) do |p|
+      src_tree = Gran::PathTree.build_from_fs(@assets_fs_path, prune: false) do |p|
         p.extname.downcase == ".adoc"
       end
       src_tree.traverse_preorder do |level, node|

data/lib/giblish/subtreeinfobuilder.rb

@@ -1,5 +1,5 @@
 require "pathname"
-require_relative "pathtree"
+require "gran"
 
 module Giblish
   class SubtreeSrcItf
@@ -75,7 +75,7 @@ module Giblish
         # with this object as source for conversion options
         # and adoc_source
         v_path = Pathname.new("/virtual") / index_dir / "#{@basename}.adoc"
-        v_tree = PathTree.new(v_path, self)
+        v_tree = Gran::PathTree.new(v_path, self)
         src_node = v_tree.node(v_path, from_root: true)
 
         # add the destination node where the converted file will be stored

data/lib/giblish/treeconverter.rb

@@ -1,7 +1,8 @@
 require "asciidoctor"
 require "asciidoctor-pdf"
-require_relative "pathtree"
+require "gran"
 require_relative "conversion_info"
+require_relative "node_data_provider"
 require_relative "utils"
 
 module Giblish
@@ -70,7 +71,7 @@ module Giblish
 
       # get the top-most node of the source and destination trees
       @src_tree = src_top
-      @dst_tree = PathTree.new(dst_top).node(dst_top, from_root: true)
+      @dst_tree = Gran::PathTree.new(dst_top).node(dst_top, from_root: true)
 
       # setup build-phase callback objects
       @pre_builders = Array(opts.fetch(:pre_builders, []))
@@ -127,20 +128,24 @@ module Giblish
     end
 
     # the default callback will tie a 'SuccessfulConversion' instance
-    # to the destination node as its data
+    # to the destination node as its data, wrapped in NodeDataProvider
+    # to allow dynamic addition of other providers (e.g., history)
     def self.on_success(src_node, dst_node, dst_tree, doc, adoc_log_str)
-      dst_node.data = DataDelegator.new(SuccessfulConversion.new(
+      conversion_info = SuccessfulConversion.new(
         src_node: src_node, dst_node: dst_node, dst_top: dst_tree, adoc: doc, adoc_stderr: adoc_log_str
-      ))
+      )
+      dst_node.data = NodeDataProvider.new(conversion_info)
     end
 
     # the default callback will tie a 'FailedConversion' instance
-    # to the destination node as its data
+    # to the destination node as its data, wrapped in NodeDataProvider
+    # to allow dynamic addition of other providers (e.g., history)
     def self.on_failure(src_node, dst_node, dst_tree, ex, adoc_log_str)
       Giblog.logger.error { ex.message }
-      dst_node.data = DataDelegator.new(FailedConversion.new(
+      conversion_info = FailedConversion.new(
         src_node: src_node, dst_node: dst_node, dst_top: dst_tree, error_msg: ex.message
-      ))
+      )
+      dst_node.data = NodeDataProvider.new(conversion_info)
     end
   end
 

data/lib/giblish/version.rb

@@ -1,3 +1,3 @@
 module Giblish
-  VERSION = "2.2.2".freeze
+  VERSION = "3.0.1".freeze
 end

data/scripts/release.rb

@@ -0,0 +1,365 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "pathname"
+require "optparse"
+require "fileutils"
+
+# Release automation script for giblish gem
+class GiblishReleaseManager
+  GIBLISH_DIR = Pathname.new(__dir__).parent
+
+  VALID_COMMANDS = %w[prepare publish all].freeze
+  VALID_VERSION_TYPES = %w[major minor patch].freeze
+
+  attr_reader :command, :version_type, :dry_run, :yes, :specific_version
+
+  def initialize(args)
+    @dry_run = false
+    @yes = false
+    @specific_version = nil
+    parse_options(args)
+    validate_args
+  end
+
+  def run
+    puts "\n=== Giblish Release Manager ==="
+    puts "Command: #{command}"
+    puts "Version: #{version_type || specific_version}"
+    puts "Dry-run: #{dry_run}"
+    puts "================================\n\n"
+
+    case command
+    when "prepare"
+      prepare_release
+    when "publish"
+      publish_release
+    when "all"
+      prepare_release
+      publish_release
+    end
+  end
+
+  private
+
+  def parse_options(args)
+    OptionParser.new do |opts|
+      opts.banner = "Usage: release.rb [options] COMMAND [VERSION]"
+      opts.separator ""
+      opts.separator "COMMAND: #{VALID_COMMANDS.join(", ")}"
+      opts.separator "VERSION: #{VALID_VERSION_TYPES.join(", ")} or specific version (e.g., 0.2.0)"
+      opts.separator ""
+      opts.separator "Options:"
+
+      opts.on("-n", "--dry-run", "Show what would happen without doing it") do
+        @dry_run = true
+      end
+
+      opts.on("-y", "--yes", "Skip confirmation prompts") do
+        @yes = true
+      end
+
+      opts.on("-h", "--help", "Show this help message") do
+        puts opts
+        exit 0
+      end
+    end.parse!(args)
+
+    @command = args[0]
+
+    # Parse version argument
+    if args[1]
+      if VALID_VERSION_TYPES.include?(args[1])
+        @version_type = args[1]
+      elsif args[1].match?(/^\d+\.\d+\.\d+$/)
+        @specific_version = args[1]
+      else
+        puts "ERROR: Invalid version '#{args[1]}'. Must be #{VALID_VERSION_TYPES.join(", ")} or a version number (e.g., 0.2.0)"
+        exit 1
+      end
+    end
+  end
+
+  def validate_args
+    unless VALID_COMMANDS.include?(command)
+      puts "ERROR: Invalid command '#{command}'. Must be one of: #{VALID_COMMANDS.join(", ")}"
+      exit 1
+    end
+
+    if command != "publish" && version_type.nil? && specific_version.nil?
+      puts "ERROR: VERSION argument required for '#{command}' command"
+      exit 1
+    end
+  end
+
+  def prepare_release
+    puts "\n📦 Preparing giblish for release...\n"
+    with_dir(GIBLISH_DIR) do
+      run_safety_checks
+      check_gran_dependency
+      new_version = bump_version(GIBLISH_DIR / "lib/giblish/version.rb")
+      update_changelog(new_version)
+      build_gem
+      create_git_commit_and_tag(new_version)
+      success("Giblish prepared for release: v#{new_version}")
+    end
+  end
+
+  def publish_release
+    puts "\n🚀 Publishing giblish to RubyGems...\n"
+    with_dir(GIBLISH_DIR) do
+      push_to_github
+      publish_gem
+      success("Giblish published!")
+    end
+  end
+
+  # Safety Checks
+  def run_safety_checks
+    step("Running safety checks")
+    check_git_status
+    check_on_main_branch
+    run_tests
+    run_linter
+  end
+
+  def check_git_status
+    output = `git status --porcelain`.strip
+    unless output.empty?
+      error("Working directory is not clean. Commit or stash changes first.")
+    end
+  end
+
+  def check_on_main_branch
+    branch = `git rev-parse --abbrev-ref HEAD`.strip
+    unless branch == "main"
+      unless confirm("You are on branch '#{branch}', not 'main'. Continue anyway?")
+        error("Aborted. Switch to main branch or use --yes to override.")
+      end
+    end
+  end
+
+  def run_tests
+    step("Running tests")
+    unless system("bundle exec rake test > /dev/null 2>&1")
+      error("Tests failed! Fix tests before releasing.")
+    end
+  end
+
+  def run_linter
+    step("Running linter")
+    unless system("bundle exec rake standard > /dev/null 2>&1")
+      error("Linter failed! Fix linting issues before releasing.")
+    end
+  end
+
+  def check_gran_dependency
+    gemspec_path = GIBLISH_DIR / "giblish.gemspec"
+    content = File.read(gemspec_path)
+
+    if content =~ /add_runtime_dependency\s+"gran",\s+"~>\s*([\d.]+)"/
+      current_dep = $1
+      latest_gran = get_latest_rubygems_version("gran")
+
+      if latest_gran && Gem::Version.new(latest_gran) > Gem::Version.new(current_dep)
+        puts "⚠️  Gran dependency in giblish.gemspec is ~> #{current_dep}"
+        puts "    Latest gran on RubyGems is #{latest_gran}"
+        puts "    Consider updating the dependency before releasing."
+        unless confirm("Continue with current gran dependency?")
+          error("Aborted. Update gran dependency first.")
+        end
+      end
+    end
+  end
+
+  # Version Management
+  def bump_version(version_file)
+    current_version = extract_version(version_file)
+    new_version = calculate_new_version(current_version)
+
+    puts "Current version: #{current_version}"
+    puts "New version: #{new_version}"
+
+    unless confirm("Bump version to #{new_version}?")
+      error("Aborted by user")
+    end
+
+    update_version_file(version_file, current_version, new_version)
+    new_version
+  end
+
+  def extract_version(version_file)
+    content = File.read(version_file)
+    if content =~ /VERSION\s*=\s*"([\d.]+)"/
+      $1
+    else
+      error("Could not find VERSION in #{version_file}")
+    end
+  end
+
+  def calculate_new_version(current)
+    return specific_version if specific_version
+
+    parts = current.split(".").map(&:to_i)
+    case version_type
+    when "major"
+      "#{parts[0] + 1}.0.0"
+    when "minor"
+      "#{parts[0]}.#{parts[1] + 1}.0"
+    when "patch"
+      "#{parts[0]}.#{parts[1]}.#{parts[2] + 1}"
+    end
+  end
+
+  def update_version_file(version_file, old_version, new_version)
+    content = File.read(version_file)
+    content.gsub!(/VERSION\s*=\s*"#{Regexp.escape(old_version)}"/,
+      "VERSION = \"#{new_version}\"")
+
+    if dry_run
+      puts "[DRY-RUN] Would update #{version_file.basename} to #{new_version}"
+    else
+      File.write(version_file, content)
+      puts "✓ Updated #{version_file.basename}"
+    end
+  end
+
+  # Changelog
+  def update_changelog(version)
+    step("Updating CHANGELOG")
+    puts "⚠️  Please update the CHANGELOG manually with changes for v#{version}"
+    puts "Press Enter when done..."
+    $stdin.gets unless yes
+  end
+
+  # Gem Operations
+  def build_gem
+    step("Building giblish gem")
+
+    if dry_run
+      puts "[DRY-RUN] Would run: gem build giblish.gemspec"
+    else
+      unless system("gem build giblish.gemspec")
+        error("Failed to build gem")
+      end
+      puts "✓ Gem built successfully"
+    end
+  end
+
+  def publish_gem
+    gem_file = Dir.glob("giblish-*.gem").max_by { |f| File.mtime(f) }
+
+    unless gem_file
+      error("No gem file found to publish")
+    end
+
+    step("Publishing #{gem_file}")
+
+    unless confirm("Push #{gem_file} to RubyGems.org?")
+      error("Aborted by user")
+    end
+
+    if dry_run
+      puts "[DRY-RUN] Would run: gem push #{gem_file}"
+    else
+      unless system("gem push #{gem_file}")
+        error("Failed to publish gem")
+      end
+      puts "✓ Gem published successfully"
+    end
+  end
+
+  # Git Operations
+  def create_git_commit_and_tag(version)
+    tag_name = "giblish-v#{version}"
+    commit_message = "Release giblish v#{version}"
+
+    step("Creating git commit and tag")
+
+    if dry_run
+      puts "[DRY-RUN] Would run:"
+      puts "  git add ."
+      puts "  git commit -m '#{commit_message}'"
+      puts "  git tag -a #{tag_name} -m '#{commit_message}'"
+    else
+      system("git add .")
+      unless system("git commit -m '#{commit_message}'")
+        error("Failed to create commit")
+      end
+      unless system("git tag -a #{tag_name} -m '#{commit_message}'")
+        error("Failed to create tag")
+      end
+      puts "✓ Created commit and tag: #{tag_name}"
+    end
+  end
+
+  def push_to_github
+    step("Pushing to GitHub")
+
+    unless confirm("Push commits and tags to GitHub?")
+      error("Aborted by user")
+    end
+
+    if dry_run
+      puts "[DRY-RUN] Would run:"
+      puts "  git push origin main"
+      puts "  git push origin --tags"
+    else
+      unless system("git push origin main")
+        error("Failed to push commits")
+      end
+      unless system("git push origin --tags")
+        error("Failed to push tags")
+      end
+      puts "✓ Pushed to GitHub"
+    end
+  end
+
+  # Helpers
+  def get_latest_rubygems_version(gem_name)
+    output = `gem search ^#{gem_name}$ --remote 2>/dev/null`
+    if output =~ /#{gem_name}\s+\(([\d.]+)\)/
+      $1
+    end
+  end
+
+  def with_dir(dir)
+    original_dir = Dir.pwd
+    Dir.chdir(dir)
+    yield
+  ensure
+    Dir.chdir(original_dir)
+  end
+
+  def confirm(message)
+    return true if yes
+    print "#{message} (y/N): "
+    response = $stdin.gets.strip.downcase
+    response == "y" || response == "yes"
+  end
+
+  def step(message)
+    puts "\n→ #{message}..."
+  end
+
+  def success(message)
+    puts "\n✓ #{message}\n"
+  end
+
+  def error(message)
+    puts "\n✗ ERROR: #{message}\n"
+    exit 1
+  end
+end
+
+# Run the script
+if __FILE__ == $0
+  if ARGV.empty?
+    puts "Usage: release.rb [options] COMMAND [VERSION]"
+    puts "Run with --help for more information"
+    exit 1
+  end
+
+  manager = GiblishReleaseManager.new(ARGV)
+  manager.run
+end