synthra 0.1.0

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module TechnologyInternet
+      # Email type
+      class Email < Base
+        # Generate a random email address
+        #
+        # Uses Faker::Internet to generate realistic email addresses.
+        #
+        # @param rng [Generator::RNG] random number generator (not directly used)
+        # @param args [Hash] type arguments (not used for basic email)
+        # @return [String] generated email address
+        #
+        # @example
+        #   generate_random(rng, {})
+        #   # => "maria.garcia@example.com"
+        #
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.email
+
+          else
+            Faker::Internet.email
+          end
+
+        rescue StandardError
+          "#{rng.sample(['user', 'test', 'admin'])}@#{rng.sample(['example.com', 'test.com', 'demo.com'])}"
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "a@b", "user@", "@domain", "user@domain"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          ["notanemail", "@missing.local", "missing@", "double@@at.com", "spaces in@email.com", nil, 123].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # Phone type
+      class Phone < Base
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.phone_number
+
+          else
+            Faker::PhoneNumber.phone_number
+          end
+
+        rescue StandardError
+          rng.sample(["+1-555-123-4567", "+44-20-1234-5678", "+33-1-23-45-67-89"])
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "+1-555-000-0000", "000-000-0000"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, 123, [], {}, "not a phone"].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # Url type
+      class Url < Base
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.url
+
+          else
+            Faker::Internet.url
+          end
+
+        rescue StandardError
+          "https://#{rng.sample(['example.com', 'test.com', 'demo.com'])}/#{rng.sample(['page', 'path', 'resource'])}"
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "http://", "http://a", "https://example.com"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, 123, [], {}, "not-a-url", "missing-protocol.com"].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # Domain type
+      class Domain < Base
+        # Generate random domain 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 domain name
+        #
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.domain_name
+
+          else
+            Faker::Internet.domain_name
+          end
+
+        rescue StandardError
+          "#{rng.sample(['example', 'test', 'demo'])}.#{rng.sample(['com', 'org', 'net'])}"
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "a.b", "very-long-domain-name-that-exceeds-normal-limits.com"].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
+
+      # UserAgent type
+      class UserAgent < Base
+        # Generate random user agent
+        #
+        # @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 user agent string
+        #
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.user_agent
+
+          else
+            Faker::Internet.user_agent
+          end
+
+        rescue StandardError
+          rng.sample([
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+            "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36"
+          ])
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "Mozilla/5.0", "Invalid User Agent"].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/technology_internet/devices.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module TechnologyInternet
+      # MobileDeviceBrand type
+      class MobileDeviceBrand < Base
+        BRANDS = ["Apple", "Samsung", "Google", "Huawei", "Xiaomi", "OnePlus", "LG", "Motorola"].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(BRANDS)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "Apple", "Samsung"].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
+
+      # MobileDeviceModel type
+      class MobileDeviceModel < Base
+        MODELS = [
+          "iPhone 14", "iPhone 13", "Galaxy S23", "Galaxy S22",
+          "Pixel 7", "Pixel 6", "P50", "Mi 13", "OnePlus 11"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(MODELS)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "iPhone 14", "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
+
+      # MobileDeviceOs type
+      class MobileDeviceOs < Base
+        OS_TYPES = ["iOS", "Android", "Windows Mobile", "BlackBerry OS"].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(OS_TYPES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "iOS", "Android"].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
+
+      # MobileDeviceReleaseDate type
+      class MobileDeviceReleaseDate < Base
+        def generate_random(rng, context, args)
+          # Generate date between 2015 and 2024
+          year = rng.int(2015, 2024)
+          month = rng.int(1, 12)
+          day = rng.int(1, 28)
+          Date.new(year, month, day)
+        end
+
+        def generate_edge(rng, context, args)
+          [Date.new(2015, 1, 1), Date.new(2024, 12, 31)].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a date", 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module TechnologyInternet
+      # Language type
+      class Language < Base
+        LANGUAGES = [
+          "English", "Spanish", "French", "German", "Italian", "Portuguese",
+          "Russian", "Chinese", "Japanese", "Korean", "Arabic", "Hindi"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(LANGUAGES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "English", "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
+
+      # LanguageCode type
+      class LanguageCode < Base
+        LANGUAGE_CODES = ["en", "es", "fr", "de", "it", "pt", "ru", "zh", "ja", "ko", "ar", "hi"].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(LANGUAGE_CODES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "en", "xx"].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
+
+      # MimeType type
+      class MimeType < Base
+        MIME_TYPES = [
+          "text/plain", "text/html", "text/css", "text/javascript",
+          "application/json", "application/xml", "application/pdf",
+          "image/jpeg", "image/png", "image/gif", "image/svg+xml",
+          "video/mp4", "video/quicktime", "audio/mpeg", "audio/wav"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(MIME_TYPES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "text/plain", "application/json"].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
+
+      # TopLevelDomain type
+      class TopLevelDomain < Base
+        TLDS = [".com", ".org", ".net", ".edu", ".gov", ".io", ".co", ".ai", ".dev", ".app"].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(TLDS)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", ".com", ".xxx"].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
+
+      # Base64ImageUrl type
+      class Base64ImageUrl < Base
+        def generate_random(rng, context, args)
+          # Generate a data URL with base64 encoded image
+          "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "data:image/png;base64,invalid"].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
+
+      # DummyImageUrl type
+      class DummyImageUrl < Base
+        def generate_random(rng, context, args)
+          min_height = args[:minHeight] || 100
+          max_height = args[:maxHeight] || 800
+          min_width = args[:minWidth] || 100
+          max_width = args[:maxWidth] || 1200
+          format = args[:format] || "jpg"
+
+          height = rng.int(min_height, max_height)
+          width = rng.int(min_width, max_width)
+          "https://dummyimage.com/#{width}x#{height}/000/fff.#{format}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "https://dummyimage.com/1x1/000/fff.jpg"].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
+
+      # MongodbObjectId type
+      class MongodbObjectId < Base
+        def generate_random(rng, context, args)
+          # MongoDB ObjectID is 24 hex characters
+          chars = ('0'..'9').to_a + ('a'..'f').to_a
+          24.times.map { rng.sample(chars) }.join
+        end
+
+        def generate_edge(rng, context, args)
+          ["000000000000000000000000", "ffffffffffffffffffffffff"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not an id", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module TechnologyInternet
+      # Ip type
+      class Ip < Base
+        # Generate a random IPv4 address
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments (not used)
+        # @return [String] IPv4 address string
+        #
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.ip_v4_address
+
+          else
+            Faker::Internet.ip_v4_address
+          end
+
+        rescue StandardError
+          "#{rng.int(1, 255)}.#{rng.int(0, 255)}.#{rng.int(0, 255)}.#{rng.int(1, 255)}"
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["0.0.0.0", "255.255.255.255", "127.0.0.1"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not an ip", "256.256.256.256", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # Ipv6 type
+      class Ipv6 < Base
+        # Generate a random IPv6 address
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments (not used)
+        # @return [String] IPv6 address string
+        #
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.ip_v6_address
+
+          else
+            # Manual IPv6 generation fallback
+            8.times.map { format("%x", rng.int(0, 65535)) }.join(":")
+          end
+
+        rescue StandardError
+          8.times.map { format("%x", rng.int(0, 65535)) }.join(":") # Fallback
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["::1", "fe80::1", "2001:0db8:85a3:0000:0000:8a2e:0370:7334"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not:an:ipv6", "::g", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # MacAddress type
+      class MacAddress < Base
+        # Generate random MAC address
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Symbol] :format format type (:colon, :dash, :none)
+        # @return [String] generated MAC address
+        #
+        def generate_random(rng, context, args)
+          format_type = args[:format] || :colon
+
+          # Generate 6 octets (12 hex digits)
+          octets = 6.times.map { format("%02X", rng.int(0, 255)) }
+
+          case format_type
+          when :dash
+            octets.join("-")
+          when :none
+            octets.join
+          else # :colon
+            octets.join(":")
+          end
+        end
+
+        def generate_edge(rng, context, args)
+          ["00:00:00:00:00:00", "FF:FF:FF:FF:FF:FF"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a mac", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # IpV4Cidr type
+      class IpV4Cidr < Base
+        def generate_random(rng, context, args)
+          # Generate IP with CIDR notation (e.g., 192.168.1.0/24)
+          ip = TechnologyInternet::Ip.new.generate_random(rng, context, {})
+          cidr = rng.int(8, 30) # Common CIDR ranges
+          "#{ip}/#{cidr}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["0.0.0.0/0", "255.255.255.255/32"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not cidr", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # IpV6Cidr type
+      class IpV6Cidr < Base
+        def generate_random(rng, context, args)
+          # Generate IPv6 with CIDR notation
+          ipv6 = TechnologyInternet::Ipv6.new.generate_random(rng, context, {})
+          cidr = rng.int(64, 128) # Common IPv6 CIDR ranges
+          "#{ipv6}/#{cidr}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["::/0", "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not cidr", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+    end
+  end
+end

data/lib/synthra/types/template.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    # Template type generator.
+    #
+    # Substitutes +${field}+ (and legacy +{field}+) placeholders with the
+    # already-generated value of that field in the same record. Field values
+    # come from the generation +context+, which holds every field generated
+    # before this one (fields are generated in definition order).
+    #
+    #   first: name
+    #   greeting: template("Hello ${first}")  # => "Hello Ada Lovelace"
+    #
+    # A referenced field that is not (yet) available is left as the literal
+    # placeholder text rather than blanking the whole string.
+    class Template < Base
+      # Matches ${field} or {field}; the field name is captured.
+      PLACEHOLDER = /\$\{([^}]+)\}|\{([^}]+)\}/
+
+      def generate_random(rng, context, args)
+        pattern = args[:pattern] || args[:template] || ""
+        return "" if pattern.to_s.empty?
+
+        values = context_values(context)
+
+        pattern.to_s.gsub(PLACEHOLDER) do
+          key = (Regexp.last_match(1) || Regexp.last_match(2)).strip
+          if values.key?(key)
+            values[key].to_s
+          else
+            Regexp.last_match(0) # leave the literal placeholder untouched
+          end
+        end
+      end
+
+      def generate_edge(rng, context, args)
+        rng.sample(["", "${missing}", "template"])
+      end
+
+      def generate_invalid(rng, context, args)
+        rng.sample([nil, 123, [], {}])
+      end
+
+      private
+
+      # Flatten the context into a String-keyed lookup of field => value.
+      # Accepts a Context, a Hash, or anything responding to #each.
+      #
+      # @param context [Object]
+      # @return [Hash{String=>Object}]
+      def context_values(context)
+        return {} unless context.respond_to?(:each)
+
+        values = {}
+        context.each do |key, value|
+          values[key.to_s] = value
+        end
+        values
+      end
+
+      # Look up a single value from a context by key.
+      #
+      # Retained as a public-by-#send helper for callers/tests that resolve one
+      # key at a time (e.g. lazy interpolation). The primary generate_random path
+      # uses context_values for bulk substitution; this mirrors that resolution
+      # order (hash-style [] first, then a same-named method) for a single key.
+      #
+      # @param context [Object] context object (Hash, Context, or any object)
+      # @param key [String] key to retrieve
+      # @return [Object] value (stringified) or "" if not found
+      def get_context_value(context, key)
+        return "" if context.nil?
+
+        if context.respond_to?(:[])
+          value = context[key] || context[key.to_sym]
+          return value.to_s if value
+        end
+
+        if context.respond_to?(key)
+          begin
+            return context.public_send(key).to_s
+          rescue NoMethodError
+            return "" # empty result
+          end
+        end
+
+        ""
+      end
+    end
+  end
+end