solara 0.1.0

data/solara/lib/core/doctor/validator/template/flutter_template_validation_config.yml

@@ -0,0 +1,53 @@
+structure:
+    android:
+        type: directory
+        contents:
+            assets:
+                type: directory
+            res:
+                type: directory
+            android_config.json:
+                type: file
+                validations:
+                    - type: valid_json
+                    - type: json_schema
+                      schema_path: platform/android/android_config.json
+            android_signing.json:
+                type: file
+                validations:
+                    - type: valid_json
+                    - type: json_schema
+                      schema_path: platform/android/android_signing.json
+    ios:
+        type: directory
+        contents:
+            assets:
+                type: directory
+            ios_config.json:
+                type: file
+                validations:
+                    - type: valid_json
+                    - type: json_schema
+                      schema_path: platform/ios/ios_config.json
+            ios_signing.json:
+                type: file
+                validations:
+                    - type: valid_json
+                    - type: json_schema
+                      schema_path: platform/ios/ios_signing.json
+    shared:
+        type: directory
+        contents:
+            assets:
+                type: directory
+            brand_config.json:
+                type: file
+                validations:
+                    - type: valid_json
+            theme.json:
+                type: file
+                validations:
+                    - type: valid_json
+                    - type: json_schema
+                      schema_path: platform/shared/theme.json
+strict: false

data/solara/lib/core/doctor/validator/template/ios_template_validation_config.yml

@@ -0,0 +1,51 @@
+structure:
+    android:
+        type: directory
+        contents:
+            assets:
+                type: directory
+            res:
+                type: directory
+            android_config.json:
+                type: file
+                validations:
+                    - type: valid_json
+                    - type: json_schema
+                      schema_path: platform/android/android_config.json
+            android_signing.json:
+                type: file
+                validations:
+                    - type: valid_json
+                    - type: json_schema
+                      schema_path: platform/android/android_signing.json
+    ios:
+        type: directory
+        contents:
+            assets:
+                type: directory
+            ios_config.json:
+                type: file
+                validations:
+                    - type: valid_json
+                    - type: json_schema
+                      schema_path: platform/ios/ios_config.json
+            ios_signing.json:
+                type: file
+                validations:
+                    - type: valid_json
+                    - type: json_schema
+                      schema_path: platform/ios/ios_signing.json
+    shared:
+        type: directory
+        contents:
+            brand_config.json:
+                type: file
+                validations:
+                    - type: valid_json
+            theme.json:
+                type: file
+                validations:
+                    - type: valid_json
+                    - type: json_schema
+                      schema_path: platform/shared/theme.json
+strict: false

data/solara/lib/core/doctor/validator/template/template_validator.rb

