strata-cli 0.1.0.beta

data/lib/strata/cli/utils/import_manager.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "digest"
+require "fileutils"
+require "pathname"
+require_relative "git"
+
+module Strata
+  module CLI
+    module Utils
+      # Manages imported files and tracks external imports in strata.lock.
+      module ImportManager
+        module_function
+
+        LOCK_FILE = "strata.lock"
+
+        def validate_import_path(import_path)
+          if Pathname.new(import_path).absolute?
+            raise Strata::InvalidImportPathError, "Import paths must be relative, not absolute: #{import_path}"
+          end
+        end
+
+        def track_external_import(import_path, resolved_path, project_path)
+          return resolved_path unless external_import?(resolved_path, project_path)
+
+          lock_data = load_lock_file(project_path)
+          current_hash = file_hash(resolved_path)
+
+          # Find existing entry by path (as specified in YAML)
+          existing = find_existing_import(import_path, lock_data)
+
+          if existing && existing["hash"] == current_hash
+            # Hash unchanged, no update needed
+            return resolved_path
+          end
+
+          # Update or add entry
+          entry = {
+            "path" => import_path,
+            "source" => resolved_path,
+            "hash" => current_hash,
+            "imported_at" => Time.now.utc.iso8601
+          }
+
+          lock_data["imports"] ||= []
+          lock_data["imports"].reject! { |e| e["path"] == import_path }
+          lock_data["imports"] << entry
+
+          save_lock_file(project_path, lock_data)
+
+          resolved_path
+        end
+
+        def resolve_with_fallback(import_path, base_dir, project_path)
+          # Validate path is relative
+          validate_import_path(import_path)
+
+          resolved_path = File.expand_path(import_path, base_dir)
+
+          unless File.exist?(resolved_path)
+            raise Strata::MissingImportError, "Import file not found: #{import_path}"
+          end
+
+          # Track external imports in lock file
+          track_external_import(import_path, resolved_path, project_path)
+
+          resolved_path
+        end
+
+        def check_changed_imports(project_path)
+          lock_data = load_lock_file(project_path)
+          return [] unless lock_data["imports"]
+
+          changed = []
+          lock_data["imports"].each do |entry|
+            next unless entry["source"] && File.exist?(entry["source"])
+
+            current_hash = file_hash(entry["source"])
+            if current_hash != entry["hash"]
+              changed << {
+                path: entry["path"],
+                source: entry["source"],
+                old_hash: entry["hash"],
+                new_hash: current_hash
+              }
+            end
+          end
+
+          changed
+        end
+
+        def refresh_external_imports(project_path)
+          lock_data = load_lock_file(project_path)
+          return [] unless lock_data["imports"]
+
+          refreshed = []
+          lock_data["imports"].each do |entry|
+            next unless entry["source"] && File.exist?(entry["source"])
+
+            current_hash = file_hash(entry["source"])
+            if current_hash != entry["hash"]
+              entry["hash"] = current_hash
+              entry["imported_at"] = Time.now.utc.iso8601
+              refreshed << {
+                path: entry["path"],
+                source: entry["source"],
+                hash: current_hash
+              }
+            end
+          end
+
+          save_lock_file(project_path, lock_data) if refreshed.any?
+
+          refreshed
+        end
+
+        def generate_import_commit_hash(project_path)
+          lock_data = load_lock_file(project_path)
+          return nil unless lock_data["imports"]&.any?
+
+          # Create a hash from all import hashes combined
+          import_hashes = lock_data["imports"].map { |e| "#{e["path"]}:#{e["hash"]}" }.sort.join("|")
+          Digest::SHA256.hexdigest(import_hashes)[0..15]
+        end
+
+        private_class_method def external_import?(resolved_path, project_path)
+          project_abs = File.expand_path(project_path)
+          import_abs = File.expand_path(resolved_path)
+          !import_abs.start_with?(project_abs)
+        end
+
+        private_class_method def load_lock_file(project_path)
+          default_lock_data = {"imports" => []}
+          lock_path = File.join(project_path, LOCK_FILE)
+          return default_lock_data unless File.exist?(lock_path)
+
+          YAML.safe_load_file(lock_path, permitted_classes: [Date, Time], aliases: true) || default_lock_data
+        rescue => e
+          warn "Failed to load lock file: #{e.message}" if ENV["DEBUG"]
+          default_lock_data
+        end
+
+        private_class_method def save_lock_file(project_path, lock_data)
+          lock_path = File.join(project_path, LOCK_FILE)
+          begin
+            File.write(lock_path, YAML.dump(lock_data))
+
+            # Automatically commit the lock file to git if it changed
+            git_dir = File.join(project_path, ".git")
+            if File.directory?(git_dir)
+              relative_lock_path = LOCK_FILE
+              commit_message = "[Strata-CLI] Update strata.lock with external import changes"
+              Git.commit_file(relative_lock_path, commit_message, project_path)
+            end
+          rescue Errno::EACCES => e
+            raise Strata::CommandError, "Permission denied writing to #{lock_path}: #{e.message}"
+          rescue Errno::ENOSPC => e
+            raise Strata::CommandError, "Disk full: #{e.message}"
+          rescue => e
+            raise Strata::CommandError, "Failed to write lock file #{lock_path}: #{e.message}"
+          end
+        end
+
+        private_class_method def file_hash(file_path)
+          return nil unless File.exist?(file_path)
+
+          Digest::SHA256.file(file_path).hexdigest
+        end
+
+        private_class_method def find_existing_import(import_path, lock_data)
+          return nil unless lock_data["imports"]
+
+          lock_data["imports"].find { |entry| entry["path"] == import_path }
+        end
+
+        # Public accessors for testing/debugging
+        def load_lock_file_public(project_path)
+          load_lock_file(project_path)
+        end
+        module_function :load_lock_file_public
+
+        def file_hash_public(file_path)
+          file_hash(file_path)
+        end
+        module_function :file_hash_public
+      end
+    end
+  end
+end

