synthra 0.1.0

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module TextContent
+      # Buzzword type
+      class Buzzword < Base
+        BUZZWORDS = [
+          "Synergy", "Paradigm", "Leverage", "Disrupt", "Innovation",
+          "Scalable", "Agile", "Cloud", "Big Data", "AI", "Blockchain"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.buzzword
+
+          else
+            Faker::Company.buzzword
+          end
+
+        rescue StandardError
+          rng.sample(BUZZWORDS)
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "Synergy"].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
+
+      # CatchPhrase type
+      class CatchPhrase < Base
+        PHRASES = [
+          "Think Different", "Just Do It", "I'm Lovin' It",
+          "Because You're Worth It", "The Best a Man Can Get"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.catch_phrase
+
+          else
+            Faker::Company.catch_phrase
+          end
+
+        rescue StandardError
+          rng.sample(PHRASES)
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "Just Do It"].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
+
+      # Slogan type
+      class Slogan < Base
+        SLOGANS = [
+          "Just Do It", "Think Different", "I'm Lovin' It",
+          "Because You're Worth It", "The Best a Man Can Get",
+          "Have It Your Way", "Finger Lickin' Good"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter && adapter.respond_to?(:slogan)
+            begin
+              adapter.slogan
+            rescue StandardError
+              rng.sample(SLOGANS)
+            end
+          else
+            # Faker doesn't have a direct slogan method, use catch_phrase
+            begin
+              Faker::Company.catch_phrase
+            rescue StandardError
+              # Fallback to English-only hardcoded list
+              rng.sample(SLOGANS) # fallback
+            end
+          end
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "Just Do It"].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
+
+      # FakeCompanyName type
+      class FakeCompanyName < Base
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter && adapter.respond_to?(:company_name)
+            adapter.company_name
+
+          else
+            Faker::Company.name
+          end
+
+        rescue StandardError
+          rng.sample(["Acme Corp", "Tech Solutions Inc", "Global Industries"])
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "A", "Very Long Company Name"].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/text_content/colors.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module TextContent
+      # Color type
+      class Color < Base
+        COLORS = [
+          "Red", "Blue", "Green", "Yellow", "Orange", "Purple",
+          "Pink", "Brown", "Black", "White", "Gray", "Cyan", "Magenta"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.color
+
+          else
+            Faker::Commerce.color
+          end
+
+        rescue StandardError
+          rng.sample(COLORS)
+        end
+
+
+        def generate_edge(rng, context, args)
+          ["", "Red", "Black"].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
+
+      # HexColor type
+      class HexColor < Base
+        def generate_random(rng, context, args)
+          # Generate 6-digit hex color
+          chars = ('0'..'9').to_a + ('A'..'F').to_a
+          "##{6.times.map { rng.sample(chars) }.join}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["#000000", "#FFFFFF", "#FF0000"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a color", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # ShortHexColor type
+      class ShortHexColor < Base
+        def generate_random(rng, context, args)
+          chars = ('0'..'9').to_a + ('A'..'F').to_a
+          "##{3.times.map { rng.sample(chars) }.join}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["#000", "#FFF", "#F00"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a color", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module TextContent
+      # Avatar type
+      class Avatar < Base
+        def generate_random(rng, context, args)
+          height = args[:height] || 200
+          width = args[:width] || 200
+          "https://i.pravatar.cc/#{width}?img=#{rng.int(1, 70)}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "https://i.pravatar.cc/1?img=1"].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
+
+      # FileName type
+      class FileName < Base
+        EXTENSIONS = ["txt", "pdf", "doc", "xls", "jpg", "png", "gif", "mp4", "zip", "csv"].freeze
+
+        def generate_random(rng, context, args)
+          name = rng.sample([
+            "document", "file", "report", "data", "image", "video",
+            "archive", "spreadsheet", "presentation", "backup"
+          ])
+          number = rng.int(1, 999)
+          ext = rng.sample(EXTENSIONS)
+          "#{name}_#{number}.#{ext}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "file.1", "very_long_file_name_that_exceeds_normal_limits.txt"].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
+
+      # Frequency type
+      class Frequency < Base
+        FREQUENCIES = ["Daily", "Weekly", "Monthly", "Quarterly", "Yearly", "Once", "Never"].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(FREQUENCIES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "Daily", "Never"].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
+
+      # LinkedInSkill type
+      class LinkedInSkill < Base
+        SKILLS = [
+          "JavaScript", "Python", "Java", "Ruby", "Go", "Rust",
+          "React", "Vue", "Angular", "Node.js", "SQL", "MongoDB",
+          "AWS", "Docker", "Kubernetes", "Git", "Agile", "Scrum"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(SKILLS)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "JavaScript", "Python"].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
+
+      # NatoPhonetic type
+      class NatoPhonetic < Base
+        NATO_ALPHABET = [
+          "Alpha", "Bravo", "Charlie", "Delta", "Echo", "Foxtrot",
+          "Golf", "Hotel", "India", "Juliet", "Kilo", "Lima",
+          "Mike", "November", "Oscar", "Papa", "Quebec", "Romeo",
+          "Sierra", "Tango", "Uniform", "Victor", "Whiskey", "X-ray", "Yankee", "Zulu"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          min = args[:min] || 1
+          max = args[:max] || 5
+          count = rng.int(min, max)
+          count.times.map { rng.sample(NATO_ALPHABET) }.join(" ")
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "Alpha", "Zulu"].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
+
+      # RowNumber type
+      class RowNumber < Base
+        def generate_random(rng, context, args)
+          rng.int(1, 10000)
+        end
+
+        def generate_edge(rng, context, args)
+          [1, 10000, 0].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a number", -1, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # SqlExpression type
+      class SqlExpression < Base
+        def generate_random(rng, context, args)
+          value = args[:value] || "SELECT * FROM users"
+          # Return as-is, but note this is intentionally not executed
+          value
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "SELECT 1", "DROP TABLE users"].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
+
+      # University type
+      class University < Base
+        UNIVERSITIES = [
+          "Harvard University", "Stanford University", "MIT", "Oxford University",
+          "Cambridge University", "Yale University", "Princeton University", "Columbia University"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(UNIVERSITIES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "MIT", "Harvard University"].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
+
+      # Blank type
+      class Blank < Base
+        def generate_random(rng, context, args)
+          ""
+        end
+
+        def generate_edge(rng, context, args)
+          [""]
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # Race type
+      class Race < Base
+        RACES = [
+          "White", "Black or African American", "Asian", "American Indian or Alaska Native",
+          "Native Hawaiian or Other Pacific Islander", "Other", "Prefer not to say"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(RACES)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "White", "Other"].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
+
+      # DepartmentCorporate type
+      class DepartmentCorporate < Base
+        DEPARTMENTS = [
+          "Engineering", "Sales", "Marketing", "HR", "Finance",
+          "Operations", "Legal", "IT", "Customer Support", "Product"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(DEPARTMENTS)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "Engineering", "Sales"].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
+
+      # DepartmentRetail type
+      class DepartmentRetail < Base
+        DEPARTMENTS = [
+          "Electronics", "Clothing", "Home & Garden", "Sports & Outdoors",
+          "Toys & Games", "Books", "Automotive", "Health & Beauty", "Grocery"
+        ].freeze
+
+        def generate_random(rng, context, args)
+          rng.sample(DEPARTMENTS)
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "Electronics", "Grocery"].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/text_content/security.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module TextContent
+      # Password type
+      class Password < Base
+        def generate_random(rng, context, args)
+          min_length = args[:min_length] || 8
+          min_upper = args[:min_upper] || 1
+          min_lower = args[:min_lower] || 1
+          min_numbers = args[:min_numbers] || 1
+          min_symbols = args[:min_symbols] || 0
+
+          uppercase = ('A'..'Z').to_a
+          lowercase = ('a'..'z').to_a
+          numbers = ('0'..'9').to_a
+          symbols = ['!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '-', '_', '+', '=']
+
+          password = []
+          password.concat(min_upper.times.map { rng.sample(uppercase) })
+          password.concat(min_lower.times.map { rng.sample(lowercase) })
+          password.concat(min_numbers.times.map { rng.sample(numbers) })
+          password.concat(min_symbols.times.map { rng.sample(symbols) })
+
+          # Fill remaining length
+          all_chars = uppercase + lowercase + numbers + symbols
+          remaining = min_length - password.length
+          password.concat(remaining.times.map { rng.sample(all_chars) }) if remaining > 0
+
+          password.shuffle(random: rng.instance_variable_get(:@random)).join
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "A", "12345678"].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
+
+      # PasswordHash type
+      class PasswordHash < Base
+        def generate_random(rng, context, args)
+          # Generate bcrypt-like hash (60 characters)
+          chars = ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a + ['./']
+          "$2a$10$#{54.times.map { rng.sample(chars) }.join}"
+        end
+
+        def generate_edge(rng, context, args)
+          ["$2a$10$00000000000000000000000000000000000000000000000000000000"].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
+
+      # Md5 type
+      class Md5 < Base
+        def generate_random(rng, context, args)
+          # Generate 32-character hex MD5 hash
+          chars = ('0'..'9').to_a + ('a'..'f').to_a
+          32.times.map { rng.sample(chars) }.join
+        end
+
+        def generate_edge(rng, context, args)
+          ["00000000000000000000000000000000", "ffffffffffffffffffffffffffffffff"].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
+
+      # Sha1 type
+      class Sha1 < Base
+        def generate_random(rng, context, args)
+          # Generate 40-character hex SHA1 hash
+          chars = ('0'..'9').to_a + ('a'..'f').to_a
+          40.times.map { rng.sample(chars) }.join
+        end
+
+        def generate_edge(rng, context, args)
+          ["0000000000000000000000000000000000000000", "ffffffffffffffffffffffffffffffffffffffff"].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
+
+      # Sha256 type
+      class Sha256 < Base
+        def generate_random(rng, context, args)
+          # Generate 64-character hex SHA256 hash
+          chars = ('0'..'9').to_a + ('a'..'f').to_a
+          64.times.map { rng.sample(chars) }.join
+        end
+
+        def generate_edge(rng, context, args)
+          ["0000000000000000000000000000000000000000000000000000000000000000", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"].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
+
+      # Encrypt type
+      class Encrypt < Base
+        def generate_random(rng, context, args)
+          # Generate a base64-like encrypted string
+          chars = ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a + ['+', '/', '=']
+          length = rng.int(20, 40)
+          length.times.map { rng.sample(chars) }.join
+        end
+
+        def generate_edge(rng, context, args)
+          ["", "AAAAAAAAAAAAAAAAAAAA", "ZZZZZZZZZZZZZZZZZZZZ"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not encrypted", "invalid", [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+    end
+  end
+end