synthra 0.1.0

data/lib/synthra/types/personal_names/identifiers.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module PersonalNames
+      # Username type
+      class Username < Base
+        # Generate random username
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [String] :prefix prefix for username
+        # @option args [Integer] :length total length (default: 6..12)
+        # @return [String] generated username
+        #
+        def generate_random(rng, context, args)
+          prefix = args[:prefix] || ""
+          length = args[:length] || rng.int(6, 12)
+
+          # Use first_name/last_name from context if available
+          base = if context && (context["first_name"] || context[:first_name])
+                   first = (context["first_name"] || context[:first_name]).to_s.downcase
+                   last = (context["last_name"] || context[:last_name]).to_s.downcase
+                   "#{first}#{last}".gsub(/[^a-z0-9]/, "")
+                 else
+                   generate_random_base(rng, length - prefix.length)
+                 end
+
+          "#{prefix}#{base}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "a", "user123"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        private
+
+        def generate_random_base(rng, length)
+          chars = ('a'..'z').to_a + ('0'..'9').to_a
+          length.times.map { rng.sample(chars) }.join
+        end
+      end
+
+      # Age type
+      class Age < Base
+        # Generate random age
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Range] :range age range (e.g., 18..65)
+        # @option args [Integer] :min minimum age (default: 0)
+        # @option args [Integer] :max maximum age (default: 120)
+        # @return [Integer] generated age
+        #
+        def generate_random(rng, context, args)
+          if args[:range].is_a?(Range)
+            min = args[:range].min
+            max = args[:range].max
+          else
+            min = args[:min] || 0
+            max = args[:max] || 120
+          end
+          rng.int(min, max)
+        end
+
+        def generate_edge(rng, context, args)
+          [0, 120, 18].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a number", -1, 200, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # Gender type
+      class Gender < Base
+        # Available gender identity values
+        #
+        # @return [Array<String>] list of gender identity strings
+        #
+        GENDERS = ["male", "female", "non-binary", "other", "prefer not to say"].freeze
+
+        # Generate random gender
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Symbol] :format format type (:short, :full, :capitalized)
+        # @return [String] generated gender value
+        #
+        def generate_random(rng, context, args)
+          format_type = args[:format] || :short
+
+          # Try Faker first
+          adapter = faker_adapter(context)
+          if adapter
+            gender = adapter.gender
+
+          else
+            gender = Faker::Gender.type
+          end
+
+
+          case format_type
+          when :capitalized
+            gender.to_s.capitalize
+          when :full
+            gender.to_s
+          else
+            gender.to_s[0..2] # Short format
+          end
+
+        rescue StandardError
+          rng.sample(GENDERS) # fallback
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "male", "female"].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
+
+      # GenderAbbrev type
+      class GenderAbbrev < Base
+        ABBREVS = ["M", "F", "NB", "O"].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(ABBREVS)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "M", "F"].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
+
+      # GenderBinary type
+      class GenderBinary < Base
+        BINARY = ["Male", "Female"].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(BINARY)
+        end
+
+        def generate_edge(rng, context, args)
+          ["Male", "Female"].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
+
+      # GenderFacebook type
+      class GenderFacebook < Base
+        FACEBOOK_GENDERS = [
+          "Male", "Female", "Custom", "Prefer not to say"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(FACEBOOK_GENDERS)
+        end
+
+        def generate_edge(rng, context, args)
+          ["Male", "Female"].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
+    end
+  end
+end

data/lib/synthra/types/personal_names/names.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module PersonalNames
+      # Name type
+      class Name < Base
+        # Generate a random name
+        #
+        # Uses Faker::Name to generate realistic names that may include
+        # titles, first names, middle names, last names, and suffixes.
+        #
+        # @param rng [Generator::RNG] random number generator (not directly used)
+        # @param args [Hash] type arguments (not used for basic name)
+        # @return [String] generated full name
+        #
+        # @example
+        #   generate_random(rng, {})
+        #   # => "Maria Garcia"
+        #
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.name
+
+          else
+            Faker::Name.name
+          end
+
+        rescue StandardError
+          rng.sample(["John Doe", "Jane Smith", "Peter Jones"])
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "A", "Very Long Name That Exceeds Normal Limits"].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
+
+      # FirstName type
+      class FirstName < Base
+        # Generate random first name
+        #
+        # @param rng [Generator::RNG] random number generator (not directly used)
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments (not used)
+        # @return [String] generated first name
+        #
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.first_name
+
+          else
+            Faker::Name.first_name
+          end
+
+        rescue StandardError
+          rng.sample(["John", "Jane", "Peter"])
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "A", "Very Long FirstName That Exceeds Normal Limits"].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
+
+      # LastName type
+      class LastName < Base
+        # Generate random last name
+        #
+        # @param rng [Generator::RNG] random number generator (not directly used)
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments (not used)
+        # @return [String] generated last name
+        #
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.last_name
+
+          else
+            Faker::Name.last_name
+          end
+
+        rescue StandardError
+          rng.sample(["Doe", "Smith", "Jones"])
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "A", "Very Long LastName That Exceeds Normal Limits"].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
+
+      # FullName type
+      class FullName < Base
+        # Generate random full name
+        #
+        # @param rng [Generator::RNG] random number generator (not directly used)
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [String] :format format string (default: "{first} {last}")
+        # @return [String] generated full name
+        #
+        def generate_random(rng, context, args)
+          format_str = args[:format] || "{first} {last}"
+
+          # Try to use context values if available
+          if context && context["first_name"] && context["last_name"]
+            format_str.gsub("{first}", context["first_name"].to_s)
+                      .gsub("{last}", context["last_name"].to_s)
+          elsif context && context[:first_name] && context[:last_name]
+            format_str.gsub("{first}", context[:first_name].to_s)
+                      .gsub("{last}", context[:last_name].to_s)
+          else
+            # Generate from Faker
+            adapter = faker_adapter(context)
+            if adapter
+              name = adapter.name
+
+            else
+              name = Faker::Name.name
+            end
+
+            name
+          end
+
+        rescue StandardError
+          rng.sample(["John Doe", "Jane Smith", "Peter Jones"])
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "A", "Very Long FullName That Exceeds Normal Limits"].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
+
+      # FirstNameFemale type
+      class FirstNameFemale < Base
+        FALLBACK_NAMES = [
+          "Emma", "Olivia", "Sophia", "Isabella", "Charlotte",
+          "Amelia", "Mia", "Harper", "Evelyn", "Abigail"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter && adapter.respond_to?(:female_first_name)
+            adapter.female_first_name
+
+          else
+            Faker::Name.female_first_name
+          end
+
+        rescue StandardError
+          rng.sample(FALLBACK_NAMES)
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "A", "Very Long Female FirstName"].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
+
+      # FirstNameMale type
+      class FirstNameMale < Base
+        FALLBACK_NAMES = [
+          "Liam", "Noah", "Oliver", "Elijah", "James",
+          "William", "Benjamin", "Lucas", "Henry", "Theodore"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter && adapter.respond_to?(:male_first_name)
+            adapter.male_first_name
+
+          else
+            Faker::Name.male_first_name
+          end
+
+        rescue StandardError
+          rng.sample(FALLBACK_NAMES)
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "A", "Very Long Male FirstName"].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
+
+      # FirstNameEuropean type
+      class FirstNameEuropean < Base
+        EUROPEAN_FIRST_NAMES = [
+          "Maria", "Sophie", "Anna", "Elena", "Laura",
+          "Luca", "Marco", "David", "Thomas", "Paul"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter && adapter.respond_to?(:european_first_name)
+            adapter.european_first_name
+
+          else
+            rng.sample(EUROPEAN_FIRST_NAMES)
+          end
+
+        rescue StandardError
+          rng.sample(EUROPEAN_FIRST_NAMES)
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "A", "Very Long European FirstName"].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
+    end
+  end
+end

