solara 0.1.0

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

@@ -0,0 +1,19 @@
+class BrandOffboarder
+
+    def offboard(brand_key, confirm: true)
+        if confirm
+            Solara.logger.warn("Are you sure you need to offboard #{brand_key} and delete all its configurations? (y/n)")
+            confirmation = STDIN.gets.chomp.downcase
+
+            unless confirmation == 'y'
+                Solara.logger.info("Offboarding #{brand_key} cancelled.")
+                return
+            end
+        end
+        BrandsManager.instance.offboard(brand_key)
+        Solara.logger.success("Offboarded #{brand_key} successfully.")
+        is_current_brand = BrandsManager.instance.is_current_brand(brand_key)
+        SolaraManager.new.switch(BrandsManager.instance.first_brand_key, ignore_health_check: true) if is_current_brand
+    end
+
+end

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

@@ -0,0 +1,77 @@
+require 'fileutils'
+require_relative 'file_manager'
+require_relative 'yaml_manager'
+
+class BrandResourcesManager
+    def initialize(brand_key)
+        @brand_key = brand_key
+    end
+
+    require 'fileutils'
+
+    def update_ios
+        Solara.logger.start_step("Update iOS resources")
+        source = IOSFilePathManager.instance.brand_assets(@brand_key)
+        destination = IOSFilePathManager.instance.assets_artifacts
+        FileManager.delete_if_exists(destination)
+
+        # Copy images and set the Content.json for each one
+        add_to_asset_catalog
+
+        # Copy all folders only in source to destination
+        Dir.glob("#{source}/*").each do |item|
+            if File.directory?(item)
+                FileUtils.cp_r(item, destination)
+            end
+        end
+
+        Solara.logger.end_step("Update iOS resources")
+    end
+
+    def add_to_asset_catalog
+        source = IOSFilePathManager.instance.brand_assets(@brand_key)
+        destination = IOSFilePathManager.instance.assets_artifacts
+        asset_manager = XcodeAssetManager.new(destination)
+        asset_manager.add(source)
+    end
+
+    def update_android
+        Solara.logger.start_step("Update Android resources")
+        FileManager.new.copy_files_recursively(
+            FilePath.android_brand_res(@brand_key),
+            FilePath.android_res_artifacts)
+
+        assets_artifacts = File.join(FilePath.android_project_assets, 'artifacts')
+        FileManager.delete_if_exists(assets_artifacts)
+
+        FileManager.new.copy_files_recursively(
+            FilePath.android_brand_assets(@brand_key),
+            assets_artifacts)
+
+        # Delete the original launcher icons to fix duplicate resources
+        FileManager.new.delete_folders_by_prefix(FilePath.android_res, 'mipmap')
+        Solara.logger.end_step("Update Android resources")
+    end
+
+    def update_flutter
+        Solara.logger.start_step("Update Flutter resources")
+        case SolaraSettingsManager.instance.platform
+        when Platform::Flutter
+            YamlManager.new(FilePath.pub_spec_yaml).add_to_nested_array(
+                'flutter',
+                'assets',
+                'assets/artifacts/')
+
+            destination = FilePath.flutter_assets_artifacts
+            FileManager.delete_if_exists(destination)
+
+            FileManager.new.copy_files_recursively(
+                FilePath.brand_flutter_assets(@brand_key),
+                destination)
+        else
+            # Nothing
+        end
+
+        Solara.logger.end_step("Update Flutter resources")
+    end
+end

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

@@ -0,0 +1,22 @@
+class DirectoryCreator
+    def self.create_directories(directories, delete_if_exists = false)
+        directories.each do |dir|
+            create_directory(dir, delete_if_exists)
+        end
+    end
+
+    private
+
+    def self.create_directory(dir, delete_if_exists)
+        if Dir.exist?(dir)
+            if delete_if_exists
+                FileUtils.rm_rf(dir)
+                Solara.logger.debug("🧹 Deleted directory: #{dir}")
+                Dir.mkdir(dir)
+            end
+        else
+            Dir.mkdir(dir)
+        end
+        Solara.logger.debug("✨  Created directory: #{dir}")
+    end
+end

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

