solara 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 145b33e1ba6fda109d59904bf8e356ed6ec8f4990b16857e5fbde74fb2d5e2da
+  data.tar.gz: 401d6f18d80006e0e030d1873ad6488a845301fc8f6fb91700ecd7cf2b959c25
+SHA512:
+  metadata.gz: 4dbd300836c1b9c4885c24e9f9506f0b10fb0baa987a5a851d95aa24d5e592e9af496d96601c05f248e386736589151916baab4a53034af1d2723ccd99f26482
+  data.tar.gz: 3bbc2fc137767dd083228dd520a8b47e8ab7a06eb1b78ea81fa6184524d70630167419665021f1eefb08ddab649cdaa771d265685e5288d4ec1b53778c4a2016

data/bin/solara

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+if RUBY_VERSION < '2.0.0'
+  abort("Solara requires Ruby 2.0.0 or higher")
+end
+
+Dir.glob("#{__dir__}/core/scripts/*.rb").each { |file| require file }
+Dir.glob("#{__dir__}/core/scripts/*.rb").each { |file| require file }
+Dir.glob("#{__dir__}/core/*.rb").each { |file| require file }
+Dir.glob("#{__dir__}/core/doctor/*.rb").each { |file| require file }
+Dir.glob("#{__dir__}/core/aliases/*.rb").each { |file| require file }
+Dir.glob("#{__dir__}/core/dashboard/*.rb").each { |file| require file }
+Dir.glob("#{__dir__}/core/brands/*.rb").each { |file| require file }
+
+require 'solara'
+
+Solara::Setup.new.setup
+Solara::CLI.start(ARGV)

data/solara/lib/core/aliases/alias_generator.rb

@@ -0,0 +1,128 @@
+Dir[File.expand_path('../scripts/*.rb', __dir__)].each { |file| require_relative file }
+require 'json'
+
+class AliasGenerator
+    def initialize
+        @output_file = FilePath.solara_aliases_sh
+        FileManager.create_file_if_not_exist(@output_file)
+
+        @readme_file = FilePath.solara_aliases_readme
+        FileManager.create_file_if_not_exist(@readme_file)
+
+        @json_file = FilePath.solara_aliases_json
+        FileManager.create_file_if_not_exist(@json_file)
+
+        @brand_aliases = {}
+        @common_aliases = []
+    end
+
+    def add_brand_aliases(brands)
+        alias_templates = [
+            "solara_offboard_{brand_key}='solara offboard -k {brand_key}'",
+            "solara_switch_{brand_key}='solara switch -k {brand_key}'",
+            "solara_doctor_{brand_key}='solara doctor -k {brand_key}'",
+            "solara_dashboard_{brand_key}='solara dashboard -k {brand_key}'"
+        ]
+
+        brands.each do |app|
+            brand_key = app['key']
+            @brand_aliases[brand_key] = []
+            alias_templates.each do |template|
+                alias_line = template.gsub('{brand_key}', brand_key)
+                @brand_aliases[brand_key] << "alias #{alias_line}"
+            end
+        end
+    end
+
+    def add_common_aliases(common_aliases)
+        @common_aliases = common_aliases.map { |alias_line| "alias #{alias_line}" }
+    end
+
+    def generate_shell_file
+        existing_content = File.exist?(@output_file) ? File.read(@output_file) : ""
+        new_content = []
+
+        new_content << "#!/bin/bash" if existing_content.empty?
+
+        common_aliases_added = false
+        @common_aliases.each do |alias_line|
+            unless existing_content.include?(alias_line)
+                new_content << "# Common Aliases" unless common_aliases_added
+                common_aliases_added = true
+                new_content << alias_line
+            end
+        end
+
+        brand_aliases_added = false
+        @brand_aliases.each do |brand_name, brand_aliases|
+            brand_aliases_for_this_brand_added = false
+            brand_aliases.each do |alias_line|
+                unless existing_content.include?(alias_line)
+                    unless brand_aliases_added
+                        brand_aliases_added = true
+                    end
+                    unless brand_aliases_for_this_brand_added
+                        new_content << "" # Add a new line before each brand name
+                        new_content << "# #{brand_name}"
+                        brand_aliases_for_this_brand_added = true
+                    end
+                    new_content << alias_line
+                end
+            end
+        end
+
+        new_content.reject!(&:empty?) if new_content.size == 1
+
+        if new_content.any? && !(new_content.size == 1 && new_content.first == "#!/bin/bash")
+            File.open(@output_file, 'a') do |file|
+                file.puts new_content
+            end
+            Solara.logger.debug("Aliases have been appended to #{@output_file}")
+        else
+            Solara.logger.debug("No new aliases to add to #{@output_file}")
+        end
+    end
+
+    def generate_readme
+        File.open(@readme_file, 'w') do |file|
+            file.puts "# Aliases"
+            file.puts
+            file.puts "This document provides an overview of all available aliases."
+            file.puts
+
+            if @common_aliases.any?
+                file.puts "## Common Aliases"
+                file.puts
+                @common_aliases.each do |alias_line|
+                    alias_name = alias_line.split('=').first.strip.gsub('alias ', '')
+                    file.puts "- `#{alias_name}`"
+                end
+            end
+
+            file.puts
+
+            file.puts
+            @brand_aliases.each do |brand_name, brand_aliases|
+                file.puts "## #{brand_name}"
+                file.puts
+                brand_aliases.each do |alias_line|
+                    alias_name = alias_line.split('=').first.strip.gsub('alias ', '')
+                    file.puts "- `#{alias_name}`"
+                end
+            end
+        end
+        Solara.logger.debug("README.md has been generated in #{@readme_file}")
+    end
+
+    def save_aliases_to_json
+        json_data = {
+            "common_aliases" => @common_aliases,
+            "brand_aliases" => @brand_aliases
+        }
+
+        File.open(@json_file, 'w') do |file|
+            file.puts JSON.pretty_generate(json_data)
+        end
+        Solara.logger.debug("Aliases have been saved in JSON format in #{@json_file}")
+    end
+end