data/lib/strata/cli/utils/test_reporter.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "../helpers/color_helper"
+require_relative "../terminal"
+
+module Strata
+  module CLI
+    module Utils
+      class TestReporter
+        include Terminal
+
+        def initialize(color_helper: ColorHelper)
+          @color_helper = color_helper
+        end
+
+        def display(test_results, skip_opening_divider: false)
+          return unless test_results.is_a?(Hash) && test_results["tests"].is_a?(Array)
+
+          display_summary(test_results, skip_opening_divider: skip_opening_divider)
+          display_failures(test_results) if has_failures?(test_results)
+        end
+
+        private
+
+        attr_reader :color_helper
+
+        def say(message, color_helper_result = nil)
+          if color_helper_result
+            if color_helper_result.is_a?(Array)
+              colored_message = ColorHelper.pastel.decorate(message, *color_helper_result)
+              $stdout.puts(colored_message)
+            elsif color_helper_result.is_a?(Symbol)
+              theme = ColorHelper::THEME[color_helper_result]
+              if theme
+                styles = Array(theme)
+                colored_message = ColorHelper.pastel.decorate(message, *styles)
+                $stdout.puts(colored_message)
+              else
+                begin
+                  colored_message = ColorHelper.pastel.send(color_helper_result, message)
+                  $stdout.puts(colored_message)
+                rescue NoMethodError
+                  $stdout.puts(message)
+                end
+              end
+            else
+              $stdout.puts(message)
+            end
+          else
+            $stdout.puts(message)
+          end
+        end
+
+        def display_summary(test_results, skip_opening_divider: false)
+          tests = test_results["tests"] || []
+          total = tests.length
+          passed = tests.count { |t| t["status"] == "passed" }
+          failed = tests.count { |t| t["status"] == "failed" }
+          errors = tests.count { |t| t["status"] == "error" }
+
+          say "\n" + "=" * 60, :border unless skip_opening_divider
+          say "\n Tests ran: #{total} total, #{passed} passed", :info
+          say "   #{failed} failed, #{errors} error#{"s" if errors != 1}" if failed > 0 || errors > 0
+          say "\n" + "=" * 60, :border
+        end
+
+        def display_failures(test_results)
+          tests = test_results["tests"] || []
+          failed_tests = tests.select { |t| t["status"] == "failed" || t["status"] == "error" }
+
+          return if failed_tests.empty?
+
+          say "\n Failed Tests:\n", :error
+
+          failed_tests.each do |test|
+            display_test_failure(test)
+          end
+        end
+
+        def display_test_failure(test)
+          name = test["name"] || "Unknown test"
+          status = test["status"]
+
+          say "\n ✖ #{name}", :error
+
+          if status == "error"
+            say "   Error: #{test["error"]}", :error
+            return
+          end
+
+          # Display assertion failure details
+          if test["assertion_type"]
+            say "   Assertion failed: #{test["assertion_type"]}", :error
+          end
+
+          if test["message"]
+            say "   #{test["message"]}", :error
+          end
+
+          # Show expected vs generated SQL for debugging
+          if test["expected_sql"]
+            say "   Expected: #{truncate(test["expected_sql"], 100)}", :error
+          end
+
+          if test["pattern"]
+            say "   Pattern: #{test["pattern"]}", :error
+          end
+
+          if test["generated_sql"]
+            say "   Generated: #{truncate(test["generated_sql"], 200)}", :error
+          end
+
+          if test["failing_values"] && test["failing_values"].is_a?(Array) && test["failing_values"].any?
+            sample_values = test["failing_values"].first(5)
+            say "   Sample failing values: #{sample_values.inspect}", :error
+          end
+        end
+
+        def truncate(str, max_length)
+          return str if str.nil? || str.length <= max_length
+          str[0, max_length] + "..."
+        end
+
+        def has_failures?(test_results)
+          tests = test_results["tests"] || []
+          tests.any? { |t| t["status"] == "failed" || t["status"] == "error" }
+        end
+      end
+    end
+  end
+end