@@ -0,0 +1,90 @@
+require 'find'
+
+class FileManager
+    def copy_files_recursively(source_dir, destination_dir)
+        if Dir.exist?(source_dir)
+            Dir.glob(File.join(source_dir, '*')).each do |item|
+                relative_path = Pathname.new(item).relative_path_from(Pathname.new(source_dir)).to_s
+                destination_path = File.join(destination_dir, relative_path)
+
+                if File.directory?(item)
+                    FileUtils.mkdir_p(destination_path)
+                    FileUtils.cp_r(File.join(item, '.'), destination_path)
+                else
+                    FileUtils.mkdir_p(File.dirname(destination_path))
+                    FileUtils.cp(item, destination_path)
+                end
+
+                Solara.logger.debug("🚗 Copied #{relative_path} \n\t↖️From: #{source_dir} \n\t↗️To: #{destination_dir}")
+            end
+        else
+            Solara.logger.failure("#{source_dir} not found in Solara")
+        end
+    end
+
+    def delete_folders_by_prefix(directory, folder_prefix)
+        # Get a list of all folders in the directory
+        folders = Dir.entries(directory).select { |entry| File.directory?(File.join(directory, entry)) && entry.start_with?(folder_prefix) }
+
+        # Delete each folder
+        folders.each do |folder|
+            folder_path = File.join(directory, folder)
+            FileUtils.rm_rf(folder_path)
+            Solara.logger.debug("🧹 Deleted folder: #{folder_path}")
+        end
+    end
+
+    def self.create_file_if_not_exist(file_path)
+        unless File.exist?(file_path)
+            FileUtils.mkdir_p(File.dirname(file_path))
+            File.open(file_path, 'w') {}
+            Solara.logger.debug("✨ Created file: #{file_path}")
+        end
+    end
+
+    def self.create_files_if_not_exist(file_paths)
+        file_paths.each do |file_path|
+            create_file_if_not_exist(file_path)
+        end
+    end
+
+    def self.find_file_extesion(extension)
+        files = []
+        Find.find(SolaraSettingsManager.instance.project_root) do |path|
+            if FileTest.file?(path) && File.extname(path) == extension
+                files << path
+            end
+        end
+        files
+    end
+
+    def self.find_files_by_extension(directory, extension)
+        Dir.glob(File.join(directory, "**", "*#{extension}"))
+    end
+
+    def self.find_files_by_name(directory, filename)
+        Dir.glob(File.join(directory, "**", filename)).to_a
+    end
+
+    def self.get_relative_path(root_dir, sub_dir)
+        Pathname(sub_dir).relative_path_from(Pathname(root_dir)).to_s
+    rescue
+        sub_dir
+    end
+
+    def self.get_relative_path_to_root(sub_dir)
+        Pathname(sub_dir).relative_path_from(Pathname(FilePath.project_root)).to_s
+    rescue
+        sub_dir
+    end
+
+    def self.get_folders(source)
+        # Fetches only directories in the specified source directory
+        Dir.glob(File.join(source, '*')).select { |path| File.directory?(path) }
+    end
+
+    def self.delete_if_exists(path)
+        FileUtils.rm_rf(path) if File.exist?(path)
+    end
+
+end

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

