synthra 0.1.0

data/lib/synthra/types/regex.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    # Regex type generator.
+    #
+    # Generates a string that MATCHES a supplied regular-expression pattern.
+    # The generator is small and dependency-free; it understands the common
+    # subset of regex syntax used in fake-data schemas:
+    #
+    #   - character classes:  \d \w \s \D \W \S  and  [a-z] [A-Z0-9] [^abc]
+    #   - quantifiers:        {n}  {n,m}  {n,}  +  *  ?
+    #   - literals:           any other character is emitted verbatim
+    #   - anchors:            ^ and $ are stripped (treated as match boundaries)
+    #   - groups:             (...) are flattened (their contents are generated)
+    #   - alternation:        a|b  picks one branch at random (seeded)
+    #
+    # Anything it cannot understand degrades gracefully to a reasonable string
+    # rather than crashing or returning "".
+    class Regex < Base
+      DEFAULT_REPEAT_MAX = 8 # cap for unbounded quantifiers (+ and *)
+
+      def generate_random(rng, context, args)
+        pattern = args[:pattern]
+        return "" unless pattern
+
+        source = pattern.is_a?(Regexp) ? pattern.source : pattern.to_s
+        return "" if source.empty?
+
+        build_from_pattern(source, rng)
+      rescue StandardError
+        # Pattern too complex / malformed — never crash, never return "".
+        "generated_string"
+      end
+
+      def generate_edge(rng, context, args)
+        rng.sample(["", "0", "a"])
+      end
+
+      def generate_invalid(rng, context, args)
+        rng.sample([nil, 123, [], {}])
+      end
+
+      private
+
+      # Generate a string matching +source+.
+      #
+      # @param source [String] regex source (no surrounding slashes)
+      # @param rng [Generator::RNG] seeded RNG
+      # @return [String]
+      def build_from_pattern(source, rng)
+        source = strip_anchors(source)
+        source = pick_alternation(source, rng)
+        tokens = tokenize(source)
+        tokens.map { |tok| render_token(tok, rng) }.join
+      end
+
+      # Strip leading ^ and trailing $ anchors (they constrain position, not content).
+      def strip_anchors(source)
+        source.sub(/\A\^/, "").sub(/\$\z/, "")
+      end
+
+      # If the (top-level) pattern uses alternation, pick one branch deterministically.
+      # Only splits on bars that are not inside a group or char class.
+      def pick_alternation(source, rng)
+        branches = split_top_level_alternation(source)
+        return source if branches.length <= 1
+
+        rng.sample(branches)
+      end
+
+      def split_top_level_alternation(source)
+        branches = []
+        current = +""
+        depth = 0
+        in_class = false
+        i = 0
+        while i < source.length
+          ch = source[i]
+          case ch
+          when "\\"
+            current << ch << (source[i + 1] || "")
+            i += 2
+            next
+          when "["
+            in_class = true
+            current << ch
+          when "]"
+            in_class = false
+            current << ch
+          when "("
+            depth += 1 unless in_class
+            current << ch
+          when ")"
+            depth -= 1 unless in_class
+            current << ch
+          when "|"
+            if depth.zero? && !in_class
+              branches << current
+              current = +""
+            else
+              current << ch
+            end
+          else
+            current << ch
+          end
+          i += 1
+        end
+        branches << current
+        branches
+      end
+
+      # Break the pattern into (atom, quantifier) tokens.
+      #
+      # @return [Array<Hash>] each token: { atom:, min:, max: }
+      def tokenize(source)
+        tokens = []
+        i = 0
+        while i < source.length
+          atom, i = read_atom(source, i)
+          min, max, i = read_quantifier(source, i)
+          tokens << { atom: atom, min: min, max: max }
+        end
+        tokens
+      end
+
+      # Read a single atom starting at +i+. Returns [atom_descriptor, next_index].
+      # atom_descriptor is one of:
+      #   { kind: :class, chars: [...] }  - a character set to pick from
+      #   { kind: :literal, char: "x" }   - a literal character
+      def read_atom(source, i)
+        ch = source[i]
+        case ch
+        when "\\"
+          esc = source[i + 1]
+          [{ kind: :class, chars: escape_class(esc) }, i + 2]
+        when "["
+          chars, next_i = read_char_class(source, i + 1)
+          [{ kind: :class, chars: chars }, next_i]
+        when "."
+          [{ kind: :class, chars: printable_chars }, i + 1]
+        when "(", ")"
+          # Flatten groups: skip the paren, the contents are read as normal atoms.
+          [{ kind: :empty }, i + 1]
+        else
+          [{ kind: :literal, char: ch }, i + 1]
+        end
+      end
+
+      # Expand an escaped class character (\d \w \s and negations) to a char list.
+      def escape_class(esc)
+        case esc
+        when "d" then ("0".."9").to_a
+        when "w" then ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["_"]
+        when "s" then [" ", "\t"]
+        when "D" then ("a".."z").to_a + ("A".."Z").to_a
+        when "W" then [" ", "-", ".", "!"]
+        when "S" then ("a".."z").to_a + ("0".."9").to_a
+        else [esc] # escaped literal, e.g. \. \- \/
+        end
+      end
+
+      # Read a [...] character class starting after the opening bracket.
+      # Returns [chars, next_index].
+      def read_char_class(source, i)
+        negate = false
+        if source[i] == "^"
+          negate = true
+          i += 1
+        end
+
+        chars = []
+        while i < source.length && source[i] != "]"
+          if source[i] == "\\"
+            chars.concat(escape_class(source[i + 1]))
+            i += 2
+            next
+          end
+
+          if source[i + 1] == "-" && source[i + 2] && source[i + 2] != "]"
+            chars.concat((source[i]..source[i + 2]).to_a)
+            i += 3
+          else
+            chars << source[i]
+            i += 1
+          end
+        end
+        i += 1 # consume closing ]
+
+        chars = printable_chars - chars if negate
+        [chars, i]
+      end
+
+      # Read a quantifier at +i+. Returns [min, max, next_index].
+      # No quantifier => [1, 1, i].
+      def read_quantifier(source, i)
+        case source[i]
+        when "+" then [1, DEFAULT_REPEAT_MAX, i + 1]
+        when "*" then [0, DEFAULT_REPEAT_MAX, i + 1]
+        when "?" then [0, 1, i + 1]
+        when "{" then read_brace_quantifier(source, i)
+        else [1, 1, i]
+        end
+      end
+
+      def read_brace_quantifier(source, i)
+        close = source.index("}", i)
+        return [1, 1, i] unless close
+
+        body = source[(i + 1)...close]
+        if body.include?(",")
+          lo, hi = body.split(",", 2)
+          min = lo.to_i
+          max = hi.empty? ? min + DEFAULT_REPEAT_MAX : hi.to_i
+        else
+          min = max = body.to_i
+        end
+        [min, max, close + 1]
+      end
+
+      def render_token(token, rng)
+        atom = token[:atom]
+        return "" if atom[:kind] == :empty
+
+        count = token[:min] == token[:max] ? token[:min] : rng.int(token[:min], token[:max])
+        Array.new(count) { render_atom(atom, rng) }.join
+      end
+
+      def render_atom(atom, rng)
+        case atom[:kind]
+        when :class
+          chars = atom[:chars]
+          chars.empty? ? "" : rng.sample(chars)
+        when :literal
+          atom[:char]
+        else
+          # :nocov: render_token short-circuits :empty atoms, so this arm is a defensive fallback only
+          ""
+          # :nocov:
+        end
+      end
+
+      def printable_chars
+        @printable_chars ||= ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+      end
+    end
+  end
+end

