bulkrax 9.3.5 → 9.4.0

data/app/services/bulkrax/sample_csv_service/schema_analyzer.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Bulkrax
-  # Analyzes model schemas for required and controlled vocabulary fields
-  class SampleCsvService::SchemaAnalyzer
-    def initialize(klass)
-      @klass = klass
-      @schema = load_schema
-    end
-
-    def required_terms
-      return [] if @schema.blank?
-
-      @schema.select do |field|
-        field.respond_to?(:meta) &&
-          field.meta["form"].is_a?(Hash) &&
-          field.meta["form"]["required"] == true
-      end.map(&:name).map(&:to_s)
-    rescue StandardError
-      []
-    end
-
-    def controlled_vocab_terms
-      return [] unless @schema
-
-      controlled_properties = extract_controlled_properties
-      controlled_properties.empty? ? registered_controlled_vocab_fields : controlled_properties
-    rescue StandardError
-      []
-    end
-
-    private
-
-    def load_schema
-      return nil unless @klass.respond_to?(:schema)
-      # Yes, this looks strange. The fallback is intentional.
-      # At the point in time when this service is being created, Hyrax behaves
-      # differently between flexible metadata setting on & off. This may be modified
-      # in the future, and this code can be revisited then.
-      # flexible=true: @klass.new.singleton_class.schema would return the full schema,
-      #                but @klass.schema doesn't get the flexible metadata terms
-      # flexible=false: @klass.new.singleton_class.schema returns nil so it will fallback
-      @klass.new.singleton_class.schema || @klass.schema
-    rescue StandardError
-      nil
-    end
-
-    def extract_controlled_properties
-      return [] unless @schema
-
-      @schema.filter_map do |property|
-        next unless property.respond_to?(:meta)
-        sources = property.meta&.dig('controlled_values', 'sources')
-        next if sources.nil? || sources == ['null'] || sources == 'null'
-        property.name.to_s
-      end
-    end
-
-    def registered_controlled_vocab_fields
-      qa_registry.filter_map do |k, v|
-        k.singularize if v.klass == Qa::Authorities::Local::FileBasedAuthority
-      end
-    end
-
-    def qa_registry
-      @qa_registry ||= Qa::Authorities::Local.registry.instance_variable_get('@hash')
-    end
-  end
-end

data/app/services/bulkrax/sample_csv_service/split_formatter.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Bulkrax
-  # Formats split pattern descriptions
-  class SampleCsvService::SplitFormatter
-    def format(split_value)
-      return "Property does not split." if split_value.nil?
-
-      if split_value == true
-        parse_pattern(Bulkrax.multi_value_element_split_on.source)
-      elsif split_value.is_a?(String)
-        parse_pattern(split_value)
-      else
-        split_value
-      end
-    end
-
-    private
-
-    def parse_pattern(pattern)
-      chars = extract_characters(pattern)
-      format_message(chars)
-    end
-
-    def extract_characters(pattern)
-      if (match = pattern.match(/\[([^\]]+)\]/))
-        match[1]
-      elsif (single = pattern.match(/\\(.)/))
-        single[1]
-      else
-        pattern
-      end
-    end
-
-    def format_message(chars)
-      formatted = chars.chars.then do |c|
-        c.length > 1 ? "#{c[0..-2].join(' ')}, or #{c.last}" : c.first
-      end
-      "Split multiple values with #{formatted}"
-    end
-  end
-end