@@ -0,0 +1,327 @@
+Dir.glob("#{__dir__}/*.rb").each { |file| require file }
+
+module FilePath
+
+    def self.project_root
+        SolaraSettingsManager.instance.project_root
+    end
+
+    def self.root
+        SolaraSettingsManager.instance.root
+    end
+
+    def self.android
+        "android"
+    end
+
+    def self.android_project_root
+        case SolaraSettingsManager.instance.platform
+        when Platform::Flutter
+            File.join(project_root, android)
+        when Platform::Android
+            project_root
+        else
+            raise ArgumentError, "Invalid platform: #{SolaraSettingsManager.instance.platform}"
+        end
+    end
+
+    def self.ios_project_root
+        case SolaraSettingsManager.instance.platform
+        when Platform::Flutter
+            File.join(project_root, ios)
+        when Platform::IOS
+            project_root
+        else
+            raise ArgumentError, "Invalid platform: #{SolaraSettingsManager.instance.platform}"
+        end
+    end
+
+    def self.android_project_relative_root
+        case SolaraSettingsManager.instance.platform
+        when Platform::Flutter
+            android
+        when Platform::Android
+            ''
+        else
+            raise ArgumentError, "Invalid platform: #{SolaraSettingsManager.instance.platform}"
+        end
+    end
+
+    def self.android_brand_relative_root
+        android
+    end
+
+    def self.android_brand_root(brand_key)
+        brand_root(android, brand_key)
+    end
+
+    def self.ios_brand_root(brand_key)
+        brand_root(ios, brand_key)
+    end
+
+    def self.brand_root(platform, brand_key)
+        File.join(brands, brand_key, platform)
+    end
+
+    def self.solara
+        File.join(Dir.pwd, 'solara')
+    end
+
+    def self.dot_solara
+        File.join(project_root, 'solara', '.solara')
+    end
+
+    def self.ios
+        "ios"
+    end
+
+    def self.brands
+        File.join(project_root, 'solara', 'brands')
+    end
+
+    def self.brand(brand_key)
+        File.join(brands, brand_key)
+    end
+
+    def self.android_config(brand_key)
+        File.join(android_brand_root(brand_key), 'android_config.json')
+    end
+
+    def self.ios_config(brand_key)
+        File.join(ios_brand_root(brand_key), 'ios_config.json')
+    end
+
+    def self.brand_config(brand_key)
+        File.join(brands, brand_key, 'shared', 'brand_config.json')
+    end
+
+    def self.brand_theme(brand_key)
+        File.join(brands, brand_key, 'shared', 'theme.json')
+    end
+
+    def self.brand_signing(brand_key, platform)
+        config("#{platform}_signing.json", brand_key, platform)
+    end
+
+    def self.android_brand_signing(brand_key)
+        brand_signing(brand_key, Platform::Android)
+    end
+
+    def self.ios_brand_signing(brand_key)
+        brand_signing(brand_key, Platform::IOS)
+    end
+
+    def self.config(name, brand_key, platform = SolaraSettingsManager.instance.platform)
+        case platform
+        when Platform::Flutter
+            File.join(brands, brand_key, 'shared', "#{name}")
+        when Platform::Android
+            File.join(android_brand_root(brand_key), "#{name}")
+        when Platform::IOS
+            File.join(ios_brand_root(brand_key), "#{name}")
+        else
+            raise ArgumentError, "Invalid platform: #{SolaraSettingsManager.instance.platform}"
+        end
+    end
+
+    def self.generated_config(name, platform)
+        case platform
+        when Platform::Flutter
+            File.join(flutter_artifacts, name)
+        when Platform::Android
+            File.join(android_main_artifacts, name)
+        when Platform::IOS
+            File.join(IOSFilePathManager.instance.artifacts, name)
+        else
+            raise ArgumentError, "Invalid platform: #{SolaraSettingsManager.instance.platform}"
+        end
+    end
+
+    def self.flutter_artifacts
+        File.join(project_root, 'lib', 'artifacts')
+    end
+
+    def self.android_artifacts
+        File.join(android_project_root, 'artifacts')
+    end
+
+    def self.android_main_artifacts
+        File.join(android_project_root, 'app', 'src', 'main', 'java', 'artifacts')
+    end
+
+    def self.android_brand_config(brand_key)
+        File.join(android_brand_root(brand_key), 'android_config.json')
+    end
+
+    def self.android_app_gradle
+        File.join(android_project_root, 'app', gradle_name)
+    end
+
+    def self.android_app_gradle_by_type(type = '')
+        File.join(android_project_root, 'app', "build.gradle#{type}")
+    end
+
+    def self.is_koltin_gradle
+        File.exist?(android_app_gradle_by_type('.kts'))
+    end
+
+    def self.gradle_name
+        is_koltin_gradle ? 'build.gradle.kts' : 'build.gradle'
+    end
+
+    def self.android_manifest
+        File.join(android_project_root, 'app', 'src', 'main', 'AndroidManifest.xml')
+    end
+
+    def self.android_project_assets
+        File.join(android_project_root, 'app', 'src', 'main', 'assets')
+    end
+
+    def self.android_brand_assets(brand_key)
+        File.join(android_brand_root(brand_key), 'assets')
+    end
+
+    def self.android_generated_properties
+        File.join(android_artifacts, 'brand.properties')
+    end
+
+    def self.android_res
+        File.join(android_project_root, 'app', 'src', 'main', 'res')
+    end
+
+    def self.android_res_artifacts
+        File.join(android_project_root, 'app', 'src', 'main', 'artifacts')
+    end
+
+    def self.android_artifacts_strings
+        File.join(android_res_artifacts, 'values', 'strings.xml')
+    end
+
+    def self.android_strings
+        File.join(android_project_root, 'app', 'src', 'main', 'res', 'values', 'strings.xml')
+    end
+
+    def self.android_brand_res(brand_key)
+        File.join(android_brand_root(brand_key), 'res')
+    end
+
+    def self.brand_flutter_assets(brand_key)
+        File.join(brands, brand_key, 'shared', 'assets')
+    end
+
+    def self.flutter_assets_artifacts
+        File.join(project_root, 'assets', 'artifacts')
+    end
+
+    def self.pub_spec_yaml
+        File.join(project_root, 'pubspec.yaml')
+    end
+
+    def self.flutter_artifacts_config
+        File.join(flutter_artifacts, 'app_config.dart')
+    end
+
+    def self.dashboard
+        File.join(root, 'core', 'dashboard')
+    end
+
+    def self.brands_list
+        File.join(brands, 'brands.json')
+    end
+
+    def self.current_brand
+        File.join(brands, 'current_brand.json')
+    end
+
+    def self.solara_template_brands(platform)
+        File.join(solara_template, 'brands', platform)
+    end
+
+    def self.template_brands
+        File.join(solara_template, 'brands')
+    end
+
+    def self.template_config
+        platform = SolaraSettingsManager.instance.platform
+        File.join(solara_template, 'config', "#{platform}_template_config.json")
+    end
+
+    def self.template_validation_config
+        platform = SolaraSettingsManager.instance.platform
+        File.join(root, 'core', 'doctor', 'validator', 'template', "#{platform}_template_validation_config.yml")
+    end
+
+    def self.solara_template_brands_json
+        File.join(root, 'core', 'template', 'brands', 'brands.json')
+    end
+
+    def self.solara_template
+        File.join(root, 'core', 'template')
+    end
+
+    def self.solara_aliases_json
+        File.join(dot_solara, 'aliases', 'aliases.json')
+    end
+
+    def self.project_settings
+        File.join(dot_solara, 'project_settings.json')
+    end
+
+    def self.solara_settings
+        File.join(dot_solara, 'solara_settings.json')
+    end
+
+    def self.solara_version
+        File.join(dot_solara, 'solara_version.json')
+    end
+
+    def self.solara_aliases_sh
+        File.join(ENV['HOME'], '.solara', 'aliases.sh')
+    end
+
+    def self.solara_aliases_readme
+        File.join(dot_solara, 'aliases', 'README.md')
+    end
+
+    def self.android_launcher_icon(brand_key)
+        paths = %w[mipmap-xxxhdpi mipmap-xxhdpi mipmap-xhdpi mipmap-mdpi mipmap-hdpi]
+
+        paths.each do |path|
+            full_path = File.join(android_brand_root(brand_key), 'res', path)
+            return File.join(full_path, 'ic_launcher.png') if File.exist?(full_path)
+        end
+
+        nil # No existing path found
+    end
+
+    def self.launcher_icon(brand_key)
+        case SolaraSettingsManager.instance.platform
+        when Platform::Flutter
+            return android_launcher_icon(brand_key)
+        when Platform::Android
+            return android_launcher_icon(brand_key)
+        when Platform::IOS
+            path = IOSFilePathManager.instance.brand_app_icon_image(brand_key)
+            return path
+        else
+            raise ArgumentError, "Invalid platform: #{SolaraSettingsManager.instance.platform}"
+        end
+    end
+
+    def self.schema
+        File.join(root, 'core', 'doctor', 'schema')
+    end
+
+    def self.brand_configurations_schema
+        File.join(schema, 'brand_configurations.json')
+    end
+
+    def self.flutter_xcconfig_debug
+        File.join(project_root, ios, 'Flutter', 'Debug.xcconfig')
+    end
+
+    def self.flutter_xcconfig_release
+        File.join(project_root, ios, 'Flutter', 'Release.xcconfig')
+    end
+
+end

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

