synthra 0.1.0

data/lib/synthra/types/core/sequences.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module Core
+      # Sequence type generator (numeric or string sequences)
+      #
+      # Generates sequential values with thread-safe counter management per schema.
+      # Supports both numeric and string sequences with configurable start and step.
+      #
+      # @example Generate numeric sequence
+      #   seq = Sequence.new
+      #   seq.generate_random(rng, context, { start: 1, step: 1 }, :random)
+      #   # => 1, 2, 3, ...
+      #
+      # @example Generate string sequence
+      #   seq.generate_random(rng, context, { start: "A", step: 1 }, :random)
+      #   # => "A", "B", "C", ...
+      #
+      class Sequence < Base
+        # Class-level counters for thread-safe sequence management
+        @counters = {}
+        @mutex = Mutex.new
+
+        class << self
+          attr_reader :counters, :mutex
+        end
+
+        # Get or create a counter for a schema
+        #
+        # @param schema_name [String] schema name
+        # @return [Integer] current counter value (after increment)
+        #
+        def self.counter_for(schema_name)
+          @mutex.synchronize do
+            @counters[schema_name] ||= 0
+            @counters[schema_name] += 1
+            @counters[schema_name]
+          end
+        end
+
+        # Reset counter for a schema
+        #
+        # @param schema_name [String] schema name
+        # @return [void]
+        #
+        def self.reset_counter(schema_name)
+          @mutex.synchronize do
+            @counters[schema_name] = 0
+          end
+        end
+
+        # Generate a sequential value
+        #
+        # @param rng [Generator::RNG] random number generator (not used)
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Integer, String] :start starting value (default: 1)
+        # @option args [Integer] :step step size (default: 1)
+        # @option args [String] :format format string (e.g., "ID-%03d")
+        # @return [Integer, String] next sequential value
+        #
+        def generate_random(rng, context, args)
+          start = args[:start] || 1
+          step = args[:step] || 1
+          format_str = args[:format]
+
+          # Get schema name from context or use default
+          schema_name = context&.schema_name || "default"
+          counter = self.class.counter_for(schema_name)
+
+          # Calculate value
+          if start.is_a?(String)
+            # String sequence: increment character
+            if format_str
+              # Format with counter
+              if format_str.include?("%s")
+                format(format_str, start, counter)
+              else
+                format(format_str, counter)
+              end
+            else
+              # Simple character increment
+              base_char = start[0]
+              new_char = (base_char.ord + (counter - 1) * step).chr
+              new_char
+            end
+          else
+            # Numeric sequence
+            value = start + (counter - 1) * step
+            if format_str
+              format(format_str, value)
+            else
+              value
+            end
+          end
+        end
+
+        # Generate edge case sequence values
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @return [Integer, String] edge case value
+        #
+        def generate_edge(rng, context, args)
+          start = args[:start] || 1
+          if start.is_a?(String)
+            rng.sample(["A", "Z", "0", ""])
+          else
+            rng.sample([0, 1, -1, 2_147_483_647])
+          end
+        end
+
+        # Generate invalid sequence values
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @return [Object] invalid value
+        #
+        def generate_invalid(rng, context, args)
+          rng.sample([
+            nil,
+            "not-a-sequence",
+            [],
+            {}
+          ])
+        end
+      end
+
+      # Sequential ID type generator
+      #
+      # Generates sequential integer IDs with thread-safe counter management.
+      # Each named sequence maintains its own counter.
+      #
+      # @example Generate sequential ID
+      #   id_type = IdSequence.new
+      #   id_type.generate_random(rng, context, { start: 1 })
+      #   # => 1
+      #   id_type.generate_random(rng, context, { start: 1 })
+      #   # => 2
+      #
+      class IdSequence < Base
+        # Create a new IdSequence generator
+        #
+        # Initializes thread-safe counters for managing multiple sequences.
+        #
+        def initialize
+          @counters = Hash.new(0)
+          @mutex = Mutex.new
+        end
+
+        # Generate a sequential ID
+        #
+        # @param rng [Generator::RNG] random number generator (not used for sequence)
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Integer] :start starting value (default: 1)
+        # @option args [String, Symbol] :name sequence name (default: "default")
+        # @return [Integer] next sequential ID
+        #
+        def generate_random(rng, context, args)
+          start = args[:start] || 1
+          sequence_name = args[:name] || "default"
+
+          @mutex.synchronize do
+            @counters[sequence_name] += 1
+            start + @counters[sequence_name] - 1
+          end
+        end
+
+        # Generate edge case ID values
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments (not used)
+        # @return [Integer] edge case ID
+        #
+        def generate_edge(rng, context, args)
+          rng.sample([1, 0, -1, 2_147_483_647])
+        end
+
+        # Generate invalid ID values
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments (not used)
+        # @return [Object] invalid ID value
+        #
+        def generate_invalid(rng, context, args)
+          rng.sample(["not-an-id", nil, "abc", 1.5])
+        end
+
+        # Reset counter for a specific sequence
+        #
+        # @param name [String] sequence name (default: "default")
+        # @return [void]
+        #
+        def reset(name = "default")
+          @mutex.synchronize do
+            @counters[name] = 0
+          end
+        end
+
+        # Reset all sequence counters
+        #
+        # @return [void]
+        #
+        def reset_all
+          @mutex.synchronize do
+            @counters.clear
+          end
+        end
+      end
+
+      # Character sequence type generator
+      class CharacterSequence < Base
+        @counters = {}
+        @mutex = Mutex.new
+
+        class << self
+          attr_reader :counters, :mutex
+
+          def counter_for(schema_name)
+            @mutex.synchronize do
+              @counters[schema_name] ||= 0
+              @counters[schema_name] += 1
+              @counters[schema_name]
+            end
+          end
+
+          def reset_counter(schema_name)
+            @mutex.synchronize do
+              @counters[schema_name] = 0
+            end
+          end
+        end
+
+        def generate_random(rng, context, args)
+          start = args[:start] || "A"
+          step = args[:step] || 1
+          schema_name = context&.schema_name || "default"
+          counter = self.class.counter_for(schema_name)
+          
+          base_char = start[0]
+          new_char = (base_char.ord + (counter - 1) * step).chr
+          new_char
+        end
+
+        def generate_edge(rng, context, args)
+          rng.sample(["A", "Z", "AA", ""])
+        end
+
+        def generate_invalid(rng, context, args)
+          rng.sample([nil, "not-chars", 123, []])
+        end
+      end
+
+      # Digit sequence type generator
+      class DigitSequence < Base
+        @counters = {}
+        @mutex = Mutex.new
+
+        class << self
+          attr_reader :counters, :mutex
+
+          def counter_for(schema_name)
+            @mutex.synchronize do
+              @counters[schema_name] ||= 0
+              @counters[schema_name] += 1
+              @counters[schema_name]
+            end
+          end
+
+          def reset_counter(schema_name)
+            @mutex.synchronize do
+              @counters[schema_name] = 0
+            end
+          end
+        end
+
+        def generate_random(rng, context, args)
+          start = args[:start] || 0
+          step = args[:step] || 1
+          format_str = args[:format] || "%d"
+          schema_name = context&.schema_name || "default"
+          counter = self.class.counter_for(schema_name)
+          value = start + (counter - 1) * step
+          format(format_str, value)
+        end
+
+        def generate_edge(rng, context, args)
+          rng.sample(["0", "9", "00", "999"])
+        end
+
+        def generate_invalid(rng, context, args)
+          rng.sample([nil, "not-digits", [], {}])
+        end
+      end
+    end
+  end
+end
+