data/solara/lib/core/aliases/alias_generator_manager.rb

@@ -0,0 +1,28 @@
+class AliasGeneratorManager
+  def initialize
+    @generator = AliasGenerator.new()
+  end
+
+  def start
+    Solara.logger.start_step("Generate terminal command aliases")
+    common_aliases = [
+      "solara_dashboard='solara dashboard'",
+      "solara_doctor='solara doctor'",
+    ]
+
+    @generator.add_brand_aliases(BrandsManager.instance.brands_list)
+    @generator.add_common_aliases(common_aliases)
+    @generator.generate_shell_file
+    @generator.save_aliases_to_json
+    @generator.generate_readme
+
+    SolaraSetup.new.run
+    Solara.logger.end_step("Generate terminal command aliases")
+  end
+
+  def self.aliases_json
+      path = FilePath.solara_aliases_json
+      JSON.parse(File.read(path))
+  end
+
+end

data/solara/lib/core/aliases/solara_terminal_setup.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+Dir.glob("../scripts/*.rb").each { |file| require file }
+
+require 'fileutils'
+require 'rbconfig'
+
+class SolaraSetup
+  def initialize
+    @aliases_file = FilePath.solara_aliases_sh
+    @setup_dir = File.join(ENV['HOME'], '.solara')
+    @unix_setup_file = File.join(@setup_dir, 'setup.sh')
+    @windows_setup_file = File.join(@setup_dir, 'setup.bat')
+  end
+
+  def run
+    create_setup_directory
+    create_unix_setup_script
+    create_windows_setup_script
+    
+    case RbConfig::CONFIG['host_os']
+    when /mswin|mingw|cygwin/
+      setup_windows
+    when /darwin|mac os|linux/
+      setup_unix
+    else
+      Solara.logger.fatal("Unsupported operating system. Please set up manually.")
+    end
+  end
+
+  private
+
+  def create_setup_directory
+    FileUtils.mkdir_p(@setup_dir)
+  end
+
+  def create_unix_setup_script
+    File.open(@unix_setup_file, 'w') do |file|
+      file.puts <<~SCRIPT
+        #!/bin/bash
+        source "#{@aliases_file}"
+      SCRIPT
+    end
+    FileUtils.chmod(0755, @unix_setup_file)
+  end
+
+  def create_windows_setup_script
+    File.open(@windows_setup_file, 'w') do |file|
+      file.puts <<~SCRIPT
+        @echo off
+        call "#{@aliases_file.gsub('/', '\\')}"
+      SCRIPT
+    end
+  end
+
+  def setup_unix
+    shell_config_file = determine_shell_config_file
+    setup_line = "source #{@unix_setup_file}"
+
+    if File.exist?(shell_config_file)
+      content = File.read(shell_config_file)
+      unless content.include?(setup_line)
+        File.open(shell_config_file, 'a') do |file|
+          file.puts "\n# Solara Setup"
+          file.puts setup_line
+        end
+        Solara.logger.debug("Configuration added to #{shell_config_file}")
+        Solara.logger.success("Please restart your terminal or run 'source #{shell_config_file}' to apply changes.")
+      else
+        Solara.logger.debug("Configuration already exists in #{shell_config_file}")
+      end
+    else
+      Solara.logger.failure("Shell configuration file not found. Please add the following line manually to your shell configuration:")
+      Solara.logger.failure(setup_line)
+    end
+  end
+
+  def setup_windows
+    require 'win32/registry'
+
+    begin
+      Win32::Registry::HKEY_CURRENT_USER.create('Software\Microsoft\Command Processor') do |reg|
+        reg['AutoRun', Win32::Registry::REG_EXPAND_SZ] = @windows_setup_file
+      end
+      Solara.logger.success("Windows AutoRun registry key set up successfully.")
+      pSolara.logger.warn("Please restart your Command Prompt to apply changes.")
+    rescue Win32::Registry::Error => e
+      Solara.logger.failure("Failed to set up Windows registry: #{e.message}")
+      Solara.logger.failure("Please add the following file path to your AutoRun registry key manually:")
+      Solara.logger.failure(@windows_setup_file)
+    end
+  end
+
+  def determine_shell_config_file
+    if ENV['SHELL'] =~ /zsh/
+      File.expand_path('~/.zshrc')
+    elsif ENV['SHELL'] =~ /bash/
+      File.expand_path('~/.bashrc')
+    else
+      File.expand_path('~/.profile')
+    end
+  end
+end

