suma 0.2.5 → 0.2.6

data/lib/suma/cli/compare.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
 require "thor"
-require_relative "../eengine/wrapper"
-require_relative "../eengine_converter"
+require_relative "../schema_comparer"
 
 module Suma
   module Cli
-    # Command to compare EXPRESS schemas using eengine
     class Compare < Thor
       desc "compare TRIAL_SCHEMA REFERENCE_SCHEMA",
            "Compare EXPRESS schemas using eengine and generate Change YAML"
@@ -44,166 +42,17 @@ module Suma
                        desc: "Enable verbose output"
 
       def compare(trial_schema, reference_schema)
-        # Validate schema files exist
-        unless File.exist?(trial_schema)
-          say "Error: Trial schema not found: #{trial_schema}", :red
-          exit 1
-        end
-
-        unless File.exist?(reference_schema)
-          say "Error: Reference schema not found: #{reference_schema}", :red
-          exit 1
-        end
-
-        # Check eengine availability
-        unless Eengine::Wrapper.available?
-          say "Error: eengine not found in PATH", :red
-          say "Install eengine following instructions at:"
-          say "  macOS: https://github.com/expresslang/homebrew-eengine"
-          say "  Linux: https://github.com/expresslang/eengine-releases"
-          exit 1
-        end
+        comparer = SchemaComparer.new(trial_schema, reference_schema, options)
 
-        # Auto-detect repo roots
-        trial_stepmod = options[:trial_stepmod] ||
-          detect_repo_root(trial_schema)
-        reference_stepmod = options[:reference_stepmod] ||
-          detect_repo_root(reference_schema)
+        result = comparer.compare
 
-        if options[:verbose]
-          say "Using eengine version: #{Eengine::Wrapper.version}", :green
-          say "Trial repo root: #{trial_stepmod}", :cyan
-          say "Reference repo root: #{reference_stepmod}", :cyan
-        end
-
-        # Create a temporary directory for eengine output
-        require "tmpdir"
-        out_dir = nil
-        out_dir = Dir.mktmpdir("eengine-compare-")
-
-        # Run comparison
-        result = Eengine::Wrapper.compare(
-          trial_schema,
-          reference_schema,
-          mode: options[:mode],
-          trial_stepmod: trial_stepmod,
-          reference_stepmod: reference_stepmod,
-          out_dir: out_dir,
-        )
-
-        unless result[:has_changes]
+        if result.nil?
           say "No changes detected between schemas", :yellow
-          # Clean up temp directory
-          FileUtils.rm_rf(out_dir) if out_dir && File.directory?(out_dir)
-          return
-        end
-
-        unless result[:xml_path]
-          say "Error: XML output not found", :red
-          exit 1
-        end
-
-        if options[:verbose]
-          say "Comparison XML generated: #{result[:xml_path]}", :green
-        end
-
-        # Convert to Change YAML
-        convert_to_change_yaml(result[:xml_path], trial_schema, out_dir)
-      rescue Eengine::EengineError => e
-        # Clean up temp directory
-        FileUtils.rm_rf(out_dir) if out_dir && File.directory?(out_dir)
-        say "Error: #{e.message}", :red
-        say e.stderr if e.respond_to?(:stderr) && options[:verbose]
-        exit 1
-      end
-
-      private
-
-      def detect_repo_root(schema_path)
-        # Walk up from schema path to find .git directory
-        current = File.expand_path(File.dirname(schema_path))
-
-        loop do
-          if File.directory?(File.join(current, ".git"))
-            return current
-          end
-
-          parent = File.dirname(current)
-          break if parent == current # reached root
-
-          current = parent
-        end
-
-        # If no .git found, use the directory containing the schema
-        # (for non-git workflows)
-        File.dirname(schema_path)
-      end
-
-      def convert_to_change_yaml(xml_path, trial_schema, out_dir)
-        schema_name = extract_schema_name(trial_schema)
-        output_path = determine_output_path(trial_schema)
-
-        # Load existing ChangeSchema if it exists
-        existing_schema = if File.exist?(output_path)
-                            if options[:verbose]
-                              say "Loading existing change schema: " \
-                                  "#{output_path}", :cyan
-                            end
-                            require "expressir/changes"
-                            Expressir::Changes::SchemaChange.from_file(output_path)
-                          end
-
-        # Convert using Suma's converter
-        converter = EengineConverter.new(xml_path, schema_name)
-        change_schema = converter.convert(
-          version: options[:version],
-          existing_change_schema: existing_schema,
-        )
-
-        # Save using Expressir model
-        change_schema.to_file(output_path)
-
-        # Determine what action was taken
-        if existing_schema
-          existing_version = existing_schema.versions.find do |ed|
-            ed.version == options[:version]
-          end
-
-          say "Change YAML file updated: #{output_path}", :green
-          if existing_version
-            say "  Replaced existing version #{options[:version]}", :green
-          else
-            say "  Added version #{options[:version]} to change versions",
-                :green
-          end
-        else
-          say "Change YAML file created: #{output_path}", :green
-        end
-
-        if options[:verbose]
-          say "\nGenerated change schema content:", :cyan
-          say File.read(output_path)
-        end
-
-        # Clean up temp directory and XML file
-        FileUtils.rm_rf(out_dir) if out_dir && File.directory?(out_dir)
-      end
-
-      def extract_schema_name(path)
-        # Remove version suffix if present (e.g., schema_1.exp -> schema)
-        basename = File.basename(path, ".exp")
-        basename.sub(/_\d+$/, "")
-      end
-
-      def determine_output_path(trial_schema)
-        if options[:output]
-          options[:output]
         else
-          # Place .changes.yaml next to the trial schema in the NEW repo
-          base = extract_schema_name(trial_schema)
-          dir = File.dirname(trial_schema)
-          File.join(dir, "#{base}.changes.yaml")
+          say "Change YAML file: #{result}", :green
         end
+      rescue Suma::Error => e
+        raise Thor::Error, e.message
       end
     end
   end

data/lib/suma/cli/export.rb

@@ -2,7 +2,6 @@
 
 require "thor"
 require_relative "../thor_ext"
-require_relative "../export_standalone_schema"
 
 module Suma
   module Cli
@@ -85,12 +84,7 @@ module Suma
       end
 
       def create_schema_from_exp_file(exp_file)
-        # Create a schema object from a standalone EXPRESS file
-        # The id will be determined during parsing
-        ExportStandaloneSchema.new(
-          id: nil,
-          path: File.expand_path(exp_file),
-        )
+        Struct.new(:id, :path).new(nil, File.expand_path(exp_file))
       end
 
       def self.exit_on_failure?