solara 0.7.2 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f359a3ba4f7f58b06a5c26efa077d45900f5d98952c8ffb85ed80407b5060b5
-  data.tar.gz: 1f9bf9dc53e840e154f7c8ad3474f04cf4423bbd0ee97f201aa751e1a03423d0
+  metadata.gz: 58813f26f146e2116b645174ff1c07b4d55fd681c95aeac51d14816668b44211
+  data.tar.gz: 212aebb78263261836b669f60c78fcb3148c79c0aee218cd90477458865ecc96
 SHA512:
-  metadata.gz: bbf72d63463d30bd732fc79bb254c66aeba2f65773bb488ac697688656b462860c3e1b9b0ac4a0d506ccc7d249dad2cf4130b2e0f7da06d8d1862765f8cf81dc
-  data.tar.gz: 36ddb1dcdbcf3c3c0540ea5c78461083bc5fc98751a94e864cd81278ead26919006b80bd037d2a57d5d9be557a0b7916a829e04420366abb99db7ba6fb4ad905
+  metadata.gz: 4f31381757be0faeeb566131c45a9242b63a8b89fb610ccd6b6abd5bb7b99937890ee6f2e5420ac95022d3e534aeeb48e29dc427206f18217871768caaa84a58
+  data.tar.gz: aa9af4d947d47c5a5ae7d43f336e4ee1c4d16b8c4224778f19579061f8215e3508887143607688f831d89229ba7d2c89a5925f9c6f4b0487d73632fb7356f33c

data/solara/lib/core/scripts/brand_config_manager.rb

@@ -1,5 +1,6 @@
 Dir.glob("#{__dir__}/../scripts/platform/android/*.rb").each { |file| require file }
 Dir.glob("#{__dir__}/../scripts/platform/ios/*.rb").each { |file| require file }
+Dir.glob("#{__dir__}/../scripts/code_generator/*.rb").each { |file| require file }
 
 class BrandConfigManager
     def initialize(brand_key)

data/solara/lib/core/scripts/code_generator/class_name_registry.rb

@@ -0,0 +1,33 @@
+class ClassNameRegistry
+  def initialize(custom_types = {})
+    @registry = {}
+    @custom_types = custom_types
+  end
+
+  def register(key, class_name)
+    @registry[key] = class_name
+  end
+
+  def get_class_name(key, default_name)
+    @custom_types[key] || @registry[key] || default_name
+  end
+
+  def get_type(value, default_type)
+    type_key = generate_type_key(value, default_type)
+    @custom_types[type_key] || default_type
+  end
+
+  private
+
+  def generate_type_key(value, default_type)
+    case value
+    when String then "String"
+    when Integer then "int"
+    when Float then "double"
+    when TrueClass, FalseClass then "bool"
+    when Array then "List"
+    when Hash then default_type # class name
+    else default_type
+    end
+  end
+end

data/solara/lib/core/scripts/code_generator/code_generator.rb

@@ -0,0 +1,53 @@
+module Language
+  Kotlin = 'kotlin'
+  Swift = 'swift'
+  Dart = 'dart'
+
+  def self.all
+    [Kotlin, Swift, Dart]
+  end
+
+  def self.init(language)
+    if all.include?(language)
+      # Do something with the valid language
+    else
+      raise ArgumentError, "Invalid language. Please use one of: #{all.join(', ')}"
+    end
+  end
+end
+
+class CodeGenerator
+  def initialize(
+    json:,
+    language:,
+    parent_class_name:,
+    custom_types: {}
+  )
+    @json = json
+    @language = language
+    @parent_class_name = parent_class_name
+    @custom_types = custom_types
+    @generator = create_language_generator
+  end
+
+  def generate
+    @generator.generate unless @generator.nil?
+  end
+
+  private
+
+  def create_language_generator
+    registry = ClassNameRegistry.new(@custom_types)
+
+    case @language
+    when Language::Kotlin
+      KotlinCodeGenerator.new(@json, @parent_class_name, registry)
+    when Language::Swift
+      SwiftCodeGenerator.new(@json, @parent_class_name, registry)
+    when Language::Dart
+      DartCodeGenerator.new(@json, @parent_class_name, registry)
+    else
+      raise ArgumentError, "Unsupported language: #{@language}"
+    end
+  end
+end

data/solara/lib/core/scripts/code_generator/dart_code_generator.rb