@@ -0,0 +1,108 @@
+Dir.glob("#{__dir__}/../../doctor/validator/*.rb").each { |file| require file }
+require 'yaml'
+require 'pathname'
+require 'json'
+require 'json-schema'
+
+class TemplateValidator
+    def initialize(project_path, config_file)
+        @project_path = Pathname.new(project_path)
+        @config = YAML.load_file(config_file)
+    end
+
+    def validate
+        errors = []
+        validate_structure(errors, @project_path, @config['structure'])
+        errors
+    end
+
+    private
+
+    def validate_structure(errors, current_path, expected_structure)
+        expected_structure.each do |name, details|
+            path = current_path.join(name)
+
+            if details.is_a?(Hash)
+                case details['type']
+                when 'directory'
+                    validate_directory(errors, path, details)
+                when 'file'
+                    validate_file(errors, path, details)
+                else
+                    errors << "Unknown type '#{details['type']}' for #{path.relative_path_from(@project_path)}"
+                end
+            end
+        end
+
+        validate_no_extra_files(errors, current_path, expected_structure) if @config['strict']
+    end
+
+    def validate_directory(errors, path, details)
+        unless path.directory?
+            errors << "Missing directory: #{path.relative_path_from(@project_path)}"
+            return
+        end
+        validate_structure(errors, path, details['contents']) if details['contents']
+    end
+
+    def validate_file(errors, path, details)
+        unless path.file?
+            errors << "Missing file: #{path.relative_path_from(@project_path)}"
+            return
+        end
+
+        content = File.read(path)
+
+        details['validations']&.each do |validation|
+            case validation['type']
+            when 'content_includes'
+                unless content.include?(validation['value'])
+                    errors << "File #{path.relative_path_from(@project_path)} does not contain expected content: #{validation['value']}"
+                end
+
+            when 'content_matches'
+                unless content.match?(Regexp.new(validation['value']))
+                    errors << "File #{path.relative_path_from(@project_path)} does not match expected pattern: #{validation['value']}"
+                end
+
+            when 'file_size'
+                size = File.size(path)
+                min_size = validation['min_size']
+                max_size = validation['max_size']
+                if min_size && size < min_size
+                    errors << "File #{path.relative_path_from(@project_path)} is smaller than expected: #{size} < #{min_size} bytes"
+                end
+                if max_size && size > max_size
+                    errors << "File #{path.relative_path_from(@project_path)} is larger than expected: #{size} > #{max_size} bytes"
+                end
+
+            when 'valid_json'
+                begin
+                    JsonFileValidator.new([path]).validate(@project_path)
+                rescue StandardError => e
+                    errors << e.message
+                end
+
+            when 'json_schema'
+                begin
+                    schema_path = File.join(FilePath.schema, validation['schema_path'])
+                    JsonSchemaValidator.new(schema_path, path).validate(@project_path)
+                rescue StandardError => e
+                    errors << e.message
+                end
+
+            else
+                errors << "Unknown validation type '#{validation['type']}' for #{path.relative_path_from(@project_path)}"
+            end
+        end
+    end
+
+    def validate_no_extra_files(errors, current_path, expected_structure)
+        expected_names = expected_structure.keys
+        current_path.children.each do |child|
+            unless expected_names.include?(child.basename.to_s)
+                errors << "Unexpected #{child.directory? ? 'directory' : 'file'}: #{child.relative_path_from(@project_path)}"
+            end
+        end
+    end
+end

data/solara/lib/core/doctor/validator/validation_strategy.rb

@@ -0,0 +1,7 @@
+class ValidationStrategy
+  class ValidationError < StandardError; end
+
+  def validate(project_path)
+    raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+  end
+end

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

