expressir 2.1.18 → 2.1.20

data/lib/expressir/cli.rb

@@ -1,32 +1,32 @@
 require "thor"
 require "yaml"
+require "terminal-table"
+
+require_relative "commands/base"
+require_relative "commands/format"
+require_relative "commands/clean"
+require_relative "commands/benchmark"
+require_relative "commands/benchmark_cache"
+require_relative "commands/validate"
+require_relative "commands/coverage"
+require_relative "commands/version"
 
 module Expressir
   class Cli < Thor
+    # Exit with error code on command failures
+    def self.exit_on_failure?
+      true
+    end
+
     desc "format PATH", "pretty print EXPRESS schema located at PATH"
     def format(path)
-      repository = Expressir::Express::Parser.from_file(path)
-      repository.schemas.each do |schema|
-        puts "\n(* Expressir formatted schema: #{schema.id} *)\n"
-        puts schema.to_s(no_remarks: true)
-      end
+      Commands::Format.new(options).run(path)
     end
 
     desc "clean PATH", "Strip remarks and prettify EXPRESS schema at PATH"
     method_option :output, type: :string, desc: "Output file path (defaults to stdout)"
     def clean(path)
-      repository = Expressir::Express::Parser.from_file(path)
-      formatted_schemas = repository.schemas.map do |schema|
-        # Format schema without remarks
-        schema.to_s(no_remarks: true)
-      end.join("\n\n")
-
-      if options[:output]
-        File.write(options[:output], formatted_schemas)
-        puts "Cleaned schema written to #{options[:output]}"
-      else
-        puts formatted_schemas
-      end
+      Commands::Clean.new(options).run(path)
     end
 
     desc "benchmark FILE_OR_YAML", "Benchmark schema loading performance for a file or list of files from YAML"
@@ -35,18 +35,7 @@ module Expressir
     method_option :save, type: :boolean, desc: "Save benchmark results to file"
     method_option :format, type: :string, desc: "Output format (json, csv, default)"
     def benchmark(path)
-      # Enable benchmarking via configuration
-      Expressir.configuration.benchmark_enabled = true
-      Expressir.configuration.benchmark_ips = options[:ips]
-      Expressir.configuration.benchmark_verbose = options[:verbose]
-      Expressir.configuration.benchmark_save = options[:save]
-      Expressir.configuration.benchmark_format = options[:format] if options[:format]
-
-      if [".yml", ".yaml"].include?(File.extname(path).downcase)
-        benchmark_from_yaml(path)
-      else
-        benchmark_file(path)
-      end
+      Commands::Benchmark.new(options).run(path)
     end
 
     desc "benchmark-cache FILE_OR_YAML", "Benchmark schema loading with caching"
@@ -56,178 +45,25 @@ module Expressir
     method_option :format, type: :string, desc: "Output format (json, csv, default)"
     method_option :cache_path, type: :string, desc: "Path to store the cache file"
     def benchmark_cache(path)