@@ -0,0 +1,112 @@
+class DartCodeGenerator
+  def initialize(json, parent_class_name, registry = nil)
+    @json = json
+    @parent_class_name = parent_class_name
+    @registry = registry || ClassNameRegistry.new
+    @generated_classes = []
+  end
+
+  def generate
+    imports = "import 'package:flutter/material.dart';\n\n"
+    generate_class(@json, @parent_class_name)
+    imports + @generated_classes.reverse.join("\n\n")
+  end
+
+  private
+
+  def generate_class(json_obj, class_name)
+    @registry.register(class_name, class_name)
+    class_name = @registry.get_class_name(class_name, class_name)
+    return if @generated_classes.any? { |c| c.include?("class #{class_name}") }
+
+    properties = []
+    constructor_params = []
+    companion_values = []
+    instance_values = []
+
+    json_obj.each do |key, value|
+      nested_class_name = "#{class_name}#{StringCase.capitalize(key)}"
+      @registry.register(nested_class_name, nested_class_name)
+      nested_class_name = @registry.get_class_name(nested_class_name, nested_class_name)
+
+      type = determine_type(value, nested_class_name, "#{class_name}.#{key}")
+
+      if value.is_a?(Hash)
+        generate_class(value, nested_class_name)
+        companion_values << "static final #{key}Value = #{nested_class_name}.instance;"
+      elsif value.is_a?(Array) && !value.empty? && value.first.is_a?(Hash)
+        generate_class(value.first, nested_class_name)
+        type = "List<#{nested_class_name}>"
+        list_values = value.map { |_| "#{nested_class_name}.instance" }
+        companion_values << "static final #{key}Value = <#{nested_class_name}>[#{list_values.join(", ")}];"
+      else
+        companion_values << "static final #{key}Value = #{dart_value(value)};"
+      end
+
+      properties << "final #{type} #{key};"
+      constructor_params << "required this.#{key}"
+      instance_values << "#{key}: #{key}Value"
+    end
+
+    class_code = <<~DART
+      class #{class_name} {
+        #{properties.join("\n  ")}
+
+        const #{class_name}({#{constructor_params.join(", ")}});
+
+        static #{class_name}? _instance;
+
+        #{companion_values.join("\n    ")}
+
+        static #{class_name} get instance {
+          _instance ??= #{class_name}(
+            #{instance_values.join(",\n            ")}
+          );
+          return _instance!;
+        }
+      }
+    DART
+
+    @generated_classes << class_code
+  end
+
+  def determine_type(value, class_name, registry_key)
+    base_type = if value.is_a?(String) && ColorDetector.new(value).color?
+      "Color"
+    elsif value.is_a?(String)
+      "String"
+    elsif value.is_a?(Integer)
+      "int"
+    elsif value.is_a?(Float)
+      "double"
+    elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      "bool"
+    elsif value.is_a?(Array)
+      item_type = value.empty? ? "dynamic" : determine_type(value.first, class_name, "#{registry_key}[]")
+      "List<#{item_type}>"
+    elsif value.is_a?(Hash)
+      class_name
+    else
+      "dynamic"
+    end
+
+    @registry.get_type(value, base_type)
+  end
+
+  def dart_value(value)
+    if value.is_a?(String) && ColorDetector.new(value).color?
+      hex = value.gsub('#', '')
+      if hex.length == 8
+        return "Color(0x#{hex})"
+      else
+        return "Color(0xFF#{hex})"
+      end
+    end
+    return "\"#{value}\"" if value.is_a?(String)
+    return value.to_s if value.is_a?(Integer) || value.is_a?(Float)
+    return value.to_s.downcase if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+    return "<#{determine_type(value.first, '', '')}>[#{value.map { |v| dart_value(v) }.join(", ")}]" if value.is_a?(Array)
+    return "null" if value.nil?
+    value.to_s
+  end
+end

data/solara/lib/core/scripts/code_generator/kotlin_code_generator.rb

