rakit 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f146d5f635716871e7960854ae13c5f64dcf353d50b7b57a808f81258580972
-  data.tar.gz: 80f4539d5cb9e02c506789a3ebb4862a280eb750aea7b88449dbcf54222cf6f4
+  metadata.gz: 618281ffaa52461777b6cf921c5290e89dc503ef845adc9410d4934d917ed285
+  data.tar.gz: c3b90837302fb00dac1987e6c181307480ab7133fe113dc65805b307e0c2ed3a
 SHA512:
-  metadata.gz: fe9c41e4505e458900c66bfa5fed2041fed850f568fdcb44cf0843468278a5320317d84d6b97c1b76bc303f683f79ca1b9994a69224574599c8ec5c216b00925
-  data.tar.gz: fc4fd21d2dbefede571552edc32d3f8e62e323ed008e09d7831dd282ad216aca8ba7221af3515f56b2d76897898e40f295d075dbbfb058bb2749d32aeba54507
+  metadata.gz: 9c9b06b9a2fce44ff8cb4b99993c2a6caff13a9b5155cb2202b23000faccdc82853201134bff2cef57bd17400e038d86d6ef3437239c26409587ed78ef3b3c30
+  data.tar.gz: 4b3624c2093bde3d3f0a42959a511793e231dc2fba0a6e2cf7baac4613812355764a11a195cd76ec8abfa7c082813e38243e7276e94de19505fd33499827d0ca