data/solara/lib/core/brands/brand_onboarder.rb

@@ -0,0 +1,46 @@
+Dir[File.expand_path('scripts/*.rb', __dir__)].each { |file| require_relative file }
+Dir[File.expand_path('../template/*.rb', __dir__)].each { |file| require_relative file }
+Dir[File.expand_path('platform/android/*.rb', __dir__)].each { |file| require_relative file }
+Dir[File.expand_path('platform/ios/*.rb', __dir__)].each { |file| require_relative file }
+Dir[File.expand_path('platform/flutter/*.rb', __dir__)].each { |file| require_relative file }
+
+class BrandOnboarder
+    def initialize(brand_key, brand_name, clone_brand_key: nil)
+        @brand_key = brand_key
+        @brand_name = brand_name
+        @clone_brand_key = clone_brand_key
+    end
+
+    def onboard
+        if @clone_brand_key.nil? || @clone_brand_key.empty?
+            generate_brand_template
+        else
+            clone_brand
+        end
+        add_to_brands_list
+    end
+
+    def add_to_brands_list
+        BrandsManager.instance.add_brand(@brand_name, @brand_key)
+    end
+
+    def generate_brand_template
+        Solara.logger.debug("Onboarding #{@brand_key} from template.")
+
+        template_dir = FilePath.template_brands
+        target_dir = File.join(FilePath.solara, 'brands', @brand_key)
+        config_file = FilePath.template_config
+
+        generator = ProjectTemplateGenerator.new(template_dir, target_dir, config_file)
+        generator.create_project
+    end
+
+    def clone_brand
+        Solara.logger.debug("Cloning #{@clone_brand_key} to #{@brand_key}")
+        source = FilePath.brand(@clone_brand_key)
+        destination = File.join(FilePath.solara, 'brands', @brand_key)
+        FolderCopier.new(source, destination).copy
+    end
+
+end
+

data/solara/lib/core/brands/brand_switcher.rb

