solara 0.1.0

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

@@ -0,0 +1,110 @@
+Dir.glob("#{__dir__}/*.rb").each { |file| require file }
+
+require 'json'
+require 'fileutils'
+
+class InteractiveFileSystemValidator
+    def initialize(project_root, settings_manager)
+        @project_root = project_root
+        @settings_manager = settings_manager
+    end
+
+    def start(file_system)
+        validate(file_system)
+    end
+
+    def validate(file_system)
+        file_system.each do |item|
+            key = item[:key]
+            name = item[:name]
+            type = item[:type]
+            platform = item[:platform]
+            item_path = item.fetch(:path, '')
+            recursive = item.fetch(:recursive, true)
+
+            value = @settings_manager.value(key, platform)
+
+            if value
+                # Check if the item exists and is of the correct type
+                if type == 'file' && !File.file?(value)
+                    Solara.logger.failure("Missing file: #{key} (#{value})")
+                    validate_required_item(item)
+                elsif type == 'folder' && !File.directory?(value)
+                    Solara.logger.failure("Missing folder: #{key} (#{value})")
+                    validate_required_item(item)
+                end
+            else
+                ignored = %w[solara/ Artifacts/ Pods/ build/]
+
+                root = File.join(@project_root, item_path)
+                paths = if recursive
+                            FileManager.find_files_by_name(root, name)
+                        else
+                            Dir.glob(File.join(root, name)).select { |path| File.file?(path) || File.directory?(path) }
+                        end
+
+                paths = paths.map { |path| FileManager.get_relative_path(@project_root, path) }
+                             .reject { |path| ignored.any? { |ignored_path| path.include?(ignored_path) } }
+
+                case paths.size
+                when 0
+                    Solara.logger.failure("Missing #{type}: #{key}")
+                    validate_required_item(item)
+                when 1
+                    @settings_manager.add(key, paths.first, platform)
+
+                    Solara.logger.debug("Added #{type}: #{key} (#{paths.first})")
+                else
+                    Solara.logger.failure("Found multiple paths for #{key}:\n\t- #{paths.join("\n\t- ")}")
+                    validate_required_item(item)
+                end
+            end
+        end
+    end
+
+    private
+
+    def validate_required_item(item)
+        item_key = item[:key]
+        item_type = item[:type]
+        platform = item[:platform]
+        item_path = ''
+
+        loop do
+            item_path = get_path_from_user(item_key, item_type)
+            break if validate_item(item_path, item_key, item_type)
+        end
+        value = FileManager.get_relative_path(@project_root, item_path)
+        @settings_manager.add(item_key, value, platform)
+    end
+
+    def validate_item(item_path, item_name, item_type)
+        return false if item_path.nil? || !item_path.end_with?(item_name)
+
+        case item_type
+        when 'file'
+            if File.file?(item_path)
+                Solara.logger.debug("File exists: #{item_path}")
+                true
+            else
+                Solara.logger.failure("File does not exist: #{item_path}")
+                false
+            end
+        when 'folder'
+            if File.directory?(item_path)
+                true
+            else
+                Solara.logger.failure("Folder does not exist: #{item_path}")
+                false
+            end
+        else
+            Solara.logger.failure("Invalid item type: #{item_type}")
+            false
+        end
+    end
+
+    def get_path_from_user(item_key, item_type)
+        print "Enter the relative path for #{item_key}): "
+        STDIN.gets.chomp
+    end
+end

data/solara/lib/core/scripts/platform/android/android_manifest_switcher.rb

@@ -0,0 +1,24 @@
+class AndroidManifestSwitcher
+    def initialize
+    end
+
+    def update_manifest(config)
+        Solara.logger.start_step("Update AndroidManifest")
+        manifest_file = FilePath.android_manifest
+        if File.exist?(manifest_file)
+            manifest_content = File.read(manifest_file)
+            updated_manifest = update_app_name(manifest_content, config)
+            File.write(manifest_file, updated_manifest)
+            Solara.logger.debug("Updated #{FilePath.android_manifest} to use string resource for app name")
+        else
+            Solara.logger.debug("❌ #{FilePath.android_manifest} not found. Skipping manifest update.")
+        end
+        Solara.logger.end_step("Update AndroidManifest")
+    end
+
+    private
+
+    def update_app_name(manifest_content, config)
+        manifest_content.gsub(/android:label="[^"]+"/, 'android:label="@string/app_name"')
+    end
+end

