synthra 0.1.0

data/lib/synthra/types/text_content/text_generation.rb

@@ -0,0 +1,532 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module TextContent
+      # Paragraphs type
+      class Paragraphs < Base
+        def generate_random(rng, context, args)
+          min = args[:min] || 1
+          max = args[:max] || 3
+          count = rng.int(min, max)
+          # English-readable paragraphs — Faker::Hipster reads as English, unlike Latin Lorem.
+          Faker::Hipster.paragraphs(number: count).join("\n\n")
+
+        rescue StandardError
+          "Paragraph 1.\n\nParagraph 2.\n\nParagraph 3."
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "A single paragraph."].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
+
+      # Sentences type
+      class Sentences < Base
+        def generate_random(rng, context, args)
+          min = args[:min] || 1
+          max = args[:max] || 5
+          count = rng.int(min, max)
+          # English-readable sentences — Faker::Hipster reads as English, unlike Latin Lorem.
+          Faker::Hipster.sentences(number: count).join(" ")
+
+        rescue StandardError
+          "Sentence one. Sentence two. Sentence three."
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "A single sentence."].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
+
+      # Words type
+      class Words < Base
+        def generate_random(rng, context, args)
+          min = args[:min] || 3
+          max = args[:max] || 10
+          count = rng.int(min, max)
+          # English-readable words — Faker::Hipster reads as English, unlike Latin Lorem.
+          Faker::Hipster.words(number: count).join(" ")
+
+        rescue StandardError
+          rng.sample(["word one two", "test data here", "sample words"])
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "a", "word"].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
+
+      # Slug type
+      #
+      # Generates a URL-friendly slug — lowercase words joined by hyphens,
+      # e.g. "building-scalable-apis". Deterministic by seed.
+      #
+      # @example Generate a slug
+      #   slug_type = Slug.new
+      #   slug_type.generate_random(rng, context, {})
+      #   # => "building-scalable-apis"
+      #
+      class Slug < Base
+        # Word pool used to assemble slugs (all lowercase, hyphen-safe)
+        #
+        # @return [Array<String>] candidate slug words
+        #
+        WORDS = %w[
+          building scalable apis modern web design fast simple guide
+          getting started with data driven cloud native rust ruby
+          best practices performance tuning real world examples
+        ].freeze
+
+        # Generate a random slug
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Integer] :min minimum word count (default: 3)
+        # @option args [Integer] :max maximum word count (default: 5)
+        # @return [String] generated slug
+        #
+        def generate_random(rng, context, args)
+          min = args[:min] || 3
+          max = args[:max] || 5
+          count = rng.int(min, max)
+          count.times.map { rng.sample(WORDS) }.join("-")
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "a", "post"].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
+
+      # Message text type for chat/DM messages
+      #
+      # Generates realistic chat message text using Faker.
+      # Useful for simulating direct messages, chat conversations, comments.
+      #
+      # @example Generate message text
+      #   message_type = MessageText.new
+      #   message_type.generate_random(rng, context, {})
+      #   # => "Hello! I need help with my order."
+      #
+      class MessageText < Base
+        
+        # English sample messages
+        SAMPLE_MESSAGES_EN = [
+          "Hello! I need help with my order.",
+          "Hi, can you help me?",
+          "Thanks for reaching out!",
+          "I have a question about my account.",
+          "When will my order arrive?",
+          "Great, thank you so much!",
+          "Can I get more information?",
+          "Is this still available?",
+          "Perfect, that's what I needed!",
+          "Could you please check this for me?",
+          "I'm having trouble with my login.",
+          "Thanks for your quick response!",
+          "Just wanted to follow up on my request.",
+          "Appreciate your help! 🙏",
+          "Hi there! 👋",
+          "Got it, thanks!",
+          "Looking forward to hearing from you.",
+          "That sounds good to me.",
+          "No problem at all!",
+          "Let me know if you need anything else."
+        ].freeze
+
+        # Arabic sample messages
+        SAMPLE_MESSAGES_AR = [
+          "مرحباً! أحتاج مساعدة في طلبي.",
+          "أهلاً، هل يمكنك مساعدتي؟",
+          "شكراً على التواصل!",
+          "لدي سؤال عن حسابي.",
+          "متى سيصل طلبي؟",
+          "رائع، شكراً جزيلاً!",
+          "هل يمكنني الحصول على مزيد من المعلومات؟",
+          "هل هذا لا يزال متاحاً؟",
+          "ممتاز، هذا ما أحتاجه!",
+          "هل يمكنك التحقق من هذا من فضلك؟",
+          "أواجه مشكلة في تسجيل الدخول.",
+          "شكراً على ردك السريع!",
+          "أردت المتابعة بخصوص طلبي.",
+          "أقدر مساعدتك! 🙏",
+          "أهلاً! 👋",
+          "فهمت، شكراً!",
+          "في انتظار ردك.",
+          "يبدو جيداً بالنسبة لي.",
+          "لا مشكلة على الإطلاق!",
+          "أخبرني إذا احتجت أي شيء آخر."
+        ].freeze
+
+        # Spanish sample messages
+        SAMPLE_MESSAGES_ES = [
+          "¡Hola! Necesito ayuda con mi pedido.",
+          "Hola, ¿puedes ayudarme?",
+          "¡Gracias por contactarnos!",
+          "Tengo una pregunta sobre mi cuenta.",
+          "¿Cuándo llegará mi pedido?",
+          "¡Genial, muchas gracias!",
+          "¿Puedo obtener más información?",
+          "¿Esto todavía está disponible?",
+          "¡Perfecto, eso es lo que necesitaba!",
+          "¿Podrías verificar esto por mí?",
+          "Tengo problemas con mi inicio de sesión.",
+          "¡Gracias por tu rápida respuesta!",
+          "Solo quería dar seguimiento a mi solicitud.",
+          "¡Aprecio tu ayuda! 🙏",
+          "¡Hola! 👋",
+          "Entendido, ¡gracias!",
+          "Espero tu respuesta.",
+          "Me parece bien.",
+          "¡No hay problema!",
+          "Avísame si necesitas algo más."
+        ].freeze
+
+        # French sample messages
+        SAMPLE_MESSAGES_FR = [
+          "Bonjour ! J'ai besoin d'aide avec ma commande.",
+          "Salut, peux-tu m'aider ?",
+          "Merci de nous avoir contactés !",
+          "J'ai une question sur mon compte.",
+          "Quand ma commande arrivera-t-elle ?",
+          "Super, merci beaucoup !",
+          "Puis-je avoir plus d'informations ?",
+          "Est-ce toujours disponible ?",
+          "Parfait, c'est ce qu'il me fallait !",
+          "Pourriez-vous vérifier cela pour moi ?",
+          "J'ai des problèmes de connexion.",
+          "Merci pour votre réponse rapide !",
+          "Je voulais faire un suivi de ma demande.",
+          "J'apprécie votre aide ! 🙏",
+          "Salut ! 👋",
+          "Compris, merci !",
+          "J'attends votre réponse.",
+          "Ça me convient.",
+          "Pas de problème !",
+          "Faites-moi savoir si vous avez besoin d'autre chose."
+        ].freeze
+
+        # Locale to messages mapping
+        MESSAGES_BY_LOCALE = {
+          en: SAMPLE_MESSAGES_EN,
+          ar: SAMPLE_MESSAGES_AR,
+          es: SAMPLE_MESSAGES_ES,
+          fr: SAMPLE_MESSAGES_FR
+        }.freeze
+
+        # Keep backward compatibility
+        SAMPLE_MESSAGES = SAMPLE_MESSAGES_EN
+
+        # Faker locale mapping
+        FAKER_LOCALES = {
+          en: :en,
+          ar: :ar,
+          es: :es,
+          fr: :fr,
+          de: :de,
+          it: :it,
+          pt: :pt,
+          ru: :ru,
+          ja: :ja,
+          ko: :ko,
+          zh: :'zh-CN'
+        }.freeze
+
+        def generate_random(rng, context, args)
+          # Check for mixed locales BEFORE extracting locale
+          locale_arg = args[:locale] || args[:language] || args[:lang]
+          
+          # If mixed locales requested (e.g., locale: "en,ar" or locales: ["en", "ar"])
+          if args[:locales] || args[:mixed] || (locale_arg.is_a?(String) && locale_arg.include?(","))
+            return generate_mixed_locale(rng, args)
+          end
+          
+          locale = extract_locale(args)
+          
+          # Single locale
+          messages = MESSAGES_BY_LOCALE[locale] || SAMPLE_MESSAGES_EN
+          faker_locale = FAKER_LOCALES[locale] || :en
+          
+          # Use Faker with locale for variety (50% Faker, 50% static)
+          case rng.int(0, 9)
+          when 0..4
+            # Use Faker with the appropriate locale
+            generate_faker_message(rng, faker_locale)
+          else
+            # Use static messages for guaranteed quality
+            messages[rng.int(0, messages.length - 1)]
+          end
+
+        rescue StandardError
+          messages = MESSAGES_BY_LOCALE[locale] || SAMPLE_MESSAGES_EN
+          messages[rng.int(0, messages.length - 1)]
+        end
+
+        def generate_faker_message(rng, faker_locale)
+          original_locale = Faker::Config.locale
+          begin
+            Faker::Config.locale = faker_locale
+            
+            # For Arabic, use different approach since Lorem doesn't support Arabic
+            if faker_locale == :ar
+              generate_faker_arabic_message(rng)
+            else
+              generate_faker_latin_message(rng)
+            end
+          ensure
+            Faker::Config.locale = original_locale
+          end
+        end
+
+        def generate_faker_arabic_message(rng)
+          # Arabic-specific message generation using supported Faker modules
+          templates = [
+            -> { "مرحباً #{Faker::Name.first_name}، كيف حالك؟" },
+            -> { "أهلاً بك في #{Faker::Company.name}" },
+            -> { "شكراً لتواصلك مع #{Faker::Company.name}" },
+            -> { "مرحباً، أنا #{Faker::Name.name}" },
+            -> { "تحياتي من #{Faker::Address.city}" },
+            -> { "#{Faker::Name.first_name} يرحب بك" },
+            -> { "نتطلع للعمل معك في #{Faker::Company.name}" },
+            -> { "#{Faker::Company.name} في خدمتك" },
+            -> { "أهلاً من #{Faker::Address.city}!" },
+            -> { "تواصل معنا في #{Faker::Company.name}" },
+          ]
+          templates[rng.int(0, templates.length - 1)].call
+        end
+
+        def generate_faker_latin_message(rng)
+          case rng.int(0, 5)
+          when 0
+            Faker::Lorem.sentence(word_count: rng.int(4, 10))
+          when 1
+            Faker::Lorem.question(word_count: rng.int(4, 8))
+          when 2
+            # Company catch phrase - works in most locales
+            Faker::Company.catch_phrase
+          when 3
+            # Try greeting - falls back gracefully
+            begin
+              Faker::Greeting.hi
+            rescue
+              Faker::Lorem.sentence(word_count: rng.int(3, 6))
+            end
+          when 4
+            # Quote - works in most locales
+            begin
+              Faker::Quote.famous_last_words
+            rescue
+              Faker::Lorem.sentence(word_count: rng.int(5, 10))
+            end
+          else
+            Faker::Lorem.sentences(number: 1).first
+          end
+        end
+
+        private
+
+        def extract_locale(args)
+          locale_arg = args[:locale] || args[:language] || args[:lang] || :en
+          locale_str = locale_arg.to_s.downcase.strip
+          
+          case locale_str
+          when "en", "english" then :en
+          when "ar", "arabic" then :ar
+          when "es", "spanish" then :es
+          when "fr", "french" then :fr
+          else
+            locale_str.to_sym
+          end
+        end
+
+        def generate_mixed_locale(rng, args)
+          # Parse locales from various formats
+          locales = if args[:locales].is_a?(Array)
+                      args[:locales].map { |l| normalize_locale(l) }
+                    elsif args[:mixed].is_a?(Array)
+                      args[:mixed].map { |l| normalize_locale(l) }
+                    elsif args[:locale].is_a?(String) && args[:locale].include?(",")
+                      args[:locale].split(",").map { |l| normalize_locale(l.strip) }
+                    else
+                      [:en, :ar] # Default mixed
+                    end
+          
+          # Pick a random locale
+          selected_locale = locales[rng.int(0, locales.length - 1)]
+          messages = MESSAGES_BY_LOCALE[selected_locale] || SAMPLE_MESSAGES_EN
+          messages[rng.int(0, messages.length - 1)]
+        end
+
+        def normalize_locale(locale)
+          case locale.to_s.downcase
+          when "en", "english" then :en
+          when "ar", "arabic" then :ar
+          when "es", "spanish" then :es
+          when "fr", "french" then :fr
+          else
+            locale.to_s.to_sym
+          end
+        end
+
+        public
+
+
+        def generate_edge(rng, context, args)
+          rng.sample([
+            "",                    # Empty message
+            "👋",                  # Single emoji
+            "a",                   # Single character
+            "OK",                  # Very short
+            "!" * 100,            # Long repeated chars
+            "Hello 你好 مرحبا"     # Unicode/multilingual
+          ])
+        end
+
+        def generate_invalid(rng, context, args)
+          rng.sample([
+            nil,
+            123,
+            [],
+            {},
+            true
+          ])
+        end
+      end
+
+      # Empty array type for entities
+      #
+      # Always returns an empty array. Useful for API responses
+      # that have optional array fields.
+      #
+      class EmptyArray < Base
+        def generate_random(_rng, _context, _args)
+          []
+        end
+
+        def generate_edge(_rng, _context, _args)
+          []
+        end
+
+        def generate_invalid(rng, _context, _args)
+          rng.sample([nil, "", {}, "[]"])
+        end
+      end
+
+      # Hashtag text (without # prefix)
+      #
+      # Generates hashtag-style text without the # symbol.
+      #
+      class HashtagText < Base
+        
+        HASHTAGS = %w[
+          help support question order shipping delivery customer service
+          tech coding ruby programming api dev javascript python
+          love awesome amazing cool great best new trending viral
+          business startup entrepreneur innovation growth success
+        ].freeze
+        
+
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.fetch("internet.slug").gsub("-", "")
+
+          else
+            HASHTAGS[rng.int(0, HASHTAGS.length - 1)]
+          end
+
+        rescue StandardError
+          HASHTAGS[rng.int(0, HASHTAGS.length - 1)]
+        end
+
+
+        def generate_edge(rng, context, args)
+          rng.sample(["", "a", "x" * 50])
+        end
+
+        def generate_invalid(rng, context, args)
+          rng.sample([nil, 123, [], "#invalid"])
+        end
+      end
+
+      # Twitter/social handle (without @ prefix)
+      #
+      # Generates username-style handles for social media.
+      #
+      class SocialHandle < Base
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.fetch("internet.username")
+
+          else
+            Faker::Internet.username(specifier: 5..15)
+          end
+
+        rescue StandardError
+          "user_#{rng.int(1000, 99999)}"
+        end
+
+
+        def generate_edge(rng, context, args)
+          rng.sample(["", "a", "user_" + ("x" * 50)])
+        end
+
+        def generate_invalid(rng, context, args)
+          rng.sample([nil, 123, [], "@invalid"])
+        end
+      end
+
+      # Indices pair for entity positions
+      #
+      # Generates [start, end] pairs for text entity positions.
+      #
+      class IndicesPair < Base
+        def generate_random(rng, context, args)
+          start = rng.int(0, 100)
+          length = rng.int(5, 30)
+          [start, start + length]
+        end
+
+        def generate_edge(rng, context, args)
+          rng.sample([
+            [0, 0],        # Zero length
+            [0, 1],        # Single char
+            [0, 280],      # Full tweet length
+            [100, 105]     # End of text
+          ])
+        end
+
+        def generate_invalid(rng, context, args)
+          rng.sample([
+            nil,
+            [],
+            [10, 5],       # End before start
+            [-1, 10],      # Negative start
+            "invalid"
+          ])
+        end
+      end
+    end
+  end
+end