data/lib/synthra/types/registry.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+# =============================================================================
+# Synthra Types Registry
+# =============================================================================
+#
+# The Types::Registry manages registration and lookup of type generator classes.
+# Built-in types are registered automatically at gem load time.
+#
+# @example Register a custom type
+#   Synthra::Types::Registry.register("my_type", MyTypeClass)
+#
+# @example Register with a block
+#   Synthra::Types::Registry.register("my_type") do |rng, context, args, mode|
+#     "custom_value"
+#   end
+#
+# =============================================================================
+
+module Synthra
+  module Types
+    # Registry for type generator classes
+    #
+    # Thread-safe registry for storing and retrieving type implementations.
+    # Supports both class-based and block-based type registration.
+    #
+    # @example Look up a type
+    #   type = Registry.lookup("uuid")
+    #   value = type.generate(rng, context, {}, :random)
+    #
+    class Registry
+      # Internal storage for registered types
+      # @api private
+      @types = {}
+
+      # Mutex for thread-safe access
+      # @api private
+      @mutex = Mutex.new
+
+      class << self
+        # Register a type generator
+        #
+        # @param name [String] type name (used in DSL)
+        # @param klass [Class, nil] type class (must inherit from Base)
+        # @param force [Boolean] if true, overwrites existing type
+        # @yield [rng, context, args, mode] block for generating values
+        # @yieldparam rng [Generator::RNG] random number generator
+        # @yieldparam context [Generator::Context] generation context
+        # @yieldparam args [Hash] type arguments
+        # @yieldparam mode [Symbol] generation mode (:random, :edge, :invalid)
+        # @yieldreturn [Object] generated value
+        # @return [void]
+        # @raise [ArgumentError] if type exists and force is false
+        #
+        # @example Register with a class
+        #   Registry.register("uuid", Types::Uuid)
+        #
+        # @example 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
+        #
+        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
+
+        # Look up a registered type
+        #
+        # @param name [String] type name (may include ? for nullable)
+        # @return [Base] type generator instance
+        # @raise [UnknownTypeError] if type not found (includes "did you mean" suggestions)
+        #
+        # @example
+        #   type = Registry.lookup("uuid")
+        #   value = type.generate(rng, context, {}, :random)
+        #
+        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
+
+        private
+
+        # Find type names similar to the given name
+        #
+        # @param name [String] the type name to match
+        # @return [Array<String>] similar type names
+        #
+        def find_similar_types(name)
+          Utils::StringDistance.similar_strings(name, @types.keys, max_distance: 3, limit: 3)
+        end
+
+        public
+
+        # Check if a type is registered
+        #
+        # @param name [String] type name
+        # @return [Boolean] true if registered
+        #
+        def registered?(name)
+          @mutex.synchronize do
+            key = name.to_s.sub(/\?$/, "")
+            @types.key?(key)
+          end
+        end
+
+        # Get all registered type names
+        #
+        # @return [Array<String>] list of type names
+        #
+        def names
+          @mutex.synchronize do
+            @types.keys.sort
+          end
+        end
+
+        # Clear all registered types
+        #
+        # @return [void]
+        #
+        def clear
+          @mutex.synchronize do
+            @types.clear
+          end
+        end
+
+        # Get the number of registered types
+        #
+        # @return [Integer] number of types
+        #
+        def size
+          @mutex.synchronize do
+            @types.size
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/synthra/types/repeating_element.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    # Repeating element type generator (stub implementation)
+    class RepeatingElement < Base
+      def generate_random(rng, context, args)
+        value = args[:value]
+        count = clamp_count(args[:count] || 1)
+        type_name = args[:type]
+
+        if type_name
+          generate_from_type(rng, context, type_name, count)
+        elsif value
+          value.to_s * count
+        else
+          ""
+        end
+      end
+
+      def generate_edge(rng, context, args)
+        rng.sample(["", "-", "---"])
+      end
+
+      def generate_invalid(rng, context, args)
+        rng.sample([nil, 123, [], {}])
+      end
+
+      private
+
+      # Bound the repeat count to the same ceiling as the other array-producing
+      # types (schema_ref, array). Without this, a tenant-supplied `count:` allocates
+      # an unbounded Array/String — a denial-of-service vector. Floors at 0.
+      def clamp_count(count)
+        max = Synthra.configuration&.limits&.max_array_size || 1000
+        [[count.to_i, 0].max, max].min
+      end
+
+      def generate_from_type(rng, context, type_name, count)
+        type = Types::Registry.lookup(type_name)
+        Array.new(count) { type.generate_random(rng, context, {}) }
+
+      rescue StandardError
+        []
+      end
+
+    end
+  end
+end
+