data/solara/lib/core/scripts/platform/android/android_strings_switcher.rb

@@ -0,0 +1,39 @@
+class AndroidStringsSwitcher
+    def initialize
+    end
+
+    def update(config)
+        Solara.logger.start_step("Generate artifacts/strings.xml")
+        strings_file = FilePath.android_artifacts_strings
+
+        # Create the file if it doesn't exist
+        unless File.exist?(strings_file)
+            FileUtils.mkdir_p(File.dirname(strings_file))
+        end
+
+        strings_content = generate_strings_xml_content(config)
+        File.write(strings_file, strings_content)
+        Solara.logger.debug("Updated #{strings_file} with name: \"#{config['brandName']}\"")
+
+        remove_app_name_from_strings
+        Solara.logger.end_step("Generate artifacts/strings.xml")
+    end
+
+    # It's important to delete app_name to avoid duplicate resources
+    def remove_app_name_from_strings
+        file_path = FilePath.android_strings
+        manager = StringsXmlManager.new(file_path)
+        manager.delete_app_name
+    end
+
+    private
+
+    def generate_strings_xml_content(config)
+        <<-XML
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">#{config['brandName']}</string>
+</resources>
+        XML
+    end
+end

data/solara/lib/core/scripts/platform/android/gradle_switcher.rb