data/lib/synthra/types/crypto/crypto.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module Crypto
+      # BitcoinAddress type
+      class BitcoinAddress < Base
+        # Base58 characters (Bitcoin uses Base58)
+        BASE58_CHARS = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".freeze
+
+        # Generate random Bitcoin address
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Symbol] :format address format (:legacy, :bech32)
+        # @return [String] generated Bitcoin address
+        #
+        def generate_random(rng, context, args)
+          format_type = args[:format] || :legacy
+
+          case format_type
+          when :bech32
+            # Bech32 format: bc1 + 42 characters
+            "bc1" + generate_base58_string(rng, 42)
+          else # :legacy
+            # Legacy format: starts with 1 or 3, 26-35 characters
+            prefix = rng.sample(["1", "3"])
+            prefix + generate_base58_string(rng, rng.int(26, 34))
+          end
+        end
+
+        def generate_edge(rng, context, args)
+          ["1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa", "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not an address", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        private
+
+        def generate_base58_string(rng, length)
+          length.times.map { rng.sample(BASE58_CHARS.chars) }.join
+        end
+      end
+
+      # EthereumAddress type
+      class EthereumAddress < Base
+        # Generate random Ethereum address
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments (not used)
+        # @return [String] generated Ethereum address
+        #
+        def generate_random(rng, context, args)
+          # Ethereum addresses are 40 hex characters (20 bytes)
+          hex_chars = ("0".."9").to_a + ("a".."f").to_a + ("A".."F").to_a
+          address = 40.times.map { rng.sample(hex_chars) }.join
+          "0x#{address}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["0x0000000000000000000000000000000000000000", "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not an address", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # PrivateKey type
+      class PrivateKey < Base
+        # Base58 characters for WIF format
+        BASE58_CHARS = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".freeze
+
+        # Generate random private key
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Symbol] :format key format (:hex, :wif, :pem)
+        # @option args [Integer] :length key length in bytes (default: 32)
+        # @return [String] generated private key
+        #
+        def generate_random(rng, context, args)
+          format_type = args[:format] || :hex
+          length = args[:length] || 32
+
+          case format_type
+          when :wif
+            # WIF (Wallet Import Format) for Bitcoin: Base58 encoded
+            "5" + generate_base58_string(rng, 51)
+          when :pem
+            # PEM format (simplified)
+            "-----BEGIN PRIVATE KEY-----\n" + generate_base64_string(rng, length * 2) + "\n-----END PRIVATE KEY-----"
+          else # :hex
+            # Hex format: 64 hex characters (32 bytes)
+            hex_chars = ("0".."9").to_a + ("a".."f").to_a
+            (length * 2).times.map { rng.sample(hex_chars) }.join
+          end
+        end
+
+        def generate_edge(rng, context, args)
+          ["0" * 64, "f" * 64].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a key", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        private
+
+        def generate_base58_string(rng, length)
+          length.times.map { rng.sample(BASE58_CHARS.chars) }.join
+        end
+
+        def generate_base64_string(rng, length)
+          chars = ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a + ['+', '/', '=']
+          length.times.map { rng.sample(chars) }.join
+        end
+      end
+
+      # HashType type
+      class HashType < Base
+        # Hash algorithm lengths (in hex characters)
+        HASH_LENGTHS = {
+          md5: 32,
+          sha1: 40,
+          sha256: 64,
+          sha512: 128
+        }.freeze
+
+        # Generate random hash
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Symbol, String] :algorithm hash algorithm (:md5, :sha1, :sha256, :sha512)
+        # @return [String] generated hash string
+        #
+        def generate_random(rng, context, args)
+          algorithm = (args[:algorithm] || :sha256).to_sym
+          length = HASH_LENGTHS[algorithm] || 64
+
+          # Generate random hex string
+          hex_chars = ("0".."9").to_a + ("a".."f").to_a
+          length.times.map { rng.sample(hex_chars) }.join
+        end
+
+        def generate_edge(rng, context, args)
+          ["0" * 64, "f" * 64].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a hash", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+    end
+  end
+end