-      # Same options as benchmark + cache_path
-      Expressir.configuration.benchmark_enabled = true
-      Expressir.configuration.benchmark_ips = options[:ips]
-      Expressir.configuration.benchmark_verbose = options[:verbose]
-      Expressir.configuration.benchmark_save = options[:save]
-      Expressir.configuration.benchmark_format = options[:format] if options[:format]
-
-      # Run benchmarks with cache
-      cache_path = options[:cache_path] || generate_temp_cache_path
-
-      if [".yml", ".yaml"].include?(File.extname(path).downcase)
-        benchmark_cache_from_yaml(path, cache_path)
-      else
-        benchmark_cache_file(path, cache_path)
-      end
-    end
-
-    no_commands do
-      def _validate_schema(path)
-        repository = Expressir::Express::Parser.from_file(path)
-        repository.schemas.inject([]) do |acc, schema|
-          acc << schema.id unless schema.version&.value
-          acc
-        end
-      rescue StandardError
-        nil
-      end
-
-      def _print_validation_errors(type, array)
-        return if array.empty?
-
-        puts "#{'*' * 20} RESULTS: #{type.to_s.upcase.tr('_', ' ')} #{'*' * 20}"
-        array.each do |msg|
-          puts msg
-        end
-      end
-
-      def benchmark_file(path)
-        puts "Express Schema Loading Benchmark"
-        puts "--------------------------------"
-
-        repository = Expressir::Benchmark.measure_file(path) do
-          Expressir::Express::Parser.from_file(path)
-        end
-
-        if repository
-          puts "Loaded #{repository.schemas.size} schemas"
-        else
-          puts "Failed to load schema"
-        end
-      end
-
-      def benchmark_from_yaml(yaml_path)
-        puts "Express Schema Loading Benchmark from YAML"
-        puts "--------------------------------"
-
-        # Load schema list from YAML
-        schema_list = YAML.load_file(yaml_path)
-        if schema_list.is_a?(Hash) && schema_list["schemas"]
-          # Handle format: { "schemas": ["path1", "path2", ...] }
-          schema_files = schema_list["schemas"]
-        elsif schema_list.is_a?(Array)
-          # Handle format: ["path1", "path2", ...]
-          schema_files = schema_list
-        else
-          puts "Invalid YAML format. Expected an array of schema paths or a hash with a 'schemas' key."
-          return
-        end
-
-        puts "YAML File: #{yaml_path}"
-        puts "Number of schemas in list: #{schema_files.size}"
-        puts "--------------------------------"
-
-        # Load the schemas
-        Expressir::Benchmark.measure_collection(schema_files) do |file|
-          repository = Expressir::Express::Parser.from_file(file)
-          repository.schemas
-        end
-      end
-
-      def benchmark_cache_file(path, cache_path)
-        puts "Express Schema Loading Benchmark with Caching"
-        puts "--------------------------------"
-        puts "Schema: #{path}"
-        puts "Cache: #{cache_path}"
-        puts "--------------------------------"
-
-        # Benchmark with caching
-        results = Expressir::Benchmark.measure_with_cache(path, cache_path) do |file|
-          Expressir::Express::Parser.from_file(file)
-        end
-
-        if results[:repository]
-          schema_count = results[:repository].schemas.size
-          puts "Loaded #{schema_count} schemas"
-        else
-          puts "Failed to load schema"
-        end
-      end
-
-      def benchmark_cache_from_yaml(yaml_path, cache_path)
-        puts "Express Schema Loading Benchmark with Caching from YAML"
-        puts "--------------------------------"
-
-        # Load schema list from YAML
-        schema_list = YAML.load_file(yaml_path)
-        if schema_list.is_a?(Hash) && schema_list["schemas"]
-          # Handle format: { "schemas": ["path1", "path2", ...] }
-          schema_files = schema_list["schemas"]
-        elsif schema_list.is_a?(Array)
-          # Handle format: ["path1", "path2", ...]
-          schema_files = schema_list
-        else
-          puts "Invalid YAML format. Expected an array of schema paths or a hash with a 'schemas' key."
-          return
-        end
-
-        puts "YAML File: #{yaml_path}"
-        puts "Number of schemas in list: #{schema_files.size}"
-        puts "Cache: #{cache_path}"
-        puts "--------------------------------"
-
-        # Process each file with caching
-        schema_files.each_with_index do |file, index|
-          puts "Processing file #{index + 1}/#{schema_files.size}: #{file}"
-
-          # Benchmark with caching
-          Expressir::Benchmark.measure_with_cache(file, cache_path) do |path|
-            Expressir::Express::Parser.from_file(path)
-          end
-
-          puts "--------------------------------"
-        end
-      end
-
-      def generate_temp_cache_path
-        require "tempfile"
-        Tempfile.new(["expressir_cache", ".bin"]).path
-      end
+      Commands::BenchmarkCache.new(options).run(path)
     end
 
     desc "validate *PATH", "validate EXPRESS schema located at PATH"