@@ -0,0 +1,111 @@
+class KotlinCodeGenerator
+  def initialize(json, parent_class_name, registry = nil)
+    @json = json
+    @parent_class_name = parent_class_name
+    @registry = registry || ClassNameRegistry.new
+    @generated_classes = []
+  end
+
+  def generate
+    imports = "import android.graphics.Color\n\n"
+    generate_class(@json, @parent_class_name)
+    imports + @generated_classes.reverse.join("\n\n")
+  end
+
+  private
+
+  def generate_class(json_obj, class_name)
+    @registry.register(class_name, class_name)
+    class_name = @registry.get_class_name(class_name, class_name)
+    return if @generated_classes.any? { |c| c.include?("data class #{class_name}") }
+
+    properties = []
+    companion_values = []
+
+    json_obj.each do |key, value|
+      nested_class_name = "#{class_name}#{StringCase.capitalize(key)}"
+      @registry.register(nested_class_name, nested_class_name)
+      nested_class_name = @registry.get_class_name(nested_class_name, nested_class_name)
+
+      type = determine_type(value, nested_class_name, "#{class_name}.#{key}")
+
+      if value.is_a?(Hash)
+        generate_class(value, nested_class_name)
+        companion_values << "private val #{key}Value = #{nested_class_name}.instance"
+      elsif value.is_a?(Array) && !value.empty? && value.first.is_a?(Hash)
+        generate_class(value.first, nested_class_name)
+        type = "List<#{nested_class_name}>"
+        list_values = value.map { |_| "#{nested_class_name}.instance" }
+        companion_values << "private val #{key}Value = listOf(#{list_values.join(", ")})"
+      else
+        companion_values << "private val #{key}Value = #{kotlin_value(value)}"
+      end
+
+      properties << "val #{key}: #{type}"
+    end
+
+    class_code = <<~KOTLIN
+      data class #{class_name}(
+          #{properties.join(",\n          ")}
+      ) {
+          companion object {
+              private var _instance: #{class_name}? = null
+
+              #{companion_values.join("\n          ")}
+
+              val instance: #{class_name}
+                  get() {
+                      if (_instance == null) {
+                          _instance = #{class_name}(
+                              #{json_obj.keys.map { |key| "#{key} = #{key}Value" }.join(",\n                              ")}
+                          )
+                      }
+                      return _instance!!
+                  }
+          }
+      }
+    KOTLIN
+
+    @generated_classes << class_code
+  end
+
+  def determine_type(value, class_name, registry_key)
+    base_type = if value.is_a?(String) && ColorDetector.new(value).color?
+      "Int"
+    elsif value.is_a?(String)
+      "String"
+    elsif value.is_a?(Integer)
+      "Int"
+    elsif value.is_a?(Float)
+      "Double"
+    elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      "Boolean"
+    elsif value.is_a?(Array)
+      item_type = value.empty? ? "Any" : determine_type(value.first, class_name, "#{registry_key}[]")
+      "List<#{item_type}>"
+    elsif value.is_a?(Hash)
+      class_name
+    else
+      "Any"
+    end
+
+    @registry.get_type(value, base_type)
+  end
+
+  def kotlin_value(value)
+    if value.is_a?(String) && ColorDetector.new(value).color?
+      hex = value.gsub('#', '')
+      if hex.length == 8
+        return "Color.parseColor(\"##{hex}\")"
+      else
+        return "Color.parseColor(\"##{hex}\")"
+      end
+    end
+    return "\"#{value}\"" if value.is_a?(String)
+    return value.to_s if value.is_a?(Integer) || value.is_a?(Float)
+    return value.to_s.downcase if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+    return "listOf(#{value.map { |v| kotlin_value(v) }.join(", ")})" if value.is_a?(Array)
+    return "null" if value.nil?
+    value.to_s
+  end
+end

data/solara/lib/core/scripts/code_generator/swift_code_generator.rb

@@ -0,0 +1,108 @@
+class SwiftCodeGenerator
+    def initialize(json, parent_class_name, registry = nil)
+      @json = json
+      @parent_class_name = parent_class_name
+      @registry = registry || ClassNameRegistry.new
+      @generated_classes = []
+    end
+
+    def generate
+      imports = "import UIKit\n\n"
+      generate_class(@json, @parent_class_name)
+      imports + @generated_classes.reverse.join("\n\n")
+    end
+
+    private
+
+    def generate_class(json_obj, class_name)
+      @registry.register(class_name, class_name)
+      class_name = @registry.get_class_name(class_name, class_name)
+      return if @generated_classes.any? { |c| c.include?("struct #{class_name}") }
+
+      properties = []
+      static_values = []
+
+      json_obj.each do |key, value|
+        nested_class_name = "#{class_name}#{StringCase.capitalize(key)}"
+        @registry.register(nested_class_name, nested_class_name)
+        nested_class_name = @registry.get_class_name(nested_class_name, nested_class_name)
+
+        type = determine_type(value, nested_class_name, "#{class_name}.#{key}")
+
+        if value.is_a?(Hash)
+          generate_class(value, nested_class_name)
+          static_values << "private static let #{key}Value = #{nested_class_name}.shared"
+        elsif value.is_a?(Array) && !value.empty? && value.first.is_a?(Hash)
+          generate_class(value.first, nested_class_name)
+          type = "[#{nested_class_name}]"
+          list_values = value.map { |_| "#{nested_class_name}.shared" }
+          static_values << "private static let #{key}Value = [#{list_values.join(", ")}]"
+        else
+          static_values << "private static let #{key}Value = #{swift_value(value)}"
+        end
+
+        properties << "let #{key}: #{type}"
+      end
+
+      class_code = <<~SWIFT
+        struct #{class_name} {
+            #{properties.join("\n    ")}
+
+            private static var _shared: #{class_name}?
+
+            #{static_values.join("\n    ")}
+
+            static var shared: #{class_name} {
+                if _shared == nil {
+                    _shared = #{class_name}(
+                        #{json_obj.keys.map { |key| "#{key}: #{key}Value" }.join(",\n                      ")}
+                    )
+                }
+                return _shared!
+            }
+        }
+      SWIFT
+
+      @generated_classes << class_code
+    end
+
+    def determine_type(value, class_name, registry_key)
+      base_type = if value.is_a?(String) && ColorDetector.new(value).color?
+        "UIColor"
+      elsif value.is_a?(String)
+        "String"
+      elsif value.is_a?(Integer)
+        "Int"
+      elsif value.is_a?(Float)
+        "Double"
+      elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        "Bool"
+      elsif value.is_a?(Array)
+        item_type = value.empty? ? "Any" : determine_type(value.first, class_name, "#{registry_key}[]")
+        "[#{item_type}]"
+      elsif value.is_a?(Hash)
+        class_name
+      else
+        "Any"
+      end
+
+      @registry.get_type(value, base_type)
+    end
+
+    def swift_value(value)
+      if value.is_a?(String) && ColorDetector.new(value).color?
+        hex = value.gsub('#', '')
+        r = "Double(0x#{hex[0,2]}) / 255.0"
+        g = "Double(0x#{hex[2,2]}) / 255.0"
+        b = "Double(0x#{hex[4,2]}) / 255.0"
+        a = hex.length == 8 ? "Double(0x#{hex[6,2]}) / 255.0" : "1.0"
+        return "UIColor(red: #{r}, green: #{g}, blue: #{b}, alpha: #{a})"
+      end
+      return "\"#{value}\"" if value.is_a?(String)
+      return value.to_s if value.is_a?(Integer) || value.is_a?(Float)
+      return value.to_s.downcase if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      return "[#{value.map { |v| swift_value(v) }.join(", ")}]" if value.is_a?(Array)
+      return "nil" if value.nil?
+      value.to_s
+    end
+end