data/lib/strata/cli/utils/yaml_import_resolver.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+require_relative "import_manager"
+
+module Strata
+  module CLI
+    module Utils
+      # Resolves YAML imports and merges fields with granular override logic.
+      module YamlImportResolver
+        module_function
+
+        def resolve(file_path, project_path, visited = Set.new)
+          return {} unless File.exist?(file_path)
+
+          absolute_path = File.expand_path(file_path)
+          raise Strata::CircularImportError, "Circular import detected: #{format_cycle(visited, absolute_path)}" if visited.include?(absolute_path)
+
+          visited.add(absolute_path)
+          content = YAML.safe_load_file(file_path, permitted_classes: [Date, Time], aliases: true)
+          return {} unless content.is_a?(Hash)
+
+          resolved_content = content.dup
+          resolved_content.delete("imports")
+
+          if content["imports"]&.is_a?(Array)
+            merged_fields = resolve_imports(content["imports"], file_path, project_path, visited)
+            resolved_content["fields"] = merge_fields(merged_fields, content["fields"] || [])
+          else
+            resolved_content["fields"] = content["fields"] || []
+          end
+
+          resolved_content
+        end
+
+        private_class_method def resolve_imports(imports, base_file_path, project_path, visited)
+          base_dir = File.dirname(base_file_path)
+          all_imported_fields = []
+
+          imports.each do |import_path|
+            ImportManager.validate_import_path(import_path)
+
+            resolved_path = ImportManager.resolve_with_fallback(import_path, base_dir, project_path)
+            imported_content = resolve(resolved_path, project_path, visited.dup)
+            all_imported_fields.concat(imported_content["fields"] || []) if imported_content.is_a?(Hash)
+          end
+
+          all_imported_fields
+        end
+
+        private_class_method def merge_fields(imported_fields, local_fields)
+          field_map = {}
+          imported_fields.each do |field|
+            next unless field.is_a?(Hash) && field["name"]
+
+            field_map[field["name"]] = field.dup
+          end
+
+          local_fields.each do |field|
+            next unless field.is_a?(Hash) && field["name"]
+
+            field_name = field["name"]
+
+            if field_map[field_name]
+              merged_field = field.dup
+              field_map[field_name].each do |key, value|
+                next if key == "name" # name is always from local
+
+                if !merged_field.key?(key) || (merged_field[key].nil? || merged_field[key] == "")
+                  merged_field[key] = value
+                end
+              end
+
+              field_map[field_name] = merged_field
+            else
+              field_map[field_name] = field.dup
+            end
+          end
+
+          field_map.values.sort_by { |f| f["name"] || "" }
+        end
+
+        private_class_method def format_cycle(visited, current)
+          cycle = visited.to_a + [current]
+          cycle.map { |path| File.basename(path) }.join(" -> ")
+        end
+      end
+    end
+  end
+end

data/lib/strata/cli/utils.rb

@@ -0,0 +1,39 @@
+module Strata
+  module CLI
+    module Utils
+      module_function
+
+      # Convert a given string to a Strata compliant
+      # slug or url friendly ID.
+      #
+      # @param str [String]
+      def url_safe_str(str)
+        str.downcase.strip.gsub(/\s+/, "-").gsub(/[^\w-]/, "")
+      end
+
+      def exit_error_if_not_strata!
+        return if CLI.config.strata_project?
+
+        Thor::Shell::Color.new.say_error "ERROR: This is not a valid strata project", :red
+        exit 1
+      end
+
+      # Match a YAML block given a key.
+      # It should match a block like so:
+      #
+      # key:
+      #   attribute: value
+      #   attr_2: val
+      #
+      # another_key: another_val
+      #
+      # This should match just the 'key' block
+      # above.
+      #
+      # @param key [String]
+      def yaml_block_matcher(key)
+        /^#{key}:.*?(?=^\S|\z)/m
+      end
+    end
+  end
+end

data/lib/strata/cli/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Strata
+  module CLI
+    VERSION = "0.1.0.beta"
+  end
+end

data/lib/strata/cli.rb

@@ -0,0 +1,36 @@
+require "thor"
+require "dwh"
+require_relative "cli/version"
+require_relative "cli/configuration"
+require_relative "cli/main"
+require_relative "cli/utils"
+
+module Strata
+  class StrataError < StandardError; end
+
+  class ConfigError < StrataError; end
+
+  class CommandError < StrataError; end
+
+  class ImportError < CommandError; end
+
+  class CircularImportError < ImportError; end
+
+  class MissingImportError < ImportError; end
+
+  class InvalidImportPathError < ImportError; end
+
+  module CLI
+    @configuration = Configuration.new
+    def self.config
+      @configuration
+    end
+
+    def self.start(args)
+      Main.start(args)
+    rescue TTY::Reader::InputInterrupt
+      warn "\nCancelled."
+      exit(1)
+    end
+  end
+end

data/sig/strata/cli.rbs

@@ -0,0 +1,6 @@
+module Strata
+  module Cli
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end