data/app/services/bulkrax/sample_csv_service/value_determiner.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module Bulkrax
-  # Determines values for CSV cells
-  class SampleCsvService::ValueDeterminer
-    def initialize(service)
-      @service = service
-      @column_builder = SampleCsvService::ColumnBuilder.new(service)
-    end
-
-    def determine_value(column, model_name, field_list)
-      key = @service.mapping_manager.mapped_to_key(column)
-      required_terms = field_list.dig(model_name, 'required_terms')
-
-      if field_list.dig(model_name, "properties")&.include?(key)
-        mark_required_or_optional(key, required_terms)
-      elsif special_column?(column, key)
-        special_value(column, key, model_name, required_terms)
-      end
-    end
-
-    private
-
-    def special_column?(column, key)
-      descriptor = SampleCsvService::ColumnDescriptor.new
-      visibility_cols = descriptor.send(:extract_column_names, :visibility)
-
-      key.in?(['model', 'work_type']) ||
-        column.in?(visibility_cols) ||
-        column == 'source_identifier' ||
-        column == 'rights_statement' ||
-        relationship_column?(column) ||
-        file_column?(column)
-    end
-
-    def special_value(column, key, model_name, required_terms)
-      return SampleCsvService::ModelLoader.determine_klass_for(model_name).to_s if key.in?(['model', 'work_type'])
-      return 'Required' if column == 'source_identifier'
-      return mark_required_or_optional(key, required_terms) if column == 'rights_statement'
-      # collections do not have files
-      return nil if file_column?(column) && model_name.in?([Bulkrax.collection_model_class].compact.map(&:to_s))
-      'Optional'
-    end
-
-    def mark_required_or_optional(field, required_terms)
-      return 'Unknown' unless required_terms
-      required_terms.include?(field) ? 'Required' : 'Optional'
-    end
-
-    def relationship_column?(column)
-      relationships = [
-        @service.mapping_manager.find_by_flag("related_children_field_mapping", 'children'),
-        @service.mapping_manager.find_by_flag("related_parents_field_mapping", 'parents')
-      ]
-      column.in?(relationships)
-    end
-
-    def file_column?(column)
-      file_cols = SampleCsvService::ColumnDescriptor::COLUMN_DESCRIPTIONS[:files].flat_map do |property_hash|
-        property_hash.keys.filter_map do |key|
-          @service.mappings.dig(key, "from")&.first
-        end
-      end
-      column.in?(file_cols)
-    end
-  end
-end

data/app/services/bulkrax/sample_csv_service.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Bulkrax
-  ## Main service class that orchestrates CSV generation
-  #
-  ## Purpose:
-  # Generates CSV import templates that help users understand what fields are available for bulk importing content into a Hyrax repository.
-  # The service uses a modular architecture with specialized components that work together to create intelligent, model-specific CSV templates:
-
-  ## 1. Initialization & Setup
-  # Loads Bulkrax field mappings (excluding auto-generated fields) via MappingManager
-  # Determines which models to include via ModelLoader (can target a specific model, all models, or none)
-  # Supports both ActiveFedora and Valkyrie object factories
-
-  ## 2. Field Analysis
-  # FieldAnalyzer examines each model's schema to extract all available properties, and identifies:
-  # Required fields
-  # Controlled vocabulary terms
-  # If a term column can be split into multiple values during import
-  # SchemaAnalyzer introspects model schemas differently based on whether they're Valkyrie or ActiveFedora models
-
-  ## 3. Column Building
-  # ColumnBuilder assembles the complete list of valid CSV columns by combining:
-  # Bulkrax-specific fields (model, source_identifier, parent, etc.)
-  # Model properties mapped through the field mapping system
-  # Controlled vocabulary information
-  # Filters out internal/system properties (created_at, updated_at, file_ids, embargo_id, etc.)
-
-  ## 4. Row Generation
-  # The service creates three types of rows:
-  # Header Row: Column names mapped through Bulkrax's field mappings
-  # Explanation Row: Descriptions of what each column expects (via ExplanationBuilder and ColumnDescriptor)
-  # Data Rows: One row per model showing appropriate sample values (via RowBuilder and ValueDeterminer)
-
-  ## 5. Intelligent Filtering
-  # Removes completely empty columns to keep the template clean and focused
-  # Preserves columns that contain any data across any model row
-
-  # 6. Output
-  # Can generate either a CSV file (default location: tmp/sample_csv_import_template.csv) or a CSV string
-  # Uses Ruby's CSV library for proper formatting and escaping
-
-  ## Sample Usage:
-  #   Bulkrax::SampleCsvService.call(model_name: 'GenericWork', output: 'file', file_path: 'path/to/output.csv')
-  #   Bulkrax::SampleCsvService.call(model_name: nil, output: 'csv_string')
-  class SampleCsvService
-    attr_reader :model_name, :mappings, :all_models
-
-    def initialize(model_name: nil)
-      @model_name = model_name
-      @mapping_manager = MappingManager.new
-      @mappings = @mapping_manager.mappings
-      @all_models = ModelLoader.new(model_name).models
-      @field_analyzer = FieldAnalyzer.new(@mappings)
-      @csv_builder = CsvBuilder.new(self)
-    end
-
-    def self.call(model_name: nil, output: 'file', **args)
-      raise NameError, "Hyrax is not defined" unless defined?(::Hyrax)
-      new(model_name: model_name).send("to_#{output}", **args)
-    end
-
-    def to_file(file_path: nil)
-      file_path ||= FilePathGenerator.default_path
-      @csv_builder.write_to_file(file_path)
-      file_path
-    end
-
-    def to_csv_string
-      @csv_builder.generate_string
-    end
-
-    # Delegate methods to appropriate components
-    attr_reader :field_analyzer
-
-    attr_reader :mapping_manager
-  end
-end