data/solara/lib/core/scripts/color_detector.rb

@@ -0,0 +1,10 @@
+class ColorDetector
+    def initialize(value)
+      @value = value
+    end
+
+    def color?
+      # Check for 6-character (RGB) or 8-character (RGBA) hex color formats
+      @value.is_a?(String) && @value.match?(/^#([0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/)
+    end
+  end

data/solara/lib/solara/version.rb

@@ -1,3 +1,3 @@
 module Solara
-  VERSION = "0.7.2"
+  VERSION = "0.7.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solara
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.7.3
 platform: ruby
 authors:
 - Malek Kamel
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-28 00:00:00.000000000 Z
+date: 2024-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -245,7 +245,12 @@ files:
 - solara/lib/core/scripts/brand_importer.rb
 - solara/lib/core/scripts/brand_offboarder.rb
 - solara/lib/core/scripts/brand_resources_manager.rb
-- solara/lib/core/scripts/code_generator.rb
+- solara/lib/core/scripts/code_generator/class_name_registry.rb
+- solara/lib/core/scripts/code_generator/code_generator.rb
+- solara/lib/core/scripts/code_generator/dart_code_generator.rb
+- solara/lib/core/scripts/code_generator/kotlin_code_generator.rb
+- solara/lib/core/scripts/code_generator/swift_code_generator.rb
+- solara/lib/core/scripts/color_detector.rb
 - solara/lib/core/scripts/directory_creator.rb
 - solara/lib/core/scripts/file_manager.rb
 - solara/lib/core/scripts/file_path.rb

data/solara/lib/core/scripts/code_generator.rb

@@ -1,715 +0,0 @@
-module Language
-  Kotlin = 'kotlin'
-  Swift = 'swift'
-  Dart = 'dart'
-
-  def self.all
-    [Kotlin, Swift, Dart]
-  end
-
-  def self.init(language)
-    if all.include?(language)
-      # Do something with the valid language
-    else
-      raise ArgumentError, "Invalid language. Please use one of: #{all.join(', ')}"
-    end
-  end
-end
-
-class ClassNameRegistry
-  def initialize(custom_types)
-    @custom_types = custom_types
-    @registry = {}
-  end
-
-  def register(original_name, prefixed_name, context = [])
-    full_context = (context + [original_name]).join('.')
-    @registry[full_context] = prefixed_name
-  end
-
-  def get(name, context = [])
-    full_context = (context + [name]).join('.')
-    result = @registry[full_context] || name
-    @custom_types[result] || result
-  end
-
-  def original_names
-    @registry.keys
-  end
-
-  def prefixed_names
-    @registry.values
-  end
-end
-
-class CodeGenerator
-  def initialize(
-    json:,
-    language:,
-    parent_class_name:,
-    custom_types: {}
-  )
-    @json = json
-    @language = language
-    @parent_class_name = parent_class_name
-    @custom_types = custom_types
-    @generator = create_language_generator
-  end
-
-  def generate
-    @generator.generate_content
-  end
-
-  private
-
-  def create_language_generator
-    case @language
-    when Language::Kotlin
-      KotlinCodeGenerator.new(@json, @parent_class_name, @custom_types)
-    when Language::Swift
-      SwiftCodeGenerator.new(@json, @parent_class_name, @custom_types)
-    when Language::Dart
-      DartCodeGenerator.new(@json, @parent_class_name, @custom_types)
-    else
-      raise ArgumentError, "Unsupported language: #{@language}"
-    end
-  end
-end
-
-class BaseCodeGenerator
-  def initialize(json, parent_class_name, custom_types)
-    @parent_class_name = parent_class_name
-    @json = json
-    @custom_types = custom_types
-    @class_registry = ClassNameRegistry.new(custom_types)
-    register_class_names(@parent_class_name, @json)
-  end
-
-  def generate_content
-    content = "// Generated by Solara\n"
-    content += language_specific_imports
-
-    classes = []
-    generate_classes(@parent_class_name, @json, classes, generate_json: true)
-
-    classes.reverse_each do |class_content|
-      content += class_content
-      content += "\n"
-    end
-
-    other_classes = language_specific_classes
-    other_classes.each do |item|
-      content += item
-    end
-
-    content + "\n"
-  end
-
-  private
-
-  def register_class_names(class_name, json, context = [])
-    full_context = context + [class_name]
-    prefixed_name = full_context.join
-    @class_registry.register(class_name, prefixed_name, context)
-
-    json.each do |key, value|
-      if value.is_a?(Hash)
-        nested_class_name = capitalize(key)
-        register_class_names(nested_class_name, value, full_context)
-      elsif value.is_a?(Array) && value.any? { |item| item.is_a?(Hash) }
-      nested_class_name = "#{capitalize(key)}Item"
-        register_class_names(nested_class_name, value.first, full_context)
-      end
-    end
-  end
-
-  def generate_classes(class_name, json, classes, context = [], generate_json: false)
-    full_context = context + [class_name]
-    prefixed_class_name = @class_registry.get(class_name, context)
-    content = class_declaration(prefixed_class_name)
-    constructor_params = []
-
-    json.each do |key, value|
-      type = value_type(value, key, full_context)
-      content += property_declaration(key, type, json)
-      constructor_params << constructor_parameter(key, type)
-    end
-
-    content += property_declaration("asJson", "String", json)
-
-    content += constructor_declaration(prefixed_class_name, constructor_params)
-    content += instance_declaration(prefixed_class_name, json, full_context)
-    content += json_methods(json, prefixed_class_name, full_context)
-    content += class_closing
-
-    classes << content
-
-    json.each do |key, value|
-      if value.is_a?(Hash)
-        nested_class_name = capitalize(key)
-        generate_classes(nested_class_name, value, classes, full_context)
-      elsif value.is_a?(Array) && value.any? { |item| item.is_a?(Hash) }
-      nested_class_name = "#{capitalize(key)}Item"
-        generate_classes(nested_class_name, value.first, classes, full_context)
-      end
-    end
-  end
-
-  def class_declaration(class_name)
-    raise NotImplementedError, "Subclasses must implement class_declaration"
-  end
-
-  def property_declaration(key, type, json)
-    raise NotImplementedError, "Subclasses must implement property_declaration"
-  end
-
-  def color_type
-    raise NotImplementedError, "Subclasses must implement property_declaration"
-  end
-
-  def constructor_parameter(key, type)
-    raise NotImplementedError, "Subclasses must implement constructor_parameter"
-  end
-
-  def constructor_declaration(class_name, params)
-    raise NotImplementedError, "Subclasses must implement constructor_declaration"
-  end
-
-  def instance_declaration(class_name, json, context)
-    raise NotImplementedError, "Subclasses must implement instance_declaration"
-  end
-
-  def json_methods(json, class_name, context)
-    raise NotImplementedError, "Subclasses must implement json_methods"
-  end
-
-  def class_closing
-    raise NotImplementedError, "Subclasses must implement class_closing"
-  end
-
-  def language_specific_imports
-    raise NotImplementedError, "Subclasses must implement language_specific_imports"
-  end
-
-  def value_type(value, class_prefix, context = [])
-    raise NotImplementedError, "Subclasses must implement value_type"
-  end
-
-  def value_for(value, class_prefix, indent, context = [])
-    raise NotImplementedError, "Subclasses must implement value_for"
-  end
-
-  def color_for(value)
-    raise NotImplementedError, "Subclasses must implement color_for"
-  end
-
-  def language_specific_null
-    raise NotImplementedError, "Subclasses must implement language_specific_null"
-  end
-
-  def language_specific_classes
-    []
-  end
-
-  def capitalize(string)
-    StringCase.capitalize(string)
-  end
-end
-
-class KotlinCodeGenerator < BaseCodeGenerator
-  def language_specific_imports
-    "import android.graphics.Color\n" +
-    "import java.io.Serializable\n\n"
-  end
-
-  def class_declaration(class_name)
-    "\ndata class #{class_name}(\n"
-  end
-
-  def property_declaration(key, type, json)
-    if key == "asJson"
-      json_string = json.to_json.gsub('"', '\\"')
-      "  val #{key}: String = \"#{json_string}\",\n"
-    elsif json[key].is_a?(String) && ColorDetector.new(json[key]).color?
-      "  val #{key}: #{color_type},\n"
-    else
-      "  val #{key}: #{type},\n"
-    end
-  end
-
-  def color_type
-    "Int"
-  end
-
-  def constructor_parameter(key, type)
-    "val #{key}: #{type}"
-  end
-
-  def constructor_declaration(class_name, params)
-    "): Serializable {\n"
-  end
-
-  def instance_declaration(class_name, json, context)
-    "  companion object {\n    val instance = #{class_name}(\n#{json.map { |k, v| "      #{k} = #{value_for(v, k, '      ', context)}" }.join(",\n")}\n    )\n  }\n"
-  end
-
-  def json_methods(json, class_name, context)
-    ""
-  end
-
-  def class_closing
-    "}\n"
-  end
-
- def value_for(value, class_prefix, indent, context = [])
-  case value
-  when String
-    if ColorDetector.new(value).color?
-      color_for(value)
-    else
-      "\"#{value}\""  # Use double quotes for Kotlin strings
-    end
-  when Integer
-    value.to_s
-  when Float
-    "#{value}F"  # Add 'F' suffix for float values
-  when TrueClass, FalseClass
-    value.to_s
-  when Array
-    if value.empty?
-      "emptyList()"  # Use Kotlin's emptyList() for empty arrays
-    elsif value.all? { |item| item.is_a?(Hash) }
-      array_items = value.map do |item|
-        item_values = item.map { |k, v| "#{k} = #{value_for(v, k, indent + '    ')}" }.join(",\n#{indent}    ")
-        "#{@class_registry.get("#{capitalize(class_prefix)}Item")}(\n#{indent}    #{item_values}\n#{indent}  )"
-      end.join(",\n#{indent}  ")
-      "listOf(\n#{indent}  #{array_items}\n#{indent})"
-    else
-      array_items = value.map { |item| value_for(item, class_prefix, indent + '  ') }.join(", ")
-      "listOf(\n#{indent}  #{array_items}\n#{indent})"  # Use listOf for non-empty lists
-    end
-  when Hash
-    "#{@class_registry.get(capitalize(class_prefix), context)}.instance"
-  else
-    language_specific_null
-  end
-end
-
-  def value_type(value, class_prefix, context = [])
-    case value
-    when String
-      if ColorDetector.new(value).color?
-        return color_type
-      end
-      return 'String'
-    when Integer then 'Int'
-    when Float then 'Float'
-    when TrueClass, FalseClass then 'Boolean'
-    when Array
-      if value.empty?
-        'List<Any>'
-      elsif value.all? { |item| item.is_a?(String) }
-        'List<String>'
-      elsif value.all? { |item| item.is_a?(Integer) }
-        'List<Int>'
-      elsif value.all? { |item| item.is_a?(Float) }
-        'List<Float>'
-      elsif value.all? { |item| item.is_a?(TrueClass) || item.is_a?(FalseClass) }
-        'List<Boolean>'
-      elsif value.all? { |item| item.is_a?(Hash) }
-      "List<#{@class_registry.get("#{capitalize(class_prefix)}Item")}>"
-      else
-        'List<Any>'
-      end
-    when Hash then @class_registry.get(capitalize(class_prefix), context)
-    else 'Any'
-    end
-  end
-
-  def color_for(value)
-    "Color.parseColor(\"#{value}\")"
-  end
-
-  def language_specific_null
-    "null"
-  end
-end
-
-class SwiftCodeGenerator < BaseCodeGenerator
-  def language_specific_imports
-    "import Foundation\n" +
-    "import UIKit\n\n"
-  end
-
-  def class_declaration(class_name)
-    "\nclass #{class_name}: Codable {\n"
-  end
-
-  def property_declaration(key, type, json)
-    if key == "asJson"
-      json_string = json.to_json.gsub('"', '\\"')
-      "  let #{key}: String = \"#{json_string}\"\n"
-    elsif json[key].is_a?(String) && ColorDetector.new(json[key]).color?
-      "  let #{key}: #{color_type}\n"
-    else
-      "  let #{key}: #{type}\n"
-    end
-  end
-
-  def color_type
-    "UIColor"
-  end
-
-  def constructor_parameter(key, type)
-    "#{key}: #{type}"
-  end
-
-  def constructor_declaration(class_name, params)
-    "  init(#{params.join(", ")}) {\n" +
-    params.map { |param| "    self.#{param.split(":").first} = #{param.split(":").first}" }.join("\n") +
-    "\n  }\n\n"
-  end
-
-  def instance_declaration(class_name, json, context)
-    "  static let shared = #{class_name}(\n" +
-    json.map { |k, v| "    #{k}: #{value_for(v, k, '    ', context)}" }.join(",\n") +
-    "\n  )\n\n"
-  end
-
-  def json_methods(json, class_name, context)
-    prefixed_class_name = @class_registry.get(capitalize(class_name))
-    coding_keys = json.map { |key, _| "    case #{key}" }.join("\n")
-
-    <<-SWIFT
-  private enum CodingKeys: String, CodingKey {
-  #{coding_keys}
-  }
-
-  func toJson() -> String? {
-    let encoder = JSONEncoder()
-    if let jsonData = try? encoder.encode(self) {
-      return String(data: jsonData, encoding: .utf8)
-    }
-    return nil
-  }
-
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: CodingKeys.self)
-    #{json.map { |key, value|
-      if value.is_a?(String) && ColorDetector.new(value).color?
-        "self.#{key} = UIColor(hex: try container.decode(String.self, forKey: .#{key}))"
-      else
-        "self.#{key} = try container.decode(#{value_type(value, key, context)}.self, forKey: .#{key})"
-      end
-    }.join("\n    ")}
-  }
-
-  func encode(to encoder: Encoder) throws {
-    var container = encoder.container(keyedBy: CodingKeys.self)
-    #{json.map { |key, value|
-     if value.is_a?(String) && ColorDetector.new(value).color?
-        "try container.encode(#{key}.toHexString(), forKey: .#{key})"
-      else
-        "try container.encode(#{key}, forKey: .#{key})"
-      end
-    }.join("\n    ")}
-  }
-
-  static func fromJson(_ json: String) -> #{prefixed_class_name}? {
-    let decoder = JSONDecoder()
-    if let jsonData = json.data(using: .utf8),
-       let result = try? decoder.decode(#{prefixed_class_name}.self, from: jsonData) {
-      return result
-    }
-    return nil
-  }
-    SWIFT
-  end
-
-  def class_closing
-    "}\n"
-  end
-
-  def value_for(value, class_prefix, indent, context = [])
-    case value
-    when String
-      if ColorDetector.new(value).color?
-        color_for(value)
-      else
-        "\"#{value}\""
-      end
-    when Integer, Float
-      value.to_s
-    when TrueClass, FalseClass
-      value.to_s
-    when Array
-      if value.empty?
-        "[]"
-      elsif value.all? { |item| item.is_a?(Hash) }
-        array_items = value.map do |item|
-          item_values = item.map { |k, v| "#{k}: #{value_for(v, k, indent + '    ')}" }.join(",\n#{indent}    ")
-          "#{@class_registry.get("#{capitalize(class_prefix)}Item")}(\n#{indent}    #{item_values}\n#{indent}  )"
-        end.join(",\n#{indent}  ")
-        "[\n#{indent}  #{array_items}\n#{indent}]"
-      else
-        array_items = value.map { |item| value_for(item, class_prefix, indent + '  ') }.join(", ")
-        "[\n#{indent}  #{array_items}\n#{indent}]"
-      end
-    when Hash
-      "#{@class_registry.get(capitalize(class_prefix), context)}.shared"
-    else
-      language_specific_null
-    end
-  end
-
-  def value_type(value, class_prefix, context = [])
-    case value
-    when String
-      if ColorDetector.new(value).color?
-        return color_type
-      end
-      return 'String'
-    when Integer then 'Int'
-    when Float then 'Double'
-    when TrueClass, FalseClass then 'Bool'
-    when Array
-      if value.empty?
-        '[Any]'
-      elsif value.all? { |item| item.is_a?(String) }
-        '[String]'
-      elsif value.all? { |item| item.is_a?(Integer) }
-        '[Int]'
-      elsif value.all? { |item| item.is_a?(Float) }
-        '[Double]'
-      elsif value.all? { |item| item.is_a?(TrueClass) || item.is_a?(FalseClass) }
-        '[Bool]'
-      elsif value.all? { |item| item.is_a?(Hash) }
-        "[#{@class_registry.get("#{capitalize(class_prefix)}Item")}]"
-      else
-        '[Any]'
-      end
-    when Hash then @class_registry.get(capitalize(class_prefix), context)
-    else 'Any'
-    end
-  end
-
-  def color_for(value)
-    "UIColor(hex: \"#{value}\")"
-  end
-
-  def language_specific_null
-    "nil"
-  end
-
-  def language_specific_classes
-    [
-      <<-SWIFT
-private extension UIColor {
-    convenience init(hex: String) {
-        let hex = hex.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
-        var int = UInt64()
-        Scanner(string: hex).scanHexInt64(&int)
-        let a, r, g, b: UInt64
-        switch hex.count {
-        case 3: // RGB (12-bit)
-            (a, r, g, b) = (255, (int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
-        case 6: // RGB (24-bit)
-            (a, r, g, b) = (255, int >> 16, int >> 8 & 0xFF, int & 0xFF)
-        case 8: // ARGB (32-bit)
-            (a, r, g, b) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
-        default:
-            (a, r, g, b) = (255, 0, 0, 0)
-        }
-        self.init(red: CGFloat(r) / 255, green: CGFloat(g) / 255, blue: CGFloat(b) / 255, alpha: CGFloat(a) / 255)
-    }
-
-    func toHexString() -> String {
-        var r:CGFloat = 0
-        var g:CGFloat = 0
-        var b:CGFloat = 0
-        var a:CGFloat = 0
-
-        getRed(&r, green: &g, blue: &b, alpha: &a)
-
-        let rgb:Int = (Int)(r*255)<<16 | (Int)(g*255)<<8 | (Int)(b*255)<<0
-
-        return String(format: "#%06x", rgb)
-    }
-}
-      SWIFT
-    ]
-  end
-end
-
-class DartCodeGenerator < BaseCodeGenerator
-  def language_specific_imports
-    "import 'dart:convert';\n" +
-    "import 'package:flutter/material.dart';\n\n"
-  end
-
-  def class_declaration(class_name)
-    "\nclass #{class_name} {\n"
-  end
-
-  def property_declaration(key, type, json)
-    if key == "asJson"
-      json_string = json.to_json.gsub('"', '\\"')
-      "  final String #{key} = \"#{json_string}\";\n"
-    elsif json[key].is_a?(String) && ColorDetector.new(json[key]).color?
-      "  final #{color_type} #{key};\n"
-    else
-      "  final #{type} #{key};\n"
-    end
-  end
-
-  def color_type
-    "Color"
-  end
-
-  def constructor_parameter(key, type)
-    "\n     required this.#{key}"
-  end
-
-  def constructor_declaration(class_name, params)
-    "  const #{class_name}({#{params.join(", ")}});\n\n"
-  end
-
-  def instance_declaration(class_name, json, context)
-    "  static const #{class_name} instance = #{class_name}(\n" +
-    json.map { |k, v| "    #{k}: #{value_for(v, k, '    ', context)}" }.join(",\n") +
-    "\n  );\n\n"
-  end
-
-  def json_methods(json, class_name, context)
-    prefixed_class_name = @class_registry.get(class_name)
-    from_json_content = json.map do |key, value|
-      if value.is_a?(String) && ColorDetector.new(value).color?
-        "      #{key}: Color(int.parse(json['#{key}'].substring(1, 7), radix: 16) + 0xFF000000)"
-      else
-        "      #{key}: json['#{key}']"
-      end
-    end.join(",\n")
-
-    to_json_content = json.map do |key, value|
-      if value.is_a?(String) && ColorDetector.new(value).color?
-        "'#{key}': '#${#{key}.value.toRadixString(16).padLeft(8, '0').substring(2)}'"
-      else
-        "'#{key}': #{key}"
-      end
-    end.join(",\n      ")
-
-    <<-DART
-  factory #{prefixed_class_name}.fromJson(Map<String, dynamic> json) {
-    return #{prefixed_class_name}(
-#{from_json_content}
-    );
-  }
-
-  Map<String, dynamic> toJson() {
-    return {
-      #{to_json_content}
-    };
-  }
-
-  String toJsonString() {
-    return json.encode(toJson());
-  }
-
-  static #{prefixed_class_name}? fromJsonString(String jsonString) {
-    try {
-      final Map<String, dynamic> jsonMap = json.decode(jsonString);
-      return #{prefixed_class_name}.fromJson(jsonMap);
-    } catch (e) {
-      print('Error parsing JSON: $e');
-      return null;
-    }
-  }
-    DART
-  end
-
-  def class_closing
-    "}\n"
-  end
-
-  def value_for(value, class_prefix, indent, context = [])
-    case value
-    when String
-      if ColorDetector.new(value).color?
-        color_for(value)
-      else
-        "\"#{value}\""
-      end
-    when Integer, Float
-      value.to_s
-    when TrueClass, FalseClass
-      value.to_s
-    when Array
-      if value.empty?
-        "[]"
-      elsif value.all? { |item| item.is_a?(Hash) }
-        array_items = value.map do |item|
-          item_values = item.map { |k, v| "#{k}: #{value_for(v, k, indent + '    ')}" }.join(",\n#{indent}    ")
-          "#{@class_registry.get("#{capitalize(class_prefix)}Item")}(\n#{indent}    #{item_values}\n#{indent}  )"
-        end.join(",\n#{indent}  ")
-        "[\n#{indent}  #{array_items}\n#{indent}]"
-      else
-        array_items = value.map { |item| value_for(item, class_prefix, indent + '  ') }.join(", ")
-        "[\n#{indent}  #{array_items}\n#{indent}]"
-      end
-    when Hash
-      "#{@class_registry.get(capitalize(class_prefix), context)}.instance"
-    else
-      language_specific_null
-    end
-  end
-
-  def value_type(value, class_prefix, context = [])
-    case value
-    when String
-      if ColorDetector.new(value).color?
-        return color_type
-      end
-      return 'String'
-    when Integer then 'int'
-    when Float then 'double'
-    when TrueClass, FalseClass then 'bool'
-    when Array
-      if value.empty?
-        'List<dynamic>'
-      elsif value.all? { |item| item.is_a?(String) }
-        'List<String>'
-      elsif value.all? { |item| item.is_a?(Integer) }
-        'List<int>'
-      elsif value.all? { |item| item.is_a?(Float) }
-        'List<double>'
-      elsif value.all? { |item| item.is_a?(TrueClass) || item.is_a?(FalseClass) }
-        'List<bool>'
-      elsif value.all? { |item| item.is_a?(Hash) }
-        "List<#{@class_registry.get("#{capitalize(class_prefix)}Item")}>"
-      else
-        'List<dynamic>'
-      end
-    when Hash then @class_registry.get(capitalize(class_prefix), context)
-    else 'dynamic'
-    end
-  end
-
-  def color_for(value)
-    "Color(0xFF#{value[1..-1]})"
-  end
-
-  def language_specific_null
-    "null"
-  end
-end
-
-class ColorDetector
-  def initialize(value)
-    @value = value
-  end
-
-  def color?
-    # Check for 6-character (RGB) or 8-character (RGBA) hex color formats
-    @value.is_a?(String) && @value.match?(/^#([0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/)
-  end
-end