@@ -0,0 +1,245 @@
+module Language
+    Kotlin = 'kotlin'
+    Swift = 'swift'
+    Dart = 'dart'
+
+    def self.all
+        [Kotlin, Swift, Dart]
+    end
+end
+
+def init(language)
+    if Language.all.include?(language)
+        # Do something with the valid language
+    else
+        raise ArgumentError, "Invalid language. Please use one of: #{Language.all.join(', ')}"
+    end
+end
+
+class BrandConfigGenerator
+    def initialize(config, output_dir, language, platform)
+        @output_dir = output_dir
+        @language = language
+        @platform = platform
+        @config = config
+    end
+
+    def generate
+        content = generate_config_content
+        FileManager.create_file_if_not_exist(@output_dir)
+        File.write(@output_dir, content)
+        Solara.logger.debug("Generated brand config #{@output_dir} for: #{@language}")
+    end
+
+    private
+
+    def generate_config_content
+        content = "// Generated by Solara\n"
+        content += language_specific_imports
+
+        classes = []
+        generate_classes("BrandConfig", @config, classes)
+
+        classes.reverse_each do |class_content|
+            content += class_content
+            content += "\n"
+        end
+
+        content
+    end
+
+    def language_specific_imports
+        case @language
+        when 'dart'
+            "import 'package:flutter/material.dart';\n\n"
+        when 'kotlin'
+            "import android.graphics.Color\n\n"
+        when 'swift'
+            "import UIKit\n\n"
+        end
+    end
+
+    def generate_classes(class_name, config, classes)
+        content = class_declaration(class_name)
+        constructor_params = []
+
+        config.each do |key, value|
+            type = value_type(value, key)
+            content += property_declaration(key, type)
+            constructor_params << constructor_parameter(key, type)
+        end
+
+        content += constructor_declaration(class_name, constructor_params)
+        content += instance_declaration(class_name, config)
+        content += class_closing
+
+        classes << content
+
+        config.each do |key, value|
+            if value.is_a?(Hash)
+                nested_class_name = "#{key.capitalize}"
+                generate_classes(nested_class_name, value, classes)
+            end
+        end
+    end
+
+    def class_declaration(class_name)
+        case @language
+        when 'dart'
+            "class #{class_name} {\n"
+        when 'kotlin'
+            "data class #{class_name}(\n"
+        when 'swift'
+            "struct #{class_name} {\n"
+        end
+    end
+
+    def property_declaration(key, type)
+        case @language
+        when 'dart'
+            "  final #{type} #{key};\n"
+        when 'kotlin'
+            "  val #{key}: #{type},\n"
+        when 'swift'
+            "  let #{key}: #{type}\n"
+        end
+    end
+
+    def constructor_parameter(key, type)
+        case @language
+        when 'dart'
+            "required this.#{key}"
+        when 'kotlin'
+            "val #{key}: #{type}"
+        when 'swift'
+            "#{key}: #{type}"
+        end
+    end
+
+    def constructor_declaration(class_name, params)
+        case @language
+        when 'dart'
+            params.empty? ? "\n  const #{class_name}();\n\n" : "\n  const #{class_name}({#{params.join(', ')}});\n\n"
+        when 'kotlin'
+            ") {\n"
+        when 'swift'
+            "\n  init(#{params.join(', ')}) {\n#{params.map { |p| "    self.#{p.split(':').first} = #{p.split(':').first}" }.join("\n")}\n  }\n\n"
+        end
+    end
+
+    def instance_declaration(class_name, config)
+        case @language
+        when 'dart'
+            "  static const #{class_name} instance = #{class_name}(\n#{config.map { |k, v| "    #{k}: #{value_for(v, k, '    ')}" }.join(",\n")}\n  );\n"
+        when 'kotlin'
+            "companion object {\n  val instance = #{class_name}(\n#{config.map { |k, v| "    #{k} = #{value_for(v, k, '    ')}" }.join(",\n")}\n  )\n}\n"
+        when 'swift'
+            "  static let shared = #{class_name}(\n#{config.map { |k, v| "    #{k}: #{value_for(v, k, '    ')}" }.join(",\n")}\n  )\n"
+        end
+    end
+
+    def class_closing
+        @language == 'swift' ? "}\n" : "}\n"
+    end
+
+    def value_type(value, class_prefix)
+        case value
+        when String then language_specific_type('String')
+        when Integer then language_specific_type('Int')
+        when Float then language_specific_type('Double')
+        when TrueClass, FalseClass then language_specific_type('Bool')
+        when Array
+            if value.all? { |item| item.is_a?(String) }
+                language_specific_type('Array<String>')
+            elsif value.all? { |item| item.is_a?(Integer) }
+                language_specific_type('Array<Int>')
+            elsif value.all? { |item| item.is_a?(Float) }
+                language_specific_type('Array<Double>')
+            elsif value.all? { |item| item.is_a?(TrueClass) || item.is_a?(FalseClass) }
+                language_specific_type('Array<Bool>')
+            else
+                language_specific_type('Array<Any>')
+            end
+        when Hash then "#{class_prefix.capitalize}"
+        else
+            language_specific_type('Any')
+        end
+    end
+
+    def language_specific_type(type)
+        case @language
+        when 'dart'
+            case type
+            when 'String' then 'String'
+            when 'Int' then 'int'
+            when 'Double' then 'double'
+            when 'Bool' then 'bool'
+            when 'Array<String>' then 'List<String>'
+            when 'Array<Int>' then 'List<int>'
+            when 'Array<Double>' then 'List<double>'
+            when 'Array<Bool>' then 'List<bool>'
+            when 'Array<Any>' then 'List<dynamic>'
+            when 'Any' then 'dynamic'
+            else type
+            end
+        when 'kotlin'
+            case type
+            when 'Array<String>' then 'List<String>'
+            when 'Array<Int>' then 'List<Int>'
+            when 'Array<Double>' then 'List<Double>'
+            when 'Array<Bool>' then 'List<Boolean>'
+            when 'Array<Any>' then 'List<Any>'
+            when 'Any' then 'Any'
+            else type
+            end
+        when 'swift'
+            type
+        end
+    end
+
+    def value_for(value, class_prefix, indent)
+        case value
+        when String
+            if value.start_with?('#') && value.length == 7 # Assume it's a color
+                color_for(value)
+            else
+                value.inspect
+            end
+        when Integer, Float
+            value.to_s
+        when TrueClass, FalseClass
+            value.to_s
+        when Array
+            array_items = value.map { |item| value_for(item, class_prefix, indent + '  ') }.join(', ')
+            "[\n#{indent}  #{array_items}\n#{indent}]"
+        when Hash
+            "#{class_prefix.capitalize}.instance"
+        else
+            language_specific_null
+        end
+    end
+
+    def color_for(value)
+        case @language
+        when 'dart'
+            "Color(0xFF#{value[1..-1]})"
+        when 'kotlin'
+            "Color.parseColor(\"#{value}\")"
+        when 'swift'
+            "UIColor(red: #{hex_to_rgb(value[:red])}, green: #{hex_to_rgb(value[:green])}, blue: #{hex_to_rgb(value[:blue])}, alpha: 1.0)"
+        end
+    end
+
+    def hex_to_rgb(hex)
+        hex.to_i(16) / 255.0
+    end
+
+    def language_specific_null
+        case @language
+        when 'dart', 'swift'
+            'null'
+        when 'kotlin'
+            'null'
+        end
+    end
+end

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