-    def validate(*paths) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-      no_version = []
-      no_valid = []
-
-      paths.each do |path|
-        x = Pathname.new(path).realpath.relative_path_from(Dir.pwd)
-        puts "Validating #{x}"
-        ret = _validate_schema(path)
-
-        if ret.nil?
-          no_valid << "Failed to parse: #{x}"
-          next
-        end
-
-        ret.each do |schema_id|
-          no_version << "Missing version string: schema `#{schema_id}` | #{x}"
-        end
-      end
-
-      _print_validation_errors(:failed_to_parse, no_valid)
-      _print_validation_errors(:missing_version_string, no_version)
-
-      exit 1 unless [no_valid, no_version].all?(&:empty?)
+    def validate(*paths)
+      Commands::Validate.new(options).run(paths)
+    end
 
-      puts "Validation passed for all EXPRESS schemas."
+    desc "coverage *PATH", "List EXPRESS entities and check documentation coverage"
+    method_option :format, type: :string, desc: "Output format (text, json, yaml)", default: "text"
+    method_option :exclude, type: :string, desc: "Comma-separated list of EXPRESS entity types to skip from coverage (e.g., TYPE,CONSTANT,TYPE:SELECT)"
+    method_option :output, type: :string, desc: "Output file path for JSON/YAML formats (defaults to coverage_report.json/yaml)"
+    def coverage(*paths)
+      Commands::Coverage.new(options).run(paths)
     end
 
     desc "version", "Expressir Version"
     def version
-      say(Expressir::VERSION)
+      Commands::Version.new(options).run
     end
   end
 end

data/lib/expressir/commands/base.rb

@@ -0,0 +1,32 @@
+module Expressir
+  module Commands
+    class Base
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      # Common utilities that all commands might need
+      def say(message)
+        # Use instance variable for testability - if output is set, use it
+        if defined?(@output) && @output
+          @output.puts(message)
+        else
+          puts(message)
+        end
+      end
+
+      def exit_with_error(message, exit_code = 1)
+        say message
+        # In test mode, raise an exception instead of exiting
+        # This makes it easier to test error cases
+        if defined?(@test_mode) && @test_mode
+          raise message # Just raise the message as an exception
+        else
+          exit exit_code
+        end
+      end
+    end
+  end
+end

data/lib/expressir/commands/benchmark.rb

@@ -0,0 +1,68 @@
+module Expressir
+  module Commands
+    class Benchmark < Base
+      def run(path)
+        configure_benchmarking
+
+        if [".yml", ".yaml"].include?(File.extname(path).downcase)
+          benchmark_from_yaml(path)
+        else
+          benchmark_file(path)
+        end
+      end
+
+      private
+
+      def configure_benchmarking
+        Expressir.configuration.benchmark_enabled = true
+        Expressir.configuration.benchmark_ips = options[:ips]
+        Expressir.configuration.benchmark_verbose = options[:verbose]
+        Expressir.configuration.benchmark_save = options[:save]
+        Expressir.configuration.benchmark_format = options[:format] if options[:format]
+      end
+
+      def benchmark_file(path)
+        say "Express Schema Loading Benchmark"
+        say "--------------------------------"
+
+        repository = Expressir::Benchmark.measure_file(path) do
+          Expressir::Express::Parser.from_file(path)
+        end
+
+        if repository
+          say "Loaded #{repository.schemas.size} schemas"
+        else
+          say "Failed to load schema"
+        end
+      end
+
+      def benchmark_from_yaml(yaml_path)
+        say "Express Schema Loading Benchmark from YAML"
+        say "--------------------------------"
+
+        # Load schema list from YAML
+        schema_list = YAML.load_file(yaml_path)
+        if schema_list.is_a?(Hash) && schema_list["schemas"]
+          # Handle format: { "schemas": ["path1", "path2", ...] }
+          schema_files = schema_list["schemas"]
+        elsif schema_list.is_a?(Array)
+          # Handle format: ["path1", "path2", ...]
+          schema_files = schema_list
+        else
+          say "Invalid YAML format. Expected an array of schema paths or a hash with a 'schemas' key."
+          return
+        end
+
+        say "YAML File: #{yaml_path}"
+        say "Number of schemas in list: #{schema_files.size}"
+        say "--------------------------------"
+
+        # Load the schemas
+        Expressir::Benchmark.measure_collection(schema_files) do |file|
+          repository = Expressir::Express::Parser.from_file(file)
+          repository.schemas
+        end
+      end
+    end
+  end
+end