data/lib/synthra/types/travel/travel.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module Travel
+      # Airline type
+      class Airline < Base
+        # Generate random airline 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 airline name
+        #
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.airline
+
+          else
+            Faker::Airline.name
+          end
+
+        rescue StandardError
+          rng.sample(["American Airlines", "United Airlines", "Delta Air Lines"])
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "A", "Very Long Airline 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
+
+      # AirportCode type
+      class AirportCode < Base
+        # Common IATA airport codes
+        #
+        # List of major international airport codes.
+        #
+        # @return [Array<String>] list of 3-letter airport codes
+        #
+        AIRPORT_CODES = [
+          "JFK", "LAX", "LHR", "CDG", "DXB", "SIN", "HKG", "NRT",
+          "FRA", "AMS", "MAD", "BCN", "FCO", "MIA", "ORD", "ATL",
+          "DFW", "DEN", "SFO", "SEA", "BOS", "IAD", "IAH", "MSP"
+        ].freeze
+
+        # Generate random airport code
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments (not used)
+        # @return [String] generated airport code
+        #
+        def generate_random(rng, context, args)
+          rng.sample(AIRPORT_CODES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "JFK", "LAX"].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
+
+      # FlightNumber type
+      class FlightNumber < Base
+        # Common IATA airline codes
+        #
+        # Two-letter codes for major airlines.
+        #
+        # @return [Array<String>] list of airline codes
+        #
+        AIRLINE_CODES = ["AA", "UA", "DL", "SW", "LH", "BA", "AF", "EK", "SQ", "JL"].freeze
+
+        # Generate random flight number
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [String] :airline airline code (default: random)
+        # @option args [Integer] :length flight number length (default: 3..4 digits)
+        # @return [String] generated flight number
+        #
+        def generate_random(rng, context, args)
+          airline = args[:airline] || rng.sample(AIRLINE_CODES)
+          length = args[:length] || rng.int(3, 4)
+
+          # Generate flight number digits
+          max_value = 10**length - 1
+          number = format("%0#{length}d", rng.int(1, max_value))
+
+          "#{airline}#{number}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["AA000", "AA9999", "ZZ000"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a flight", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # SeatNumber type
+      class SeatNumber < Base
+        # Default aircraft seat letters
+        #
+        # Standard 6-seat configuration (A-F) for economy class.
+        #
+        # @return [Array<String>] list of seat letters
+        #
+        DEFAULT_SEATS = ["A", "B", "C", "D", "E", "F"].freeze
+
+        # Generate random seat number
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Integer] :rows number of rows (default: 1..30)
+        # @option args [Array<String>] :seats seat letters (default: A-F)
+        # @return [String] generated seat number
+        #
+        def generate_random(rng, context, args)
+          max_rows = args[:rows] || 30
+          seats = args[:seats] || DEFAULT_SEATS
+
+          row = rng.int(1, max_rows)
+          seat = rng.sample(seats)
+
+          "#{row}#{seat}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["1A", "30F", "1B"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a seat", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+    end
+  end
+end