@@ -0,0 +1,90 @@
+Dir.glob("#{__dir__}/../scripts/platform/android/*.rb").each { |file| require file }
+Dir.glob("#{__dir__}/../scripts/platform/ios/*.rb").each { |file| require file }
+
+class BrandConfigManager
+    def initialize(brand_key)
+        @brand_key = brand_key
+    end
+
+    def generate_brand_config(
+        name,
+        language,
+        platform)
+        Solara.logger.start_step("Generate #{language} brand config for #{platform}")
+        config = load_config(FilePath.brand_config(@brand_key))
+        add_basic_brand_info(config, platform)
+        config_generator = BrandConfigGenerator.new(
+            config,
+            FilePath.generated_config(name, platform),
+            language,
+            platform
+        )
+        config_generator.generate
+        Solara.logger.end_step("Generate #{language} brand config for #{platform}")
+    end
+
+    def generate_android_properties
+        generator = PropertiesGenerator.new(@brand_key)
+        generator.generate
+    end
+
+    def generate_ios_xcconfig
+        generator = XcconfigGenerator.new(@brand_key)
+        generator.generate
+    end
+
+    private
+
+    def add_basic_brand_info(config, platform)
+        case platform
+        when Platform::Flutter
+            add_android_info(config, prefix: 'android')
+            add_ios_info(config, prefix: 'iOS')
+        when Platform::Android
+            add_android_info(config)
+        when Platform::IOS
+            add_ios_info(config)
+        else
+            raise ArgumentError, "Invalid platform: #{@platform}"
+        end
+    end
+
+    def add_android_info(config, prefix: '')
+        android_config = load_config(FilePath.android_config(@brand_key))
+        config_mappings = {
+            'brandName' => 'BrandName',
+            'applicationId' => 'ApplicationId',
+            'versionName' => 'VersionName',
+            'versionCode' => 'VersionCode'
+        }
+
+        add_config_info(config, android_config, config_mappings, prefix)
+    end
+
+    def add_ios_info(config, prefix: '')
+        ios_config = load_config(FilePath.ios_config(@brand_key))
+        config_mappings = {
+            'PRODUCT_NAME' => 'ProductName',
+            'PRODUCT_BUNDLE_IDENTIFIER' => 'BundleIdentifier',
+            'MARKETING_VERSION' => 'MarketingVersion',
+            'BUNDLE_VERSION' => 'BundleVersion'
+        }
+
+        add_config_info(config, ios_config, config_mappings, prefix)
+    end
+
+    def add_config_info(config, source_config, mappings, prefix)
+        mappings.each do |source_key, target_key|
+            key = if prefix.empty?
+                      target_key[0].downcase + target_key[1..]
+                  else
+                      "#{prefix}#{target_key}"
+                  end
+            config[key] = source_config[source_key]
+        end
+    end
+
+    def load_config(file_path)
+        JSON.parse(File.read(file_path))
+    end
+end

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