@@ -0,0 +1,204 @@
+Dir[File.expand_path('scripts/*.rb', __dir__)].each { |file| require_relative file }
+Dir[File.expand_path('platform/android/*.rb', __dir__)].each { |file| require_relative file }
+Dir[File.expand_path('platform/ios/*.rb', __dir__)].each { |file| require_relative file }
+Dir[File.expand_path('platform/flutter/*.rb', __dir__)].each { |file| require_relative file }
+
+class BrandSwitcher
+    def initialize(brand_key, ignore_health_check: false)
+        Solara.logger.debug("ignore_health_check = #{ignore_health_check}")
+        @brand_key = brand_key
+        @ignore_health_check = ignore_health_check
+        @platform = SolaraSettingsManager.instance.platform
+    end
+
+    def self.switch_to_first_brand(ignore_health_check: true)
+        first_brand_key = BrandsManager.instance.first_brand_key
+        if first_brand_key.nil?
+            return
+        end
+        BrandSwitcher.new(first_brand_key, ignore_health_check: ignore_health_check).start
+    end
+
+    def start
+        Solara.logger.header("Switching to #{@brand_key}")
+
+        health_errors = SolaraManager.new.doctor([@brand_key]).select { |issue| issue.type == Issue::ERROR }
+        unless health_errors.empty?
+            unless @ignore_health_check
+                errors_with_index = health_errors.each_with_index.map { |error, index| "#{index + 1}: #{error}" }
+                raise "Health check completed with errors: \n\n#{errors_with_index.join("\n")}."
+            end
+        end
+
+        BrandsManager.instance.save_current_brand(@brand_key)
+
+        Solara.logger.start_step("Create artifacts directories")
+        create_artifacts_dirs
+        Solara.logger.end_step("Create artifacts directories")
+
+        switch
+
+        SolaraConfigurator.new.start
+
+        Solara.logger.success("Switched to #{@brand_key} successfully.")
+    end
+
+    def create_artifacts_dirs
+        case @platform
+        when Platform::Flutter
+            directories = [
+                FilePath::flutter_artifacts,
+                FilePath::android_artifacts,
+                IOSFilePathManager.instance.artifacts
+            ]
+            DirectoryCreator.create_directories(directories, delete_if_exists: true)
+
+        when Platform::IOS
+            directories = [
+                IOSFilePathManager.instance.artifacts
+            ]
+            DirectoryCreator.create_directories(directories, delete_if_exists: true)
+
+        when Platform::Android
+            directories = [
+                FilePath::android_artifacts
+            ]
+            DirectoryCreator.create_directories(directories, delete_if_exists: true)
+        else
+            raise ArgumentError, "Invalid platform: #{@platform}"
+        end
+    end
+
+    def switch
+        case @platform
+        when Platform::Flutter
+            switch_flutter
+            switch_android
+            switch_ios
+
+        when Platform::IOS
+            switch_ios
+
+        when Platform::Android
+            switch_android
+        else
+            raise ArgumentError, "Invalid platform: #{@platform}"
+        end
+    end
+
+    def generate_theme_kotlin
+        generate_theme(
+            'BrandTheme.kt',
+            Language::Kotlin,
+            Platform::Android)
+    end
+
+    def generate_theme_swift
+        generate_theme(
+            'BrandTheme.swift',
+            Language::Swift,
+            Platform::IOS)
+    end
+
+    def generate_theme_dart
+        generate_theme(
+            'brand_theme.dart',
+            Language::Dart,
+            Platform::Flutter)
+    end
+
+    def generate_theme(
+        name,
+        language,
+        platform)
+        Solara.logger.start_step("Generate #{language} theme for #{platform}")
+        generator = ThemeGenerator.new(
+            FilePath.brand_theme(@brand_key),
+            FilePath.generated_config(name, platform),
+            language)
+        generator.generate
+        Solara.logger.end_step("Generate #{language} theme for #{platform}")
+    end
+
+    def generate_app_config_kotlin
+        generate_brand_config(
+            'BrandConfig.kt',
+            Language::Kotlin,
+            Platform::Android
+        )
+    end
+
+    def generate_app_config_swift
+        generate_brand_config(
+            'BrandConfig.swift',
+            Language::Swift,
+            Platform::IOS)
+    end
+
+    def generate_app_config_dart
+        generate_brand_config(
+            'brand_config.dart',
+            Language::Dart,
+            Platform::Flutter)
+    end
+
+    def generate_brand_config(
+        name,
+        language,
+        platform)
+        BrandConfigManager.new(@brand_key).generate_brand_config(
+            name,
+            language,
+            platform)
+    end
+
+    def switch_flutter
+        generate_theme_dart
+        generate_app_config_dart
+        BrandResourcesManager.new(@brand_key).update_flutter
+    end
+
+    def switch_android
+        BrandConfigManager.new(@brand_key).generate_android_properties
+        config_path = FilePath.android_brand_config(@brand_key)
+        config = JSON.parse(File.read(config_path))
+        update_build_gradle
+        update_manifest(config)
+        update_strings_xml(config)
+        BrandResourcesManager.new(@brand_key).update_android
+        generate_theme_kotlin
+        generate_app_config_kotlin
+    end
+
+    def update_build_gradle
+        switcher = GradleSwitcher.new(@brand_key)
+        switcher.update_build_gradle
+    end
+
+    def update_manifest(config)
+        switcher = AndroidManifestSwitcher.new
+        switcher.update_manifest(config)
+    end
+
+    def update_strings_xml(config)
+        switcher = AndroidStringsSwitcher.new
+        switcher.update(config)
+    end
+
+    def switch_ios
+        BrandConfigManager.new(@brand_key).generate_ios_xcconfig
+        generate_theme_swift
+        generate_app_config_swift
+        update_xcode_project
+        BrandResourcesManager.new(@brand_key).update_ios
+    end
+
+    def update_xcode_project
+        Solara.logger.start_step("Update Xcode project")
+        project_path = IOSFilePathManager.instance.xcode_project
+        switcher = XcodeProjectSwitcher.new(project_path, @brand_key)
+        switcher.switch
+        Solara.logger.end_step("Update Xcode project")
+    end
+
+end