data/lib/rakit/cli/word_cloud.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "json"
+require "google/protobuf"
+require "rakit/word_cloud"
+
+module Rakit
+  module CLI
+    module WordCloud
+      class << self
+        # @param argv [Array<String>] arguments after "word-cloud"
+        # @return [Integer] exit code
+        def run(argv)
+          return usage_stderr("Expected command: status | install | generate") if argv.empty?
+
+          cmd = argv.shift
+          case cmd
+          when "status" then run_status(argv)
+          when "install" then run_install(argv)
+          when "generate" then run_generate(argv)
+          else
+            $stderr.puts "Unknown command: #{cmd}"
+            1
+          end
+        end
+
+        private
+
+        def parse_format(argv)
+          format = "console"
+          args = argv.dup
+          i = args.index("--format")
+          if i && args[i + 1]
+            format = args[i + 1]
+            args.delete_at(i + 1)
+            args.delete_at(i)
+          end
+          [format, args]
+        end
+
+        def run_status(argv)
+          format, _ = parse_format(argv)
+          st = Rakit::WordCloud.status({})
+          render_tool_status(st, format)
+          0
+        end
+
+        def run_install(argv)
+          format, _ = parse_format(argv)
+          result = Rakit::WordCloud.install({})
+          render_install_result(result, format)
+          result.success ? 0 : 1
+        end
+
+        def run_generate(argv)
+          format, rest = parse_format(argv)
+          opts = parse_generate_opts(rest)
+          return 1 if opts[:error]
+
+          request = build_generate_request(opts)
+          return 1 unless request
+
+          stdin_content = opts[:stdin] ? $stdin.read : nil
+          result = Rakit::WordCloud.generate(request, stdin_content: stdin_content)
+
+          if opts[:publish_site_name] && result.success && defined?(Rakit::StaticWebServer)
+            out_dir = ::File.dirname(result.output_image.to_s)
+            begin
+              Rakit::StaticWebServer.publish(opts[:publish_site_name], out_dir)
+            rescue => e
+              $stderr.puts "Publish failed: #{e.message}"
+              return 1
+            end
+          elsif opts[:publish_site_name] && result.success && !defined?(Rakit::StaticWebServer)
+            $stderr.puts "Publish requested but StaticWebServer not available. Require the static web server feature."
+            return 1
+          end
+
+          render_generate_result(result, format)
+          result.success ? 0 : 1
+        end
+
+        def parse_generate_opts(argv)
+          opts = {
+            format: "console",
+            text_file: nil,
+            inline_text: nil,
+            stdin: false,
+            out: nil,
+            width: nil,
+            height: nil,
+            seed: nil,
+            mask: nil,
+            font: nil,
+            exclude_words: nil,
+            max_words: nil,
+            auto_install: false,
+            publish_site_name: nil,
+            working_directory: nil
+          }
+          args = argv.dup
+          while (arg = args.shift)
+            case arg
+            when "--text" then opts[:text_file] = args.shift
+            when "--inline" then opts[:inline_text] = args.shift
+            when "--stdin" then opts[:stdin] = true
+            when "--out" then opts[:out] = args.shift
+            when "--width" then opts[:width] = (args.shift || "0").to_i
+            when "--height" then opts[:height] = (args.shift || "0").to_i
+            when "--seed" then opts[:seed] = (args.shift || "-1").to_i
+            when "--mask" then opts[:mask] = args.shift
+            when "--font" then opts[:font] = args.shift
+            when "--exclude-words" then opts[:exclude_words] = args.shift
+            when "--max-words" then opts[:max_words] = (args.shift || "0").to_i
+            when "--auto-install" then opts[:auto_install] = true
+            when "--publish" then opts[:publish_site_name] = args.shift
+            when "--working-directory" then opts[:working_directory] = args.shift
+            when /^--/
+              $stderr.puts "Unknown option: #{arg}"
+              opts[:error] = true
+            end
+          end
+          opts
+        end
+
+        def build_generate_request(opts)
+          unless opts[:out] && opts[:out].to_s.strip != ""
+            $stderr.puts "generate requires --out PATH"
+            return nil
+          end
+
+          has_file = opts[:text_file] && opts[:text_file].to_s.strip != ""
+          has_inline = opts[:inline_text] && opts[:inline_text].to_s.strip != ""
+          has_stdin = opts[:stdin]
+          count = [has_file, has_inline, has_stdin].count(true)
+          unless count == 1
+            $stderr.puts "Provide exactly one of: --text FILE, --inline \"string\", or --stdin"
+            return nil
+          end
+
+          gen = Rakit::Generated
+          config = gen::WordCloudConfig.new(
+            wcloud_path: "",
+            auto_install: opts[:auto_install],
+            working_directory: (opts[:working_directory] || "").to_s
+          )
+
+          text = if opts[:text_file] && opts[:text_file].to_s.strip != ""
+                   gen::TextSource.new(text_file: opts[:text_file].to_s)
+                 elsif opts[:inline_text] && opts[:inline_text].to_s.strip != ""
+                   gen::TextSource.new(inline_text: opts[:inline_text].to_s)
+                 else
+                   gen::TextSource.new(stdin: true)
+                 end
+
+          req = gen::GenerateRequest.new(
+            config: config,
+            text: text,
+            output_image: opts[:out].to_s,
+            width: opts[:width] || 0,
+            height: opts[:height] || 0,
+            rng_seed: opts[:seed] || -1,
+            mask_image: (opts[:mask] || "").to_s,
+            font_file: (opts[:font] || "").to_s,
+            exclude_words_file: (opts[:exclude_words] || "").to_s,
+            max_words: opts[:max_words] || 0
+          )
+          req
+        end
+
+        def render_tool_status(st, format)
+          case format
+          when "json"
+            puts ({ wcloud_found: st.wcloud_found, wcloud_path: st.wcloud_path, cargo_found: st.cargo_found, cargo_path: st.cargo_path }.to_json)
+          when "proto-json"
+            puts Google::Protobuf.encode_json(st)
+          else
+            puts "wcloud: #{st.wcloud_found ? st.wcloud_path : 'not found'}"
+            puts "cargo: #{st.cargo_found ? st.cargo_path : 'not found'}"
+          end
+        end
+
+        def render_install_result(result, format)
+          case format
+          when "json"
+            puts ({ success: result.success, message: result.message, stderr: result.stderr }.to_json)
+          when "proto-json"
+            puts Google::Protobuf.encode_json(result)
+          else
+            unless result.success
+              $stderr.puts result.message
+              $stderr.puts result.stderr if result.stderr.to_s.strip != ""
+            else
+              puts result.message
+            end
+          end
+        end
+
+        def render_generate_result(result, format)
+          unless result.success
+            $stderr.puts result.message
+            $stderr.puts result.stderr if result.stderr.to_s.strip != "" && result.stderr != result.message
+          end
+          case format
+          when "json"
+            h = { success: result.success, message: result.message, output_image: result.output_image, exit_code: result.exit_code }
+            puts h.to_json
+          when "proto-json"
+            puts Google::Protobuf.encode_json(result)
+          else
+            puts result.message if result.success
+          end
+        end
+
+        def usage_stderr(msg)
+          $stderr.puts msg
+          $stderr.puts "  word-cloud status [--format console|json|proto-json]"
+          $stderr.puts "  word-cloud install [--format ...]"
+          $stderr.puts "  word-cloud generate (--text FILE|--inline \"string\"|--stdin) --out PATH [options]"
+          1
+        end
+      end
+    end
+  end
+end