data/lib/synthra/types/scenario.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    # Scenario type generator (stub implementation)
+    class Scenario < Base
+      SCENARIOS = {
+        user_roles: ["admin", "user", "guest"],
+        status: ["active", "inactive", "pending"],
+        default: ["scenario1", "scenario2", "scenario3"]
+      }.freeze
+
+      def generate_random(rng, context, args)
+        name = (args[:name] || :default).to_sym
+        scenarios = SCENARIOS[name] || SCENARIOS[:default]
+        rng.sample(scenarios)
+      end
+
+      def generate_edge(rng, context, args)
+        rng.sample(["", "edge", "scenario"])
+      end
+
+      def generate_invalid(rng, context, args)
+        rng.sample([nil, 123, [], {}])
+      end
+    end
+  end
+end
+

data/lib/synthra/types/technology_internet/apps.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module TechnologyInternet
+      # AppBundleId type
+      class AppBundleId < Base
+        def generate_random(rng, context, args)
+          # Format: com.company.appname
+          companies = ["company", "corp", "inc", "llc", "tech", "app", "mobile", "digital"]
+          apps = ["app", "application", "mobile", "ios", "android", "game", "tool", "utility"]
+          company = rng.sample(companies)
+          app = rng.sample(apps)
+          number = rng.int(1, 999)
+          "com.#{company}.#{app}#{number}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "com.a.b", "com.verylongcompanyname.verylongappname"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # AppName type
+      class AppName < Base
+        APP_NAMES = [
+          "MyApp", "SuperApp", "AwesomeApp", "BestApp", "CoolApp",
+          "QuickApp", "SmartApp", "FastApp", "EasyApp", "ProApp"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(APP_NAMES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "MyApp", "A"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # AppVersion type
+      class AppVersion < Base
+        def generate_random(rng, context, args)
+          # Semantic versioning: major.minor.patch
+          major = rng.int(0, 10)
+          minor = rng.int(0, 99)
+          patch = rng.int(0, 999)
+          "#{major}.#{minor}.#{patch}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["0.0.0", "10.99.999", "1.0.0"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a version", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+    end
+  end
+end