@@ -0,0 +1,41 @@
+require 'fileutils'
+
+class FolderCopier
+    def initialize(source_path, destination_path)
+        @source_path = source_path
+        @destination_path = destination_path
+    end
+
+    def copy(delete_if_exists: true)
+        if File.exist?(@destination_path)
+            if delete_if_exists
+                FileUtils.rm_rf(@destination_path)
+            end
+        end
+        FileUtils.mkdir_p(@destination_path)
+        copy_files_and_folders(@source_path, @destination_path)
+    end
+
+    private
+
+    def copy_files_and_folders(source, destination)
+        if File.file?(source)
+            FileUtils.cp_r(source, destination)
+        elsif File.directory?(source)
+            Dir.foreach(source) do |item|
+                next if item == '.' || item == '..'
+                source_item_path = File.join(source, item)
+                destination_item_path = File.join(destination, item)
+
+                if File.directory?(source_item_path)
+                    FileUtils.mkdir_p(destination_item_path) unless File.directory?(destination_item_path)
+                    copy_files_and_folders(source_item_path, destination_item_path)
+                else
+                    FileUtils.cp_r(source_item_path, destination_item_path)
+                end
+            end
+        else
+            raise "Source is not a file or directory: #{source}"
+        end
+    end
+end

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

@@ -0,0 +1,54 @@
+class GitignoreManager
+    def initialize(gitignore_path = '.gitignore')
+        @gitignore_path = gitignore_path.end_with?('.gitignore') ? gitignore_path : File.join(gitignore_path, '.gitignore')
+        create_gitignore_if_not_exists
+    end
+
+    def self.ignore_redundant_files
+        GitignoreManager.new(FilePath.project_root)
+        .add_items([
+                       "# Generated by Solara. Ignore redundant brand specific changes.",
+                       "**/artifacts/",
+                       "**/Artifacts/",
+                       "solara/brands/current_app.json",
+                       "solara/.solara/aliases/",
+                       "solara/.solara/solara_settings.json",
+                   ])
+    end
+        
+    def add_items(items)
+        items.each do |item|
+            add_item(item)
+        end
+    end
+
+    def add_item(item)
+        existing_items = read_gitignore
+
+        if existing_items.include?(item)
+            Solara.logger.debug("'#{item}' already exists in .gitignore")
+        else
+            File.open(@gitignore_path, 'a') do |file|
+                file.puts(item)
+            end
+            Solara.logger.debug("Added '#{item}' to .gitignore")
+        end
+    end
+
+    private
+
+    def create_gitignore_if_not_exists
+        unless File.exist?(@gitignore_path)
+            File.open(@gitignore_path, 'w') do |file|
+                file.puts("# Generated by Solara")
+                file.puts("# Git ignore file")
+                file.puts("# Add items to ignore below")
+            end
+            Solara.logger.debug("Created new .gitignore file at #{@gitignore_path}")
+        end
+    end
+
+    def read_gitignore
+        File.readlines(@gitignore_path).map(&:chomp)
+    end
+end