@@ -0,0 +1,38 @@
+require 'json'
+require 'fileutils'
+
+class BrandExporter
+
+    def start(brand_keys, path)
+        if !path.nil? && !path.strip.empty? && !File.directory?(path)
+            Solara.logger.failure("#{path} is not a directory. Please specify a valid directory.")
+            return
+        end
+
+        directory = path || FilePath.project_root
+
+        brand_keys.each do |brand_key|
+            export(brand_key, directory)
+        end
+    end
+
+    private
+
+    def export(brand_key, directory)
+        if BrandsManager.instance.find(brand_key).nil?
+            Solara.logger.failure("#{brand_key} doesn't exist!")
+            return
+        end
+        
+        brand = BrandsManager.instance.brand_with_configurations(brand_key)
+        json = JSON.pretty_generate(brand)
+        json_file_path = File.join(directory, "#{brand_key}-solara-configurations.json")
+
+        # Create the file if it does not exist
+        File.open(json_file_path, 'w') do |file|
+            file.write(json)
+        end
+
+        Solara.logger.success("Successfully exported brand #{brand_key} to: #{json_file_path}")
+    end
+end

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

@@ -0,0 +1,84 @@
+require 'json'
+require 'fileutils'
+
+class BrandImporter
+
+    def start(configurations_paths)
+
+        configurations_paths.each do |path|
+            import(path)
+        end
+
+    end
+
+    private
+
+    def import(configurations_path)
+        unless File.exist?(configurations_path)
+            Solara.logger.failure("#{configurations_path} doesn't exist!")
+            return
+        end
+        
+        unless File.file?(configurations_path)
+            Solara.logger.failure("#{configurations_path} is not configurations file!")
+            return
+        end
+
+        validate_json(configurations_path)
+        validate_json_schema(configurations_path)
+
+        configurations_json = JSON.parse(File.read(configurations_path))
+        brand = configurations_json['brand']
+        brand_key = brand['key'] # Ensure to use 'key' instead of 'brand_key'
+
+        exists = BrandsManager.instance.exists(brand_key)
+        unless exists
+            SolaraManager.new.onboard(brand_key, brand['name'], open_dashboard: false)
+        end
+
+        update_brand(brand_key, configurations_json)
+
+        message_suffix = exists ? "The existing brand '#{brand_key}' has been updated." : "A new brand with the key '#{brand_key}' has been onboarded."
+        Solara.logger.success("Successfully imported (#{configurations_path}). #{message_suffix}")
+    end
+
+    def update_brand(brand_key, configurations_json)
+        brand_path = FilePath.brand(brand_key)
+
+        configurations_json['configurations'].each do |configuration|
+            file_name = "#{configuration['key']}.json"
+            file_path = find_file_in_subdirectories(brand_path, file_name)
+
+            # Create or replace the contents of the configuration file
+            if file_path
+                File.write(file_path, JSON.pretty_generate(configuration['content']))
+            else
+                Solara.logger.failure("File #{file_name} not found in #{brand_path}, ignoring it!")
+            end
+        end
+    end
+
+    def find_file_in_subdirectories(base_path, file_name)
+        Dir.glob(File.join(base_path, '**', file_name)).first
+    end
+
+    def validate_json(configurations_path)
+        begin
+            JsonFileValidator.new([configurations_path]).validate
+        rescue StandardError => e
+            Solara.logger.fatal(e.message)
+            exit 1
+        end
+    end
+
+    def validate_json_schema(configurations_path)
+        begin
+            schema_path = FilePath.brand_configurations_schema
+            JsonSchemaValidator.new(schema_path, configurations_path).validate
+        rescue StandardError => e
+            Solara.logger.fatal(e.message)
+            exit 1
+        end
+    end
+
+end