data/solara/lib/core/brands/brands_manager.rb

@@ -0,0 +1,154 @@
+require 'singleton'
+require 'json'
+require 'rubygems'
+
+class BrandsManager
+    include Singleton
+
+    def initialize
+        brands_list_path = FilePath.brands_list
+        @brands_list = JSON.parse(File.read(brands_list_path))
+    end
+
+    def first_brand
+        brands_list.first
+    end
+
+    def first_brand_key
+        brands_list.first["key"]
+    rescue
+        nil
+    end
+
+    def brand_name(brand_key)
+        brand_data(brand_key)["name"]
+    end
+
+    def brand_with_configurations(brand_key)
+        configurations = BrandConfigurationsManager.new(brand_key).create
+        {
+            solaraVersion: Gem.loaded_specs['solara'].version.to_s,
+            brand: brand_data(brand_key),
+            configurations: configurations
+        }
+    end
+
+    def brand_data(brand_key)
+        brands_list.find { |brand| brand["key"] == brand_key }
+    end
+
+    def brands_list
+        @brands_list["brands"]
+    end
+
+    def find(brand_key)
+        brands = brands_list
+        brands.find { |b| b["key"] == brand_key }
+    end
+
+    def brands_json
+        @brands_list
+    end
+
+    def exists(brand_key)
+        !brand_data(brand_key).nil?
+    end
+
+    def add_brand(brand_name, brand_key)
+        brand = { 'key' => brand_key, 'name' => brand_name }
+        existing_brand = brand_data(brand_key)
+        if existing_brand
+            update_brand(brands_list.index(existing_brand), brand)
+            Solara.logger.debug("#{brand_name} Brand updated in the list.")
+        else
+            brands_list.push(brand)
+            save_brands_list
+            Solara.logger.debug("#{brand_name} added to the list.")
+        end
+    end
+
+    def current_brand
+        JSON.parse(File.read(FilePath.current_brand))
+    end
+
+    def current_brand_content_changed(brand_key)
+        unless is_current_brand(brand_key)
+            return false
+        end
+        current_brand['content_changed'] == true
+    end
+
+    def set_current_brand_content_changed(brand_key, changed)
+        unless is_current_brand(brand_key)
+            return false
+        end
+        Solara.logger.debug("")
+        brand = current_brand
+        brand['content_changed'] = changed
+        save_current_brand_date(brand)
+        Solara.logger.debug("#{brand_key} changed saved to current_brand.json.")
+    end
+
+    def is_current_brand(brand_key)
+        current_brand['key'] == brand_key
+    end
+
+    def save_current_brand(brand_key)
+        brand = brand_data(brand_key)
+        save_current_brand_date(brand)
+        Solara.logger.debug("#{brand_key} saved as current brand.")
+    end
+
+    def save_current_brand_date(brand_data)
+        current_brand = FilePath.current_brand
+
+        # Create the file if it doesn't exist
+        FileUtils.touch(current_brand) unless File.exist?(current_brand)
+
+        File.open(current_brand, 'w') do |file|
+            file.write(JSON.pretty_generate(brand_data))
+        end
+
+    end
+
+    def update_brand(index, new_brand)
+        brands_list[index] = new_brand
+        save_brands_list
+        Solara.logger.debug("Brand updated.")
+    end
+
+    def remove_brand(index)
+        brands_list.delete_at(index)
+        save_brands_list
+        Solara.logger.debug("Brand removed.")
+    end
+
+    def offboard(brand_key)
+        index = brands_list.find_index { |brand| brand["key"] == brand_key }
+        if index
+            brand_dir = FilePath.brand(brand_key)
+            remove_brand(index)
+            FileUtils.rm_rf(brand_dir)
+            save_brands_list
+            Solara.logger.debug("Brand removed.")
+        else
+            Solara.logger.debug("Brand not found (#{brand_key}).")
+        end
+    end
+
+    # Class method to access the singleton instance
+    def self.instance
+        @instance ||= new
+    end
+
+    private
+
+    def save_brands_list
+        brands_list_path = FilePath.brands_list
+        File.open(brands_list_path, 'w') do |file|
+            file.write(JSON.pretty_generate(@brands_list))
+        end
+    end
+
+    private_class_method :new
+end