vial 0.0.0 → 0.2026.1.1.0

data/lib/vial/fixture_analyzer.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Vial
+  class FixtureAnalyzer
+    FixtureInfo = Data.define(:file, :fixture_name, :model_class, :model_name, :table_name, :detection_method)
+
+    attr_reader :fixture_paths, :model_mappings, :errors
+
+    def initialize(fixture_paths = nil)
+      @fixture_paths = Array(fixture_paths || default_fixture_paths)
+      @model_mappings = {}
+      @errors = []
+      @fixture_class_names = {}
+    end
+
+    def analyze
+      load_fixture_class_mappings
+      
+      @fixture_paths.each do |path|
+        analyze_path(path)
+      end
+      
+      self
+    end
+
+    def summary
+      {
+        total_fixtures: @model_mappings.size,
+        mapped_fixtures: @model_mappings.count { |_, v| v.model_class.present? },
+        unmapped_fixtures: @model_mappings.count { |_, v| v.model_class.nil? },
+        errors: @errors
+      }
+    end
+
+    def mapped_fixtures
+      @model_mappings.select { |_, v| v.model_class.present? }
+    end
+
+    def unmapped_fixtures
+      @model_mappings.select { |_, v| v.model_class.nil? }
+    end
+
+    def fixture_for_model(model_name)
+      model_class = model_name.is_a?(Class) ? model_name : model_name.to_s.safe_constantize
+      return nil unless model_class
+      
+      @model_mappings.select { |_, v| v.model_class == model_class }
+    end
+
+    private
+
+    def default_fixture_paths
+      fixture_paths = ActiveSupport::TestCase.fixture_paths
+      return fixture_paths if fixture_paths && !fixture_paths.empty?
+
+      [Rails.root.join('test/fixtures')]
+    end
+
+    def load_fixture_class_mappings
+      if ActiveSupport::TestCase.respond_to?(:fixture_class_names)
+        @fixture_class_names = ActiveSupport::TestCase.fixture_class_names || {}
+      end
+    end
+
+    def analyze_path(path)
+      return unless File.directory?(path)
+      
+      Dir[File.join(path, '**/*.yml')].each do |file|
+        analyze_fixture_file(file, path)
+      end
+    end
+
+    def analyze_fixture_file(file, base_path)
+      relative_path = file.sub(/^#{Regexp.escape(base_path.to_s)}\//, '').sub(/\.yml$/, '')
+      fixture_name = relative_path
+      
+      # Skip special fixtures
+      return if fixture_name == 'DEFAULTS' || fixture_name.start_with?('_')
+      
+      model_class = determine_model_class(file, fixture_name)
+      
+      model_name = model_class.is_a?(Class) ? model_class.name : model_class
+      table_name = model_class.is_a?(Class) ? model_class.table_name : nil
+
+      @model_mappings[fixture_name] = FixtureInfo.new(
+        file: file,
+        fixture_name: fixture_name,
+        model_class: model_class,
+        model_name: model_name,
+        table_name: table_name,
+        detection_method: @detection_method
+      )
+    rescue => e
+      @errors << {
+        file: file,
+        error: e.message,
+        backtrace: e.backtrace.first(3)
+      }
+    end
+
+    def determine_model_class(file, fixture_name)
+      # 1. Check for _fixture directive in YAML
+      if model_class = check_fixture_directive(file)
+        @detection_method = :fixture_directive
+        return model_class
+      end
+      
+      # 2. Check set_fixture_class mappings
+      if model_class = check_fixture_class_mapping(fixture_name)
+        @detection_method = :set_fixture_class
+        return model_class
+      end
+      
+      # 3. Infer from fixture path
+      if model_class = infer_from_path(fixture_name)
+        @detection_method = :path_inference
+        return model_class
+      end
+      
+      @detection_method = :none
+      nil
+    end
+
+    def check_fixture_directive(file)
+      yaml = load_fixture_yaml(file)
+      
+      return nil unless yaml.is_a?(Hash)
+      
+      if fixture_config = yaml['_fixture']
+        if model_class_name = fixture_config['model_class']
+          # Try to constantize, but if it fails, still return the string
+          # so we know the fixture has a directive
+          model_class = model_class_name.safe_constantize
+          return model_class || model_class_name
+        end
+      end
+      
+      nil
+    rescue => e
+      @errors << {
+        file: file,
+        error: "Failed to parse fixture YAML: #{e.message}",
+        backtrace: e.backtrace.first(3)
+      }
+      nil
+    end
+
+    def load_fixture_yaml(file)
+      content = File.read(file)
+      content = ERB.new(content).result if content.include?('<%')
+      YAML.safe_load(
+        content,
+        permitted_classes: permitted_yaml_classes,
+        permitted_symbols: [],
+        aliases: true
+      )
+    end
+
+    def permitted_yaml_classes
+      [Time, Date, DateTime, ActiveSupport::TimeWithZone]
+    end
+
+    def check_fixture_class_mapping(fixture_name)
+      # Check exact match
+      if class_name = @fixture_class_names[fixture_name]
+        return class_name.is_a?(Class) ? class_name : class_name.to_s.safe_constantize
+      end
+      
+      # Check with slashes replaced by underscores (Rails convention)
+      underscore_name = fixture_name.tr('/', '_')
+      if class_name = @fixture_class_names[underscore_name]
+        return class_name.is_a?(Class) ? class_name : class_name.to_s.safe_constantize
+      end
+      
+      nil
+    end
+
+    def infer_from_path(fixture_name)
+      # Handle namespaced fixtures (e.g., 'platform/countries')
+      parts = fixture_name.split('/')
+      
+      # Try various naming conventions
+      candidates = [
+        # Exact path as namespace (platform/countries -> Platform::Country)
+        parts.map(&:singularize).map(&:camelize).join('::'),
+        # Last part only (platform/countries -> Country)
+        parts.last.singularize.camelize,
+        # With Model suffix (platform/countries -> Platform::CountryModel)
+        parts.map(&:singularize).map(&:camelize).join('::') + 'Model',
+        # Pluralized namespace (platforms/country -> Platforms::Country)
+        parts[0..-2].map(&:camelize).join('::') + '::' + parts.last.singularize.camelize
+      ]
+      
+      # Add table name prefix handling
+      prefix = ActiveRecord::Base.table_name_prefix
+      if prefix.present? && fixture_name.start_with?(prefix)
+        unprefixed = fixture_name.sub(/^#{Regexp.escape(prefix)}/, '')
+        candidates << unprefixed.singularize.camelize
+      end
+      
+      # Try each candidate
+      candidates.each do |candidate|
+        next if candidate.blank?
+        
+        if model_class = candidate.safe_constantize
+          # Verify it's an ActiveRecord model
+          if model_class < ActiveRecord::Base
+            # Additional verification: check if table name matches
+            expected_table = fixture_name.tr('/', '_')
+            if model_class.table_name == expected_table
+              return model_class
+            end
+          end
+        end
+      end
+      
+      nil
+    end
+  end
+end

data/lib/vial/fixture_id_standardizer.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Vial
+  class FixtureIdStandardizer
+    Update = Data.define(:file, :model_class, :primary_key, :primary_key_type, :changes)
+    Change = Data.define(:label, :primary_key, :current_id, :new_id, :id_type)
+    attr_reader :fixture_paths, :updates_needed, :errors
+
+    def initialize(fixture_paths = nil)
+      @fixture_paths = Array(fixture_paths || default_fixture_paths)
+      @updates_needed = []
+      @errors = []
+      @analyzer = FixtureAnalyzer.new(fixture_paths)
+    end
+
+    def analyze
+      @analyzer.analyze
+      
+      @analyzer.mapped_fixtures.each do |fixture_name, info|
+        analyze_fixture_file(info)
+      end
+      
+      self
+    end
+
+    def standardize!(dry_run: false)
+      analyze if @updates_needed.empty?
+      
+      @updates_needed.each do |update|
+        if dry_run
+          puts "Would update: #{update.file}"
+          update.changes.each do |change|
+            puts "  #{change.label}: #{change.current_id} -> #{change.new_id}"
+          end
+        else
+          apply_updates(update)
+        end
+      end
+    end
+
+    def summary
+      pk_type_stats = @analyzer.mapped_fixtures.values.group_by do |info|
+        next :unmapped unless info.model_class
+        pk = info.model_class.primary_key
+        get_primary_key_type(info.model_class, pk) || :unknown
+      end.transform_values(&:size)
+      
+      {
+        total_fixtures: @analyzer.mapped_fixtures.size,
+        fixtures_needing_updates: @updates_needed.size,
+        records_to_update: @updates_needed.sum { |u| u.changes.size },
+        primary_key_types: pk_type_stats,
+        errors: @errors
+      }
+    end
+
+    private
+
+    def default_fixture_paths
+      fixture_paths = ActiveSupport::TestCase.fixture_paths
+      return fixture_paths if fixture_paths && !fixture_paths.empty?
+
+      [Rails.root.join('test/fixtures')]
+    end
+
+    def analyze_fixture_file(info)
+      return unless info.model_class
+      
+      file = info.file
+      model_class = info.model_class
+      
+      # Get primary key info
+      primary_key = model_class.primary_key
+      primary_key_type = get_primary_key_type(model_class, primary_key)
+      
+      # Skip if no primary key
+      return unless primary_key && primary_key_type
+      
+      # Read and parse fixture file
+      content = File.read(file)
+      if content.include?('<%')
+        @errors << {
+          file: file,
+          error: 'ERB detected in fixture file; skipping standardization to avoid rewriting dynamic content'
+        }
+        return
+      end
+
+      yaml = YAML.load(content)
+      
+      return unless yaml.is_a?(Hash)
+      
+      changes = []
+      
+      yaml.each do |label, attributes|
+        next if label == '_fixture' # Skip meta configuration
+        next unless attributes.is_a?(Hash)
+        
+        # Check if ID needs updating
+        current_id = attributes[primary_key] || attributes[primary_key.to_s]
+        expected_id = generate_fixture_id(label, primary_key_type)
+        
+        if should_update_id?(current_id, expected_id, primary_key_type)
+          changes << Change.new(
+            label: label,
+            primary_key: primary_key,
+            current_id: current_id,
+            new_id: expected_id,
+            id_type: primary_key_type
+          )
+        end
+      end
+      
+      if changes.any?
+        @updates_needed << Update.new(
+          file: file,
+          model_class: model_class,
+          primary_key: primary_key,
+          primary_key_type: primary_key_type,
+          changes: changes
+        )
+      end
+    rescue => e
+      @errors << {
+        file: file,
+        error: e.message,
+        backtrace: e.backtrace.first(3)
+      }
+    end
+
+    def get_primary_key_type(model_class, primary_key)
+      return nil unless model_class.connected?
+      
+      column = model_class.columns_hash[primary_key.to_s]
+      return nil unless column
+      
+      case column.type
+      when :uuid
+        :uuid
+      when :integer, :bigint
+        :integer
+      when :string
+        # String PKs are often manually managed, skip standardization
+        :string
+      else
+        column.type
+      end
+    rescue
+      nil
+    end
+
+    def generate_fixture_id(label, primary_key_type)
+      case primary_key_type
+      when :uuid
+        "<%= ActiveRecord::FixtureSet.identify(:#{label}, :uuid) %>"
+      when :integer
+        "<%= ActiveRecord::FixtureSet.identify(:#{label}) %>"
+      when :string
+        # Skip string primary keys - they're often manually managed (slugs, etc)
+        nil
+      else
+        nil
+      end
+    end
+
+    def should_update_id?(current_id, expected_id, primary_key_type)
+      return false if expected_id.nil?
+      
+      # If no current ID, we need to add one
+      return true if current_id.nil?
+      
+      # If current ID is already an ERB expression with identify, it's good
+      if current_id.is_a?(String) && current_id.include?('ActiveRecord::FixtureSet.identify')
+        # Check if it has the correct format
+        if primary_key_type == :uuid
+          return !current_id.include?(':uuid')
+        else
+          return current_id.include?(':uuid')
+        end
+      end
+      
+      # If it's a hardcoded value, we need to update it
+      true
+    end
+
+    def apply_updates(update)
+      file = update.file
+      content = File.read(file)
+      yaml = YAML.load(content)
+      
+      update.changes.each do |change|
+        label = change.label
+        if yaml[label]
+          # Update or add the primary key
+          yaml[label][change.primary_key.to_s] = change.new_id
+        end
+      end
+      
+      # Write back to file, preserving YAML formatting as much as possible
+      File.write(file, yaml.to_yaml)
+      
+      puts "Updated: #{file} (#{update.changes.size} records)"
+    rescue => e
+      @errors << {
+        file: file,
+        error: "Failed to update: #{e.message}",
+        backtrace: e.backtrace.first(3)
+      }
+    end
+  end
+end

data/lib/vial/loader.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Vial
+  class Loader
+    def initialize(path, box:)
+      @path = path
+      @box = box
+    end
+
+    def load
+      @box.module_eval(File.read(@path), @path, 1)
+    end
+  end
+end

data/lib/vial/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module Vial
+  class Railtie < Rails::Railtie
+    railtie_name :vial
+
+    rake_tasks do
+      load File.expand_path('../tasks/vial.rake', __dir__)
+    end
+  end
+end

data/lib/vial/registry.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Vial
+  class Registry
+    def initialize
+      @definitions = []
+      @by_name = {}
+    end
+
+    def define(name, **options, &block)
+      definition = Definition.new(name, **options)
+      definition.instance_eval(&block) if block
+      @definitions << definition
+      @by_name[definition.name] = definition
+      definition
+    end
+
+    def definitions
+      @definitions.dup
+    end
+
+    def [](name)
+      @by_name[name.to_s]
+    end
+  end
+end

data/lib/vial/sequence.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Vial
+  class Sequence
+    def initialize(start: 1, &block)
+      @value = start
+      @block = block
+    end
+
+    def next_value
+      current = @value
+      @value += 1
+      @block ? @block.call(current) : current
+    end
+  end
+
+  class SequenceRef
+    attr_reader :name
+
+    def initialize(name)
+      @name = name.to_sym
+    end
+  end
+end

data/lib/vial/validator.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Vial
+  class ValidationError < StandardError
+    attr_reader :type, :details
+
+    def initialize(type, details)
+      @type = type
+      @details = details
+      super(build_message)
+    end
+
+    private
+
+    def build_message
+      (["#{type}:"] + details.map { |detail| "  #{detail}" }).join("\n")
+    end
+  end
+
+  class Validator
+    MAX_DERIVED_SALTS = 3
+
+    def initialize(records_by_definition)
+      @records_by_definition = records_by_definition
+    end
+
+    def validate!
+      validate_duplicate_labels!
+      assign_and_validate_ids!
+      true
+    end
+
+    private
+
+    def validate_duplicate_labels!
+      @records_by_definition.each do |entry|
+        definition = entry[:definition]
+        records = entry[:records]
+        label_map = {}
+
+        records.each do |record|
+          label = record.identity_label
+          variant_key = normalize_variant_key(record.variant_stack)
+          existing = label_map[label]
+
+          if existing && existing[:variant_key] != variant_key
+            raise ValidationError.new(
+              'DuplicateLabel',
+              [
+                "vial: #{definition.name}",
+                "record_type: #{definition.record_type}",
+                "label: #{label}",
+                "first: #{format_source(existing[:source_file], existing[:source_line])} (variant: #{existing[:variant_label]})",
+                "second: #{format_source(record.source_file, record.source_line)} (variant: #{format_variant(record.variant_stack)})"
+              ]
+            )
+          end
+
+          label_map[label] ||= {
+            variant_key: variant_key,
+            variant_label: format_variant(record.variant_stack),
+            source_file: record.source_file,
+            source_line: record.source_line
+          }
+        end
+      end
+    end
+
+    def assign_and_validate_ids!
+      used_ids = {}
+      all_records.each do |record|
+        explicit = explicit_id_for(record)
+        next unless explicit
+
+        id_value = explicit[:value]
+        if (existing = used_ids[id_value])
+          raise ValidationError.new(
+            'ExplicitIDCollision',
+            [
+              "ID: #{id_value.inspect}",
+              record_descriptor(existing[:record], existing[:source_file], existing[:source_line]),
+              record_descriptor(record, explicit[:source_file], explicit[:source_line])
+            ]
+          )
+        end
+
+        record.attributes[record.definition.primary_key] = id_value
+        used_ids[id_value] = { explicit: true, record: record, source_file: explicit[:source_file], source_line: explicit[:source_line] }
+      end
+
+      derived_records = all_records.reject { |record| record.attributes.key?(record.definition.primary_key) }
+      derived_records.sort_by { |record| sort_key(record) }.each do |record|
+        assign_derived_id!(record, used_ids)
+      end
+    end
+
+    def assign_derived_id!(record, used_ids)
+      attempts = 0
+      last_collision = nil
+
+      while attempts < MAX_DERIVED_SALTS
+        id_value = record.definition.derive_id(
+          label: record.identity_label,
+          variant_stack: record.variant_stack,
+          index: record.index,
+          salt: attempts
+        )
+
+        existing = used_ids[id_value]
+        if existing.nil?
+          record.attributes[record.definition.primary_key] = id_value
+          used_ids[id_value] = { explicit: false, record: record }
+          return
+        end
+
+        if existing[:explicit]
+          raise ValidationError.new(
+            'DerivedIDCollision',
+            [
+              "ID: #{id_value.inspect}",
+              "derived: #{record_descriptor(record, record.source_file, record.source_line)}",
+              "explicit: #{record_descriptor(existing[:record], existing[:source_file], existing[:source_line])}"
+            ]
+          )
+        end
+
+        last_collision = { id: id_value, existing: existing }
+        attempts += 1
+      end
+
+      raise ValidationError.new(
+        'DerivedIDCollision',
+        [
+          "ID: #{last_collision ? last_collision[:id].inspect : 'unknown'}",
+          "derived: #{record_descriptor(record, record.source_file, record.source_line)}",
+          (last_collision ? "existing: #{record_descriptor(last_collision[:existing][:record], last_collision[:existing][:record].source_file, last_collision[:existing][:record].source_line)}" : nil),
+          "vial: #{record.definition.name}",
+          "record_type: #{record.definition.record_type}",
+          "source: #{format_source(record.source_file, record.source_line)}"
+        ].compact
+      )
+    end
+
+    def explicit_id_for(record)
+      primary_key = record.definition.primary_key
+      return nil unless record.attributes.key?(primary_key)
+
+      value = record.attributes[primary_key]
+      case value
+      in ExplicitId(value:, source_file:, source_line:)
+        { value: value, source_file: source_file, source_line: source_line }
+      else
+        { value: value, source_file: record.source_file, source_line: record.source_line }
+      end
+    end
+
+    def all_records
+      @all_records ||= @records_by_definition.flat_map { |entry| entry[:records] }
+    end
+
+    def sort_key(record)
+      [
+        record.definition.name.to_s.downcase,
+        record.definition.record_type.to_s.downcase,
+        record.identity_label.to_s.downcase,
+        normalize_variant_key(record.variant_stack),
+        record.index
+      ]
+    end
+
+    def normalize_variant_key(variant_stack)
+      Array(variant_stack).map(&:to_s).join('::').downcase
+    end
+
+    def format_variant(variant_stack)
+      stack = Array(variant_stack).map(&:to_s)
+      return 'base' if stack.empty?
+      stack.join('.')
+    end
+
+    def record_descriptor(record, source_file, source_line)
+      variant = format_variant(record.variant_stack)
+      label = record.identity_label
+      "#{format_source(source_file, source_line)} (vial: #{record.definition.name}, record_type: #{record.definition.record_type}, label: #{label}, variant: #{variant}, index: #{record.index})"
+    end
+
+    def format_source(source_file, source_line)
+      return 'unknown' unless source_file
+      source_line ? "#{source_file}:#{source_line}" : source_file
+    end
+  end
+end

data/lib/vial/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Vial
+  VERSION = "0.2026.1.1.0"
+end