data/lib/synthra/types/personal_names/national_id.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# =============================================================================
+# Synthra National ID Type Generator
+# =============================================================================
+#
+# Generates government-issued identifier numbers (SSN, etc.).
+# Format varies by country.
+#
+# @example DSL usage
+#   Person:
+#     ssn: national_id(country: :us)
+#     nino: national_id(country: :uk)
+#
+# @example Generated values
+#   "123-45-6789" (US SSN)
+#   "AB123456C" (UK NINO)
+#
+# =============================================================================
+
+module Synthra
+  module Types
+    module PersonalNames
+      # National ID type generator
+      #
+      # Generates government-issued identifier numbers.
+      # Supports multiple country formats.
+      #
+      # @example Generate SSN
+      #   national_id = NationalId.new
+      #   national_id.generate(rng, context, { country: :us }, :random)
+      #   # => "123-45-6789"
+      #
+      class NationalId < Base
+        # Generate national ID based on country
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Symbol, String] :country country code (:us, :uk, :ca, etc.)
+        # @return [String] generated national ID
+        #
+        def generate_random(rng, context, args)
+          country = (args[:country] || :us).to_sym
+
+          case country
+          when :us
+            # US SSN format: XXX-XX-XXXX
+            format("%03d-%02d-%04d", rng.int(100, 999), rng.int(10, 99), rng.int(1000, 9999))
+          when :uk
+            # UK NINO format: AB123456C
+            prefix = rng.sample(("AA".."ZZ").to_a.reject { |x| x.match?(/[IOQZ]/) })
+            numbers = format("%06d", rng.int(0, 999_999))
+            suffix = rng.sample(("A".."Z").to_a.reject { |x| ["I", "O", "Q", "Z"].include?(x) })
+            "#{prefix}#{numbers}#{suffix}"
+          when :ca
+            # Canadian SIN format: XXX XXX XXX
+            format("%03d %03d %03d", rng.int(100, 999), rng.int(100, 999), rng.int(100, 999))
+          else
+            # Default: simple numeric format
+            format("%09d", rng.int(100_000_000, 999_999_999)) # fallback
+          end
+        end
+
+        # Generate edge case values
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @return [String] edge case value
+        #
+        def generate_edge(rng, context, args)
+          ["", "000-00-0000", "999-99-9999", "123"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        # Generate invalid 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)
+          [nil, 123, [], {}, true, "invalid-ssn", "ABC-DEF-GHIJ"].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+    end
+  end
+end

data/lib/synthra/types/personal_names/titles_suffixes.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module PersonalNames
+      # Title type
+      class Title < Base
+        TITLES = ["Mr.", "Mrs.", "Ms.", "Miss", "Dr.", "Prof.", "Rev.", "Hon."].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(TITLES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "Mr.", "Dr."].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
+
+      # Suffix type
+      class Suffix < Base
+        SUFFIXES = ["Jr.", "Sr.", "II", "III", "IV", "V", "PhD", "MD", "Esq."].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(SUFFIXES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "Jr.", "PhD"].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
+    end
+  end
+end