data/lib/expressir/commands/benchmark_cache.rb

@@ -0,0 +1,88 @@
+module Expressir
+  module Commands
+    class BenchmarkCache < Base
+      def run(path)
+        configure_benchmarking
+
+        # Run benchmarks with cache
+        cache_path = options[:cache_path] || generate_temp_cache_path
+
+        if [".yml", ".yaml"].include?(File.extname(path).downcase)
+          benchmark_cache_from_yaml(path, cache_path)
+        else
+          benchmark_cache_file(path, cache_path)
+        end
+      end
+
+      private
+
+      def configure_benchmarking
+        Expressir.configuration.benchmark_enabled = true
+        Expressir.configuration.benchmark_ips = options[:ips]
+        Expressir.configuration.benchmark_verbose = options[:verbose]
+        Expressir.configuration.benchmark_save = options[:save]
+        Expressir.configuration.benchmark_format = options[:format] if options[:format]
+      end
+
+      def benchmark_cache_file(path, cache_path)
+        say "Express Schema Loading Benchmark with Caching"
+        say "--------------------------------"
+        say "Schema: #{path}"
+        say "Cache: #{cache_path}"
+        say "--------------------------------"
+
+        # Benchmark with caching
+        results = Expressir::Benchmark.measure_with_cache(path, cache_path) do |file|
+          Expressir::Express::Parser.from_file(file)
+        end
+
+        if results[:repository]
+          schema_count = results[:repository].schemas.size
+          say "Loaded #{schema_count} schemas"
+        else
+          say "Failed to load schema"
+        end
+      end
+
+      def benchmark_cache_from_yaml(yaml_path, cache_path)
+        say "Express Schema Loading Benchmark with Caching from YAML"
+        say "--------------------------------"
+
+        # Load schema list from YAML
+        schema_list = YAML.load_file(yaml_path)
+        if schema_list.is_a?(Hash) && schema_list["schemas"]
+          # Handle format: { "schemas": ["path1", "path2", ...] }
+          schema_files = schema_list["schemas"]
+        elsif schema_list.is_a?(Array)
+          # Handle format: ["path1", "path2", ...]
+          schema_files = schema_list
+        else
+          say "Invalid YAML format. Expected an array of schema paths or a hash with a 'schemas' key."
+          return
+        end
+
+        say "YAML File: #{yaml_path}"
+        say "Number of schemas in list: #{schema_files.size}"
+        say "Cache: #{cache_path}"
+        say "--------------------------------"
+
+        # Process each file with caching
+        schema_files.each_with_index do |file, index|
+          say "Processing file #{index + 1}/#{schema_files.size}: #{file}"
+
+          # Benchmark with caching
+          Expressir::Benchmark.measure_with_cache(file, cache_path) do |path|
+            Expressir::Express::Parser.from_file(path)
+          end
+
+          say "--------------------------------"
+        end
+      end
+
+      def generate_temp_cache_path
+        require "tempfile"
+        Tempfile.new(["expressir_cache", ".bin"]).path
+      end
+    end
+  end
+end

data/lib/expressir/commands/clean.rb

@@ -0,0 +1,20 @@
+module Expressir
+  module Commands
+    class Clean < Base
+      def run(path)
+        repository = Expressir::Express::Parser.from_file(path)
+        formatted_schemas = repository.schemas.map do |schema|
+          # Format schema without remarks
+          schema.to_s(no_remarks: true)
+        end.join("\n\n")
+
+        if options[:output]
+          File.write(options[:output], formatted_schemas)
+          say "Cleaned schema written to #{options[:output]}"
+        else
+          say formatted_schemas
+        end
+      end
+    end
+  end
+end