data/lib/rakit/word_cloud.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "generated/word_cloud_pb"
+require "fileutils"
+require "open3"
+
+module Rakit
+  module WordCloud
+    class << self
+      attr_accessor :wcloud_path, :auto_install, :working_directory
+    end
+
+    self.auto_install = false
+
+    # Validate path has no traversal. If relative, must be under base_dir; absolute paths allowed.
+    def self.path_safe?(path, base_dir)
+      return false if path.nil? || path.to_s.strip.empty?
+      p = path.to_s.strip
+      return false if p.include?("..")
+      base = ::File.expand_path(base_dir.to_s)
+      expanded = ::File.expand_path(p, base)
+      # Absolute path: allow (no traversal)
+      return true if p.start_with?("/") || (p.size >= 2 && p[1] == ":")
+      expanded == base || expanded.start_with?(base + ::File::SEPARATOR)
+    end
+
+    # Validate text file path: exists, readable file, no traversal. base_dir = working_directory or Dir.pwd.
+    def self.validate_text_file_path(path, base_dir)
+      base = ::File.expand_path(base_dir.to_s)
+      expanded = ::File.expand_path(path.to_s, base)
+      return [false, "Path contains traversal (..) or is outside working directory"] unless path_safe?(path, base_dir)
+      return [false, "File does not exist: #{path}"] unless ::File.exist?(expanded)
+      return [false, "Not a file: #{path}"] unless ::File.file?(expanded)
+      return [false, "File not readable: #{path}"] unless ::File.readable?(expanded)
+      [true, expanded]
+    end
+
+    # Validate output image path: parent creatable/writable, no traversal.
+    def self.validate_output_path(path, base_dir)
+      base = ::File.expand_path(base_dir.to_s)
+      expanded = ::File.expand_path(path.to_s, base)
+      return [false, "Path contains traversal (..) or is outside working directory"] unless path_safe?(path, base_dir)
+      parent = ::File.dirname(expanded)
+      begin
+        FileUtils.mkdir_p(parent) unless ::File.directory?(parent)
+      rescue SystemCallError => e
+        return [false, "Cannot create output directory: #{e.message}"]
+      end
+      return [false, "Output path not writable: #{path}"] unless ::File.writable?(parent)
+      [true, expanded]
+    end
+
+    # Validate optional file path (mask, font, exclude-words): if present, must exist and be readable.
+    def self.validate_optional_file_path(path, base_dir, label)
+      return [true, nil] if path.nil? || path.to_s.strip.empty?
+      base = ::File.expand_path(base_dir.to_s)
+      expanded = ::File.expand_path(path.to_s, base)
+      return [false, "#{label}: path contains traversal or is outside working directory"] unless path_safe?(path, base_dir)
+      return [false, "#{label} file does not exist: #{path}"] unless ::File.exist?(expanded)
+      return [false, "#{label} not a file: #{path}"] unless ::File.file?(expanded)
+      return [false, "#{label} not readable: #{path}"] unless ::File.readable?(expanded)
+      [true, expanded]
+    end
+
+    # Resolve wcloud: config path, then ENV RAKIT_WCLOUD_BINARY, then which wcloud.
+    def self.resolve_wcloud(config = {})
+      path = config[:wcloud_path] || config["wcloud_path"] || self.wcloud_path
+      return path if path && path.to_s.strip != "" && ::File.executable?(::File.expand_path(path))
+      env_path = ENV["RAKIT_WCLOUD_BINARY"]
+      return env_path if env_path && env_path.to_s.strip != "" && ::File.executable?(::File.expand_path(env_path))
+      which("wcloud")
+    end
+
+    # Resolve cargo: which cargo.
+    def self.resolve_cargo(_config = {})
+      which("cargo")
+    end
+
+    # Status: resolve wcloud and cargo; no side effects. Returns ToolStatus.
+    def self.status(config = {})
+      cfg = config.is_a?(Hash) ? config : {}
+      wcloud_path = cfg[:wcloud_path] || cfg["wcloud_path"] || self.wcloud_path
+      wcloud_bin = resolve_wcloud(cfg)
+      cargo_bin = resolve_cargo(cfg)
+      Rakit::Generated::ToolStatus.new(
+        wcloud_found: !wcloud_bin.nil?,
+        wcloud_path: wcloud_bin.to_s,
+        cargo_found: !cargo_bin.nil?,
+        cargo_path: cargo_bin.to_s
+      )
+    end
+
+    # Install: run cargo install wcloud. Returns GenerateResult with success, message, stderr.
+    def self.install(config = {})
+      cfg = config.is_a?(Hash) ? config : {}
+      cargo_bin = resolve_cargo(cfg)
+      unless cargo_bin
+        return fail_result("", "cargo not found. Install Rust from https://rustup.rs/ then run: cargo install wcloud", -1)
+      end
+      _stdout, stderr, status = Open3.capture3(cargo_bin, "install", "wcloud")
+      Rakit::Generated::GenerateResult.new(
+        success: status.success?,
+        message: status.success? ? "wcloud installed or already present" : stderr.to_s.strip,
+        output_image: "",
+        exit_code: status.exitstatus,
+        stdout: "",
+        stderr: stderr.to_s
+      )
+    end
+
+    def self.which(cmd)
+      exe = nil
+      ENV["PATH"].to_s.split(::File::PATH_SEPARATOR).each do |dir|
+        full = ::File.join(dir.strip, cmd)
+        if ::File.executable?(full)
+          exe = full
+          break
+        end
+      end
+      exe
+    end
+
+    # Generate word cloud. request is GenerateRequest. Optional stdin_content when text source is stdin.
+    # Returns GenerateResult. Does not leave partial output on validation or tool failure.
+    def self.generate(request, stdin_content: nil)
+      cfg = request.config || Rakit::Generated::WordCloudConfig.new
+      base_dir = (cfg.working_directory.to_s.strip != "") ? cfg.working_directory : (self.working_directory || Dir.pwd)
+
+      # Resolve text content and validate non-empty
+      content, err = resolve_text_content(request.text, base_dir, stdin_content)
+      unless content
+        return fail_result(request.output_image.to_s, err, -1)
+      end
+
+      # Validate output path (creates parent if missing)
+      ok, out_path = validate_output_path(request.output_image.to_s, base_dir)
+      unless ok
+        return fail_result(request.output_image.to_s, out_path, -1)
+      end
+
+      # Optional file paths (mask, font, exclude-words)
+      mask_path = request.mask_image.to_s.strip
+      if mask_path != ""
+        ok, err = validate_optional_file_path(mask_path, base_dir, "Mask image")
+        return fail_result(out_path, err, -1) unless ok
+      end
+      font_path = request.font_file.to_s.strip
+      if font_path != ""
+        ok, err = validate_optional_file_path(font_path, base_dir, "Font file")
+        return fail_result(out_path, err, -1) unless ok
+      end
+      exclude_path = request.exclude_words_file.to_s.strip
+      if exclude_path != ""
+        ok, err = validate_optional_file_path(exclude_path, base_dir, "Exclude-words file")
+        return fail_result(out_path, err, -1) unless ok
+      end
+
+      config_hash = { wcloud_path: cfg.wcloud_path.to_s, auto_install: cfg.auto_install }
+      wcloud_bin = resolve_wcloud(config_hash)
+      if wcloud_bin.nil? && cfg.auto_install
+        install_result = install(config_hash)
+        unless install_result.success
+          return fail_result(out_path, "wcloud not found and auto-install failed: #{install_result.message}", -1)
+        end
+        wcloud_bin = resolve_wcloud(config_hash)
+      end
+      unless wcloud_bin
+        return fail_result(out_path, "wcloud not found. Install with: cargo install wcloud", -1)
+      end
+
+      argv = build_wcloud_argv(request, out_path, mask_path, font_path, exclude_path)
+      stdout, stderr, exit_code = run_wcloud(wcloud_bin, argv, stdin: content)
+
+      result = Rakit::Generated::GenerateResult.new(
+        success: exit_code == 0,
+        message: exit_code == 0 ? "OK" : stderr.to_s.strip,
+        output_image: out_path,
+        exit_code: exit_code,
+        stdout: stdout.to_s,
+        stderr: stderr.to_s,
+        wcloud_resolved_path: wcloud_bin
+      )
+      unless result.success
+        ::File.unlink(out_path) if ::File.exist?(out_path)
+      end
+      result
+    end
+
+    def self.fail_result(output_image, message, exit_code)
+      Rakit::Generated::GenerateResult.new(
+        success: false,
+        message: message.to_s,
+        output_image: output_image.to_s,
+        exit_code: exit_code,
+        stdout: "",
+        stderr: message.to_s
+      )
+    end
+
+    def self.resolve_text_content(text_source, base_dir, stdin_content)
+      return [nil, "Text source is empty; provide non-empty text."] if text_source.nil?
+
+      case text_source.source
+      when :text_file
+        path = text_source.text_file.to_s.strip
+        return [nil, "Text file path is empty."] if path.empty?
+        ok, expanded = validate_text_file_path(path, base_dir)
+        return [nil, expanded] unless ok
+        content = ::File.read(expanded)
+        return [nil, "Text source is empty; provide non-empty text."] if content.to_s.strip.empty?
+        return [content, nil]
+      when :inline_text
+        content = text_source.inline_text.to_s
+        return [nil, "Text source is empty; provide non-empty text."] if content.strip.empty?
+        return [content, nil]
+      when :stdin
+        content = stdin_content.to_s
+        return [nil, "Text source is empty; provide non-empty text."] if content.strip.empty?
+        return [content, nil]
+      else
+        [nil, "Invalid text source."]
+      end
+    end
+
+    def self.build_wcloud_argv(request, out_path, mask_path, font_path, exclude_path)
+      argv = ["-o", out_path]
+      argv += ["--width", request.width.to_s] if request.width && request.width > 0
+      argv += ["--height", request.height.to_s] if request.height && request.height > 0
+      argv += ["--seed", request.rng_seed.to_s] if request.rng_seed && request.rng_seed >= 0
+      argv += ["--mask", mask_path] if mask_path != ""
+      argv += ["--font", font_path] if font_path != ""
+      argv += ["--exclude-words", exclude_path] if exclude_path != ""
+      argv += ["--max-words", request.max_words.to_s] if request.max_words && request.max_words > 0
+      argv
+    end
+
+    # Run wcloud with argv (no shell). Optional stdin: string. Returns [stdout, stderr, exit_status].
+    def self.run_wcloud(wcloud_bin, argv, stdin: nil)
+      if stdin
+        stdout, stderr, status = Open3.capture3(wcloud_bin, *argv, stdin_data: stdin)
+      else
+        stdout, stderr, status = Open3.capture3(wcloud_bin, *argv)
+      end
+      [stdout.to_s, stderr.to_s, status.exitstatus]
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rakit
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - rakit
@@ -131,6 +131,7 @@ files:
 - lib/rakit/azure/dev_ops.rb
 - lib/rakit/cli/file.rb
 - lib/rakit/cli/markdown.rb
+- lib/rakit/cli/word_cloud.rb
 - lib/rakit/cli/word_count.rb
 - lib/rakit/file.rb
 - lib/rakit/gem.rb
@@ -140,6 +141,7 @@ files:
 - lib/rakit/shell.rb
 - lib/rakit/static_web_server.rb
 - lib/rakit/task.rb
+- lib/rakit/word_cloud.rb
 - lib/rakit/word_count.rb
 homepage: https://gitlab.com/gems/rakit
 licenses: