Class: Synthra::Types::Registry

Inherits:
Object
  • Object
show all
Defined in:
lib/synthra/types/registry.rb

Overview

Registry for type generator classes

Thread-safe registry for storing and retrieving type implementations. Supports both class-based and block-based type registration.

Examples:

Look up a type

type = Registry.lookup("uuid")
value = type.generate(rng, context, {}, :random)

Class Method Summary collapse

Class Method Details

.clear ⇒ void

This method returns an undefined value.

Clear all registered types



163
164
165
166
167
 
# File 'lib/synthra/types/registry.rb', line 163

def clear
  @mutex.synchronize do
    @types.clear
  end
end

.find_similar_types(name) ⇒ Array<String> (private)

Find type names similar to the given name

Parameters:

  • name (String) —

    the type name to match

Returns:

  • (Array<String>) —

    similar type names



131
132
133
 
# File 'lib/synthra/types/registry.rb', line 131

def find_similar_types(name)
  Utils::StringDistance.similar_strings(name, @types.keys, max_distance: 3, limit: 3)
end

.lookup(name) ⇒ Base

Look up a registered type

Examples:

type = Registry.lookup("uuid")
value = type.generate(rng, context, {}, :random)

Parameters:

  • name (String) —

    type name (may include ? for nullable)

Returns:

  • (Base) —

    type generator instance

Raises:

  • (UnknownTypeError) —

    if type not found (includes "did you mean" suggestions)



112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/synthra/types/registry.rb', line 112

def lookup(name)
  @mutex.synchronize do
    # Strip nullable suffix if present
    key = name.to_s.sub(/\?$/, "")
    @types.fetch(key) do
      # Find similar type names for "did you mean" suggestions
      suggestions = find_similar_types(key)
      raise Errors::UnknownTypeError.new(name, suggestions: suggestions)
    end
  end
end

.names ⇒ Array<String>

Get all registered type names

Returns:

  • (Array<String>) —

    list of type names



153
154
155
156
157
 
# File 'lib/synthra/types/registry.rb', line 153

def names
  @mutex.synchronize do
    @types.keys.sort
  end
end

.register(name, klass = nil, force: false) {|rng, context, args, mode| ... } ⇒ void

This method returns an undefined value.

Register a type generator

Examples:

Register with a class

Registry.register("uuid", Types::Uuid)

Register with a block

Registry.register("ssn") do |rng, context, args, mode|
  "#{rng.int(100, 999)}-#{rng.int(10, 99)}-#{rng.int(1000, 9999)}"
end

Parameters:

  • name (String) —

    type name (used in DSL)

  • klass (Class, nil) (defaults to: nil) —

    type class (must inherit from Base)

  • force (Boolean) (defaults to: false) —

    if true, overwrites existing type

Yields:

  • (rng, context, args, mode) —

    block for generating values

Yield Parameters:

  • rng (Generator::RNG) —

    random number generator

  • context (Generator::Context) —

    generation context

  • args (Hash) —

    type arguments

  • mode (Symbol) —

    generation mode (:random, :edge, :invalid)

Yield Returns:

  • (Object) —

    generated value

Raises:

  • (ArgumentError) —

    if type exists and force is false



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/synthra/types/registry.rb', line 63

def register(name, klass = nil, force: false, &block)
  @mutex.synchronize do
    key = name.to_s
    if @types.key?(key) && !force
      raise ArgumentError, "Type '#{name}' already registered. Use force: true to override."
    end

    if block
      # Create a wrapper class for block-based types
      wrapper = Class.new(Base) do
        define_method(:generate_random) do |rng, context, args|
          block.call(rng, context, args, :random)
        end

        define_method(:generate_edge) do |rng, context, args|
          block.call(rng, context, args, :edge)

        rescue StandardError
          block.call(rng, context, args, :random)
        end


        define_method(:generate_invalid) do |rng, context, args|
          block.call(rng, context, args, :invalid)

        rescue StandardError
          nil
        end

      end
      @types[key] = wrapper.new
    elsif klass
      @types[key] = klass.new
    else
      raise ArgumentError, "Must provide either a class or a block"
    end
  end
end

.registered?(name) ⇒ Boolean

Check if a type is registered

Parameters:

  • name (String) —

    type name

Returns:

  • (Boolean) —

    true if registered



142
143
144
145
146
147
 
# File 'lib/synthra/types/registry.rb', line 142

def registered?(name)
  @mutex.synchronize do
    key = name.to_s.sub(/\?$/, "")
    @types.key?(key)
  end
end

.size ⇒ Integer

Get the number of registered types

Returns:

  • (Integer) —

    number of types



173
174
175
176
177
 
# File 'lib/synthra/types/registry.rb', line 173

def size
  @mutex.synchronize do
    @types.size
  end
end