@@ -0,0 +1,233 @@
+require 'fileutils'
+require 'json'
+
+class GradleSwitcher
+    KOTLIN_IMPORTS = <<-KOTLIN
+import java.io.FileInputStream
+import java.util.Properties
+
+    KOTLIN
+
+    KOTLIN_PROPERTIES_LOADER = <<-KOTLIN
+val brandProperties = Properties().apply {
+    load(FileInputStream(file("../artifacts/brand.properties")))
+}
+    KOTLIN
+
+    GROOVY_PROPERTIES_LOADER = <<-GROOVY
+project.ext {
+    brandProperties = new Properties()
+    brandProperties.load(new FileInputStream(file("../artifacts/brand.properties")))
+}
+    GROOVY
+
+    KOTLIN_APPLICATION_ID = 'applicationId = brandProperties.getProperty("applicationId")'
+    GROOVY_APPLICATION_ID = "applicationId = project.ext.brandProperties.getProperty('applicationId')"
+
+    KOTLIN_VERSION_NAME = 'versionName = brandProperties.getProperty("versionName")'
+    GROOVY_VERSION_NAME = "versionName = project.ext.brandProperties.getProperty('versionName')"
+
+    KOTLIN_VERSION_CODE = 'versionCode = brandProperties.getProperty("versionCode").toInt()'
+    GROOVY_VERSION_CODE = "versionCode = project.ext.brandProperties.getProperty('versionCode').toInteger()"
+
+    DEFAULT_SOURCE_SETS = %w[src/main/res src/main/artifacts]
+
+    def initialize(brand_key)
+        @brand_key = brand_key
+        @is_kotlin_gradle = FilePath.is_koltin_gradle
+        @brand_config = JSON.parse(File.read(FilePath.android_config(brand_key)))
+        @source_sets = (@brand_config['sourceSets'] || []).concat(DEFAULT_SOURCE_SETS).uniq
+    end
+
+    def update_build_gradle
+        Solara.logger.start_step("Update app/build.gradle")
+        gradle_file = FilePath.android_app_gradle
+        gradle_content = File.read(gradle_file)
+
+        update_gradle(gradle_file, gradle_content)
+        add_source_sets(gradle_file)
+        update_keystore_config(gradle_file)
+        Solara.logger.end_step("Update app/build.gradle")
+    end
+
+    private
+
+    def update_gradle(gradle_file, gradle_content)
+        properties_loader = @is_kotlin_gradle ? KOTLIN_PROPERTIES_LOADER : GROOVY_PROPERTIES_LOADER
+
+        if @is_kotlin_gradle
+            # Add imports for Kotlin
+            unless gradle_content.include?("import java.io.FileInputStream")
+                insert_position = gradle_content.index(/\s*(plugins|android)\s*{/)
+                if insert_position.nil?
+                    raise "Could not find a suitable position to insert imports in #{FilePath.gradle_name}"
+                end
+                gradle_content.insert(insert_position, KOTLIN_IMPORTS)
+            end
+        end
+
+        insert_position = gradle_content.index(/\s*android\s*{/)
+        if insert_position.nil?
+            raise "Could not find android block in #{FilePath.gradle_name}"
+        end
+
+        unless gradle_content.include?(@is_kotlin_gradle ? "val brandProperties" : "brandProperties = new Properties")
+            gradle_content.insert(insert_position + 1, properties_loader)
+        end
+
+        android_block_regex = /(android\s*\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})/m
+        updated_android_block = gradle_content.match(android_block_regex)[1]
+                                    .gsub(
+                                        /applicationId\s+=\s+.*/,
+                                        @is_kotlin_gradle ? KOTLIN_APPLICATION_ID : GROOVY_APPLICATION_ID
+                                    )
+                                    .gsub(
+                                        /versionName\s+=\s+.*/,
+                                        @is_kotlin_gradle ? KOTLIN_VERSION_NAME : GROOVY_VERSION_NAME
+                                    ).gsub(
+            /versionCode\s+=\s+.*/,
+            @is_kotlin_gradle ? KOTLIN_VERSION_CODE : GROOVY_VERSION_CODE
+        )
+
+        gradle_content.sub!(android_block_regex, updated_android_block)
+        File.write(gradle_file, gradle_content)
+        Solara.logger.debug("Updated #{gradle_file} (#{@is_kotlin_gradle ? 'Kotlin' : 'Groovy'}) to use brand.properties")
+    end
+
+    def add_source_sets(gradle_file)
+        content = File.read(gradle_file)
+
+        source_sets_string = @source_sets.map { |dir| "\"#{dir}\"" }.join(', ')
+        kotlin_pattern = /(sourceSets\s*\{\s*getByName\s*\(\s*"main"\s*\)\s*\{\s*res\s*\.\s*srcDirs\s*\(.*?\)\s*\}\s*\})/m
+        groovy_pattern = /(sourceSets\s*\{\s*main\s*\{\s*res\s*\.\s*srcDirs\s*=.*?\s*\}\s*\})/m
+
+        new_config = generate_source_sets(source_sets_string)
+
+        modified_content = if @is_kotlin_gradle
+                               if content.match?(kotlin_pattern)
+                                   content.gsub(kotlin_pattern) do |match|
+                                       indent = match[/^\s*/]
+                                       "#{indent}#{new_config.strip}"
+                                   end
+                               else
+                                   content.sub(/(\s*android\s*\{)/) { "#{$1}\n    #{new_config.strip}" }
+                               end
+                           else
+                               if content.match?(groovy_pattern)
+                                   content.gsub(groovy_pattern) do |match|
+                                       indent = match[/^\s*/]
+                                       "#{indent}#{new_config.strip}"
+                                   end
+                               else
+                                   content.sub(/(\s*android\s*\{)/) { "#{$1}\n    #{new_config.strip}" }
+                               end
+                           end
+
+        File.write(gradle_file, modified_content)
+        Solara.logger.debug("Source sets configuration updated successfully.")
+    end
+
+    def generate_source_sets(source_sets_string)
+        if @is_kotlin_gradle
+            <<-KOTLIN
+        sourceSets {
+            getByName("main") {
+                res.srcDirs(listOf(#{source_sets_string}))
+            }
+        }
+            KOTLIN
+        else
+            <<-GROOVY
+        sourceSets {
+            main {
+                res.srcDirs = [#{source_sets_string}]
+            }
+        }
+            GROOVY
+        end
+    end
+
+    def update_keystore_config(gradle_file)
+        # We need to apply code signing only if the user has provided its config
+        path = FilePath.brand_signing(@brand_key, Platform::Android)
+        signing = JSON.parse(File.read(path))
+        if signing['storeFile'].empty?
+            return
+        end
+
+        content = File.read(gradle_file)
+
+        # Check if the configuration is already applied
+        if content.include?('brandProperties.getProperty("keystore.storeFile")') ||
+            content.include?('project.ext.brandProperties.getProperty("keystore.storeFile")')
+            Solara.logger.debug("Keystore configuration already applied. Skipping update.")
+            return
+        end
+
+        new_config = generate_keystore_config
+
+        signing_config_pattern = /(signingConfigs\s*\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})/m
+        build_types_pattern = /(buildTypes\s*\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})/m
+
+        modified_content = content.dup
+
+        # Remove existing buildTypes block if it exists
+        modified_content.gsub!(build_types_pattern, '')
+
+        # Update or add signingConfigs and buildTypes
+        if modified_content.match?(signing_config_pattern)
+            modified_content.gsub!(signing_config_pattern, new_config)
+        else
+            modified_content.sub!(/(\s*android\s*\{)/) { "#{$1}\n    #{new_config.strip}" }
+        end
+
+        if content != modified_content
+            File.write(gradle_file, modified_content)
+            Solara.logger.debug("Keystore configuration updated successfully.")
+        else
+            Solara.logger.debug("No changes were necessary for keystore configuration.")
+        end
+    end
+
+    def generate_keystore_config
+        if @is_kotlin_gradle
+            <<-KOTLIN
+        signingConfigs {
+            create("release") {
+                storeFile = file(brandProperties.getProperty("storeFile"))
+                storePassword = brandProperties.getProperty("storePassword")
+                keyAlias = brandProperties.getProperty("keyAlias")
+                keyPassword = brandProperties.getProperty("keyPassword")
+            }
+        }
+        buildTypes {
+            getByName("release") {
+                signingConfig = signingConfigs.getByName("release")
+            }
+            getByName("debug") {
+                isDebuggable = true
+            }
+        }
+            KOTLIN
+        else
+            <<-GROOVY
+        signingConfigs {
+            release {
+                storeFile file(project.ext.brandProperties.getProperty("storeFile"))
+                storePassword project.ext.brandProperties.getProperty("storePassword")
+                keyAlias project.ext.brandProperties.getProperty("keyAlias")
+                keyPassword project.ext.brandProperties.getProperty("keyPassword")
+            }
+        }
+        buildTypes {
+            release {
+                signingConfig signingConfigs.release
+            }
+            debug {
+                debuggable true
+            }
+        }
+            GROOVY
+        end
+    end
+end

data/solara/lib/core/scripts/platform/android/properties_generator.rb

@@ -0,0 +1,31 @@
+class PropertiesGenerator
+    def initialize(brand_key)
+        @brand_key = brand_key
+    end
+
+    def generate
+        Solara.logger.start_step("Generate brand.properties for Android")
+        output_file = FilePath.android_generated_properties
+        content = "# Generated by Solara\n"
+
+        load_config.each do |key, value|
+            content << "#{key}=#{value}\n"
+        end
+
+        File.write(output_file, content)
+        Solara.logger.debug("🎉 Generated properties file: #{output_file}, content below ⬇️")
+        Solara.logger.debug("--------------\n#{content}--------------")
+        Solara.logger.end_step("Generate brand.properties for Android")
+    end
+
+    def load_config
+        config_path = FilePath.android_brand_config(@brand_key)
+        signing_path = FilePath.brand_signing(@brand_key, Platform::Android)
+        config = JSON.parse(File.read(config_path))
+        signing_config = JSON.parse(File.read(signing_path))
+
+        config.merge!(signing_config)
+
+        config
+      end
+end

data/solara/lib/core/scripts/platform/ios/ios_file_path_manager.rb

@@ -0,0 +1,109 @@
+Dir.glob("#{__dir__}/*.rb").each { |file| require file }
+require 'singleton'
+require 'pathname'
+
+class IOSFilePathManager
+    include Singleton
+
+    def initialize
+        @platform = SolaraSettingsManager.instance.platform
+        @project_root = SolaraSettingsManager.instance.project_root
+    end
+
+    def xcode_project
+        path = ProjectSettingsManager.instance.value('xcodeproj', Platform::IOS)
+        File.join(@project_root, path)
+    end
+
+    def xcode_project_directory
+        Pathname.new(xcode_project).parent.to_s
+    end
+
+    def brand_assets(brand_key)
+        File.join(FilePath.brands, brand_key, FilePath.ios, 'assets')
+    end
+
+    def brand_xcconfig
+        File.join(artifacts, 'Brand.xcconfig')
+    end
+
+    def artifacts
+        case @platform
+        when Platform::Flutter
+            return File.join(@project_root, FilePath.ios, 'Flutter', 'Artifacts')
+        when Platform::IOS
+            return File.join(xcode_project_directory, 'Artifacts')
+        else
+            raise ArgumentError, "Invalid platform: #{@platform}"
+        end
+    end
+
+    def info_plist
+        path = ProjectSettingsManager.instance.value('Info.plist', Platform::IOS)
+        File.join(@project_root, path)
+    end
+
+    def assets
+        path = ProjectSettingsManager.instance.value('Assets.xcassets', Platform::IOS)
+        File.join(@project_root, path)
+    end
+
+    def assets_directory
+        File.dirname(assets)
+    end
+
+    def assets_artifacts
+        File.join(assets_directory, 'Assets.xcassets', 'Artifacts')
+    end
+
+    def assets_artifcats
+        File.join(assets, 'Artifacts')
+    end
+
+    def app_xcconfig(name)
+        case @platform
+        when Platform::Flutter
+            return File.join(@project_root, FilePath.ios, 'Flutter', name)
+        when Platform::IOS
+            return File.join(xcode_project_directory, 'XCConfig', name)
+        else
+            raise ArgumentError, "Invalid platform: #{@platform}"
+        end
+    end
+
+    def app_xcconfig_directory
+        Pathname.new(app_xcconfig('Debug.xcconfig')).parent.to_s
+    end
+
+    def brand_app_icon(brand_key)
+        File.join(FilePath.brands, brand_key, FilePath.ios, 'assets', 'AppIcon.appiconset')
+    end
+
+    def brand_app_icon_image(brand_key)
+        appicon_set_path = brand_app_icon(brand_key)
+
+        if appicon_set_path.nil?
+            raise "Error: AppIcon.appiconset not found for brand #{brand_key}"
+        end
+
+        contents_json_path = File.join(appicon_set_path, 'Contents.json')
+
+        unless File.exist?(contents_json_path)
+            raise "Error: Contents.json not found in AppIcon.appiconset for brand #{brand_key}"
+        end
+
+        contents = JSON.parse(File.read(contents_json_path))
+
+        largest_image = contents['images'].max_by do |img|
+            size = img['size'].scan(/(\d+)x(\d+)/).first&.map(&:to_i)
+            size ? size[0] * size[1] : 0
+        end
+
+        if largest_image
+            File.join(appicon_set_path, largest_image['filename'])
+        else
+            raise "No images found in Contents.json for brand #{brand_key}"
+        end
+    end
+
+end

data/solara/lib/core/scripts/platform/ios/ios_plist_manager.rb

@@ -0,0 +1,42 @@
+require 'xcodeproj'
+
+class IOSPlistManager
+    def initialize(project, info_plist_path)
+        @project = project
+        @info_plist_path = info_plist_path
+    end
+
+    def create_and_add_info_plist
+#         add_info_plist_to_project
+        set_info_plist_in_build_settings
+        save_project
+    end
+
+    private
+
+    def add_info_plist_to_project
+        file_ref = @project.files.select { |f| f.path == @info_plist_path }.first
+        if file_ref
+            Solara.logger.debug("Info.plist file reference already exists in the project. Skipping this step.")
+        else
+            file_ref = XcodeProjectManager.new.add_single_file_to_group(@project, @project.main_group, @info_plist_path)
+            Solara.logger.debug("Info.plist file created. file_ref = #{file_ref}")
+        end
+    end
+
+    def set_info_plist_in_build_settings
+        path = FileManager.get_relative_path(IOSFilePathManager.instance.xcode_project_directory, @info_plist_path)
+        main_target.build_configurations.each do |config|
+            config.build_settings['INFOPLIST_FILE'] = path
+        end
+    end
+
+    def save_project
+        @project.save
+    end
+
+    def main_target
+        @project.targets.first
+    end
+
+end

data/solara/lib/core/scripts/platform/ios/xcconfig_generator.rb

@@ -0,0 +1,44 @@
+class XcconfigGenerator
+    def initialize(brand_key)
+        @brand_key = brand_key
+        @platform = SolaraSettingsManager.instance.platform
+    end
+
+    def generate
+        Solara.logger.start_step("Generate Brand.xcconfig for iOS")
+        destination = IOSFilePathManager.instance.brand_xcconfig
+        content = generate_xcconfig_content
+        File.write(destination, content)
+        Solara.logger.debug("🎉 Generated #{IOSFilePathManager.instance.brand_xcconfig}. Content below ⬇️")
+        Solara.logger.debug("--------------\n#{content}--------------")
+        Solara.logger.end_step("Generate Brand.xcconfig for iOS")
+    end
+
+    private
+
+    def generate_xcconfig_content
+        content = <<~XCCONFIG
+          ASSETCATALOG_COMPILER_APPICON_NAME = Artifacts/AppIcon
+          #{load_config.map { |key, value| "#{key.upcase} = #{value}" }.join("\n")}
+        XCCONFIG
+
+        case @platform
+        when Platform::Flutter
+            # "../Generated.xcconfig" is the config related to Flutter itself, we must include it here.
+            <<~XCCONFIG
+              #include "../Generated.xcconfig"
+
+              #{content}
+            XCCONFIG
+        when Platform::IOS
+            content
+        else
+            raise ArgumentError, "Invalid platform: #{@platform}"
+        end
+    end
+
+    def load_config
+        config_path = FilePath.ios_config(@brand_key)
+        JSON.parse(File.read(config_path))
+    end
+end

data/solara/lib/core/scripts/platform/ios/xcode_asset_manager.rb

@@ -0,0 +1,56 @@
+require 'fileutils'
+require 'json'
+
+class XcodeAssetManager
+  def initialize(asset_catalog_path)
+    @asset_catalog_path = asset_catalog_path
+  end
+
+  
+  def add(source)
+        # Fetches only files in the specified source directory
+        Dir.glob(File.join(source, '*.{png,jpg,jpeg,svg,heic,pdf}')).each do |file_path|
+            if File.file?(file_path) # Ensure it's a file and not a directory
+                filename_without_extension = File.basename(file_path, File.extname(file_path))
+                add_image(filename_without_extension, file_path, '1x')
+            end
+        end
+    end
+    
+  def add_image(image_name, image_path, scale = '1x')
+    # Create the image set directory if it doesn't exist
+    image_set_path = File.join(@asset_catalog_path, "#{image_name}.imageset")
+    FileUtils.mkdir_p(image_set_path)
+
+    # Copy the image file to the image set directory
+    destination_path = File.join(image_set_path, "#{image_name}@#{scale}.png")
+    FileUtils.cp(image_path, destination_path)
+
+    # Update or create the Contents.json file
+    contents_json_path = File.join(image_set_path, 'Contents.json')
+    contents = if File.exist?(contents_json_path)
+                 JSON.parse(File.read(contents_json_path))
+               else
+                 { "images" => [], "info" => { "version" => 1, "author" => "solara" } }
+               end
+
+    # Add or update the image entry
+    image_entry = {
+      "idiom" => "universal",
+      "filename" => "#{image_name}@#{scale}.png",
+      "scale" => scale
+    }
+
+    existing_entry = contents["images"].find { |img| img["scale"] == scale }
+    if existing_entry
+      existing_entry.merge!(image_entry)
+    else
+      contents["images"] << image_entry
+    end
+
+    # Write the updated Contents.json
+    File.write(contents_json_path, JSON.pretty_generate(contents))
+
+    puts "Image '#{image_name}' added successfully at scale #{scale}."
+  end
+end