solara 0.1.0

data/solara/lib/core/template/config/flutter_template_config.json

@@ -0,0 +1,62 @@
+{
+    "files": [
+        {
+            "source": "brands.json",
+            "target": "../brands.json",
+            "condition": "true"
+        },
+        {
+            "source": "android/assets/",
+            "target": "android/assets/",
+            "condition": "true" 
+        },
+        {
+            "source": "android/res/",
+            "target": "android/res/",
+            "condition": "true" 
+        },
+        {
+            "source": "android/android_config.json",
+            "target": "android/android_config.json",
+            "condition": "true" 
+        },
+        {
+            "source": "android/android_signing.json",
+            "target": "android/android_signing.json",
+            "condition": "true"
+        },
+        {
+            "source": "ios/assets/",
+            "target": "ios/assets/",
+            "condition": "true" 
+        },
+        {
+            "source": "ios/ios_config.json",
+            "target": "ios/ios_config.json",
+            "condition": "true"  
+        },
+        {
+            "source": "ios/ios_signing.json",
+            "target": "ios/ios_signing.json",
+            "condition": "true"
+        },
+        {
+            "source": "shared/assets/",
+            "target": "shared/assets/",
+            "condition": "true"
+        },
+        {
+            "source": "shared/theme.json",
+            "target": "shared/theme.json",
+            "condition": "true"
+        },
+        {
+            "source": "shared/brand_config.json",
+            "target": "shared/brand_config.json",
+            "condition": "true"
+        }
+    ],
+    "variables": {
+        "platform": "flutter"
+    }
+}

data/solara/lib/core/template/config/ios_template_config.json

@@ -0,0 +1,57 @@
+{
+    "files": [
+        {
+            "source": "brands.json",
+            "target": "../brands.json",
+            "condition": "true"
+        },
+        {
+            "source": "android/assets/",
+            "target": "android/assets/",
+            "condition": "true" 
+        },
+        {
+            "source": "android/res/",
+            "target": "android/res/",
+            "condition": "true" 
+        },
+        {
+            "source": "android/android_config.json",
+            "target": "android/android_config.json",
+            "condition": "true" 
+        },
+        {
+            "source": "android/android_signing.json",
+            "target": "android/android_signing.json",
+            "condition": "true"
+        },
+        {
+            "source": "ios/assets/",
+            "target": "ios/assets/",
+            "condition": "true" 
+        },
+        {
+            "source": "ios/ios_config.json",
+            "target": "ios/ios_config.json",
+            "condition": "true"  
+        },
+        {
+            "source": "ios/ios_signing.json",
+            "target": "ios/ios_signing.json",
+            "condition": "true"
+        },
+        {
+            "source": "shared/theme.json",
+            "target": "shared/theme.json",
+            "condition": "true"
+        },
+        {
+            "source": "shared/brand_config.json",
+            "target": "shared/brand_config.json",
+            "condition": "true"
+        }
+    ],
+    "variables": {
+        "platform": "ios"
+    }
+}

data/solara/lib/core/template/project_template_generator.rb

@@ -0,0 +1,63 @@
+require 'fileutils'
+require 'json'
+
+class ProjectTemplateGenerator
+  def initialize(template_dir, target_dir, config_file)
+    @template_dir = template_dir
+    @target_dir = target_dir
+    @config_file = config_file
+    @config = read_config
+  end
+
+  def create_project
+    @config["files"].each do |file|
+      if evaluate_condition(file["condition"], @config["variables"])
+        source_path = File.join(@template_dir, file["source"])
+        target_path = File.join(@target_dir, file["target"])
+
+        copy_content = file.fetch("copy_content", true)
+        copy_item(source_path, target_path, copy_content)
+        replace_variables(target_path, @config["variables"]) if copy_content
+      end
+    end
+  end
+
+  private
+
+  def read_config
+    JSON.parse(File.read(@config_file))
+  end
+
+  def evaluate_condition(condition, variables)
+    true
+  end
+
+  def copy_item(source, target, copy_content)
+    if File.directory?(source)
+      FileUtils.mkdir_p(target)
+      Dir.foreach(source) do |item|
+        next if item == '.' || item == '..'
+        copy_item(File.join(source, item), File.join(target, item), copy_content)
+      end
+    else
+      FileUtils.mkdir_p(File.dirname(target))
+      if File.exist?(source) && copy_content
+        FileUtils.cp(source, target)
+      else
+        FileUtils.touch(target)
+      end
+    end
+  end
+
+  def replace_variables(file_path, variables)
+    return unless File.exist?(file_path) && File.file?(file_path)
+
+    content = File.read(file_path)
+    
+    variables.each do |key, value|
+      content.gsub!(/\{\{#{key}\}\}/, value.to_s)
+    end
+    
+    File.write(file_path, content)
+  end
+end

data/solara/lib/platform_detector.rb

@@ -0,0 +1,84 @@
+require 'find'
+
+class PlatformDetector
+    def initialize
+        @project_path = SolaraSettingsManager.instance.project_root
+    end
+
+    def platform
+        Solara.logger.start_step("Detecting current platform")
+        detected_platform = detect
+
+        if detected_platform != Platform::Unknown
+            Solara.logger.info("👀 Detected platform: #{detected_platform}")
+        else
+            Solara.logger.failure("Unable to detect platfrom")
+            return enter_correct_platform
+        end
+
+        print "Is this #{detected_platform.upcase} project? (y/n): ".yellow
+
+        loop do
+            response = STDIN.gets.chomp.downcase
+            if response == 'y' || response.empty?
+                Solara.logger.end_step("Detecting current platform")
+                return detected_platform
+            elsif response == 'n'
+                return enter_correct_platform
+            else
+                Solara.logger.failure("Invalid input. Please enter 'y' or 'n'.")
+            end
+        end
+    end
+
+    private
+
+    def enter_correct_platform
+        loop do
+            print "Enter the platform (#{Platform.all.join(', ')}): ".green
+            user_input = STDIN.gets.chomp.downcase
+            if Platform.all.map(&:downcase).include?(user_input)
+                Solara.logger.end_step("Detecting current platform")
+                return user_input
+            else
+                Solara.logger.failure("Invalid platform. Please enter one of: #{Platform.all.join(', ')}")
+            end
+        end
+    end
+
+    def detect
+        if flutter?
+            Platform::Flutter
+        elsif ios?
+            Platform::IOS
+        elsif android?
+            Platform::Android
+        else
+            Platform::Unknown
+        end
+    end
+
+    def flutter?
+        flutter_config_file = File.join(@project_path, 'pubspec.yaml')
+        flutter_main_file = File.join(@project_path, 'lib', 'main.dart')
+        File.exist?(flutter_config_file) && File.exist?(flutter_main_file)
+    end
+
+    def ios?
+        ios_project_files = []
+        Find.find(@project_path) do |path|
+            if File.directory?(path) && (path.end_with?('.xcodeproj') || path.end_with?('.xcworkspace'))
+                ios_project_files << path
+                Find.prune # Stop searching further in this directory
+            end
+        end
+        !ios_project_files.empty?
+    end
+
+    def android?
+        app_build_gradle = File.join(@project_path, 'app', 'build.gradle')
+        app_build_gradle_kts = File.join(@project_path, 'app', 'build.gradle.kts')
+        gradle_properties = File.join(@project_path, 'gradle.properties')
+        (File.exist?(app_build_gradle) || File.exist?(app_build_gradle_kts)) && File.exist?(gradle_properties)
+    end
+end

data/solara/lib/solara/cli.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'solara'
+
+Solara::CLI.start(ARGV)

data/solara/lib/solara/version.rb

@@ -0,0 +1,3 @@
+module Solara
+  VERSION = "0.1.0"
+end

data/solara/lib/solara.rb

@@ -0,0 +1,238 @@
+require 'thor'
+require 'fileutils'
+Dir['*.rb'].each { |file| require_relative file }
+Dir.glob("#{__dir__}/core/scripts/*.rb").each { |file| require file }
+require 'solara_manager'
+require 'rubygems'
+
+module Solara
+    ROOT = Pathname.new(File.expand_path('..', __FILE__))
+    PROJECT_ROOT = Dir.pwd
+
+    class << self
+        attr_reader :logger
+        attr_reader :verbose
+
+        def verbose=(value)
+            @verbose = value
+            @logger.verbose = value
+        end
+    end
+
+    @logger = SolaraLogger.new
+    @verbose = false
+
+    class Setup
+        def setup
+            SolaraSettingsManager.instance.root = ROOT
+            SolaraSettingsManager.instance.project_root = PROJECT_ROOT
+
+            Solara.logger.debug("Solara installation at path: #{PROJECT_ROOT}")
+        end
+    end
+
+    class CLI < Thor
+        class_option :verbose, type: :boolean, :aliases => "-v", default: false, desc: 'Run verbosely'
+
+        def initialize(*args)
+            super
+            setup
+        end
+
+        def self.exit_on_failure?
+            true
+        end
+
+        desc "init -p YOUR_PLATFORM -k YOUR_BRAND_KEY -n YOUR_BRAND_NAME",
+             "Initialize Solara. Options: #{Platform.all.join(', ')}"
+        method_option :brand_key, :type => :string, :aliases => "-k"
+        method_option :brand_name, :type => :string, :aliases => "-n"
+        method_option :platform, :type => :string, :aliases => "-p"
+
+        def init
+            brand_key = options['brand_key']
+            brand_name = options['brand_name']
+            input_platform = options['platform']
+
+            brand_key = validate_brand_key(brand_key, ignore_brand_check: true)
+            brand_name = validate_brand_name(brand_name)
+
+            platform = if !input_platform.nil?
+                           input_platform
+                       else
+                           PlatformDetector.new.platform
+                       end
+
+            platform = platform.to_s.downcase
+
+            SolaraSettingsManager.instance.platform = platform
+            SolaraManager.new.init(platform, brand_key, brand_name)
+        end
+
+        desc "status", "Check the current status of Solara. The results may include information about the brand's current standing, the list of brands, and additional details."
+
+        def status
+            check_project_health
+            SolaraManager.new.status
+        end
+
+        desc "import -configurations CONFIGURATIONS_JSON_FILE --brand_key YOUR_BRAND_KEY", "Import the brand's configurations. If the brand is existing, it will be updated with these configurations, otherwise, a new brand will be onboarded."
+
+        method_option :configurations, :type => :array, :aliases => "-c"
+        def import
+            check_project_health
+
+            configurations = options['configurations']
+
+            SolaraManager.new.import(configurations)
+        end
+
+
+        desc "export --brand_key YOUR_BRAND_KEY --directory DIRECTORY", "Export the brand's configurations. The brand details will be saved to a JSON file at the specified location."
+        method_option :brand_keys, :type => :array, :aliases => "-k"
+        method_option :directory, :type => :string, :aliases => "-d"
+        def export
+            check_project_health
+
+            brand_keys = options['brand_keys']
+            directory = options['directory']
+
+
+            SolaraManager.new.export(brand_keys, directory)
+        end
+
+        desc "onboard -k YOUR_BRAND_KEY -n YOUR_BRAND_NAME", "Onboard a new brand"
+        method_option :brand_key, :type => :string, :aliases => "-k"
+        method_option :brand_name, :type => :string, :aliases => "-n"
+        method_option :clone, :type => :string, :aliases => "-c"
+
+        def onboard
+            check_project_health
+
+            brand_key = options['brand_key']
+            brand_name = options['brand_name']
+            clone_brand_key = options['clone']
+
+            brand_key = validate_brand_key(brand_key, ignore_brand_check: true)
+            brand_name = validate_brand_name(brand_name)
+
+            unless clone_brand_key.nil? || clone_brand_key.empty?
+                clone_brand_key = validate_brand_key(clone_brand_key, message: "Clone brand key is not existing, please enter correct key: ")
+            end
+
+            SolaraManager.new.onboard(brand_key, brand_name, clone_brand_key: clone_brand_key)
+        end
+
+        desc "offboard -k YOUR_BRAND_KEY", "Offboard a brand by deleting it from brands."
+        method_option :brand_key, :type => :string, :aliases => "-k"
+
+        def offboard
+            check_project_health
+            brand_key = options['brand_key']
+            brand_key = validate_brand_key(brand_key)
+            SolaraManager.new.offboard(brand_key)
+        end
+
+        desc "`switch -k YOUR_BRAND_KEY", "Switch to a brand."
+        method_option :brand_key, :type => :string, :aliases => "-k"
+
+        def switch
+            check_project_health
+            brand_key = options['brand_key']
+            brand_key = validate_brand_key(brand_key)
+            begin
+                SolaraManager.new.switch(brand_key)
+            rescue StandardError => e
+                Solara.logger.fatal("Switching to #{brand_key} failed.")
+                exit 1
+            end
+
+        end
+
+        desc "dashboard -k YOUR_OPTIONAL_BRAND_KEY", "Open the dashboard for a brand if brank_key is provided."
+        method_option :brand_key, :type => :string, :aliases => "-k"
+        method_option :port, :type => :numeric, :aliases => "-p"
+
+        def dashboard
+            check_project_health
+            brand_key = options['brand_key']
+            brand_key = validate_brand_key(brand_key, ignore_if_nil: true)
+            SolaraManager.new.dashboard(brand_key, options['port'] || 8000)
+        end
+
+        desc "doctor -k YOUR_BRAND_KEY", "Visit Doctor for a brand if brankd_key provided."
+        method_option :brand_key, :type => :string, :aliases => "-k"
+
+        def doctor
+            check_project_health
+            brand_key = options['brand_key']
+            brand_key = validate_brand_key(brand_key, ignore_if_nil: true)
+            SolaraManager.new.doctor(brand_key)
+        end
+
+        private
+
+        # Ensure the platform is set when Solara is initialized but the platform is not set
+        # This happens in scenarios like cloning the project and running Solara, In this case the
+        # platfrom is not set yet.
+        def ensure_platform
+            brands = FilePath.brands
+            platform = SolaraSettingsManager.instance.platform || ''
+            if File.exist?(brands) && platform.empty?
+                SolaraSettingsManager.instance.platform = PlatformDetector.new.platform
+            end
+        end
+
+        def check_project_health
+            DoctorManager.new.visit_project!
+        end
+
+        def validate_brand_key(brand_key, ignore_if_nil: false, ignore_brand_check: false, message: nil)
+            if ignore_if_nil && brand_key.nil?
+                return brand_key
+            end
+
+                if brand_key.nil? || brand_key.empty? || (!ignore_brand_check && BrandsManager.instance.find(brand_key).nil?)
+                message = message || (brand_key.nil? || brand_key.empty? ? "Please enter brand key: " : "Please enter existing brand key: ")
+                brand_key = TerminalInputManager.new.get_validated(message) do |input|
+                    # Validate that it starts with a letter and contains no spaces
+                    unless input.match?(/^[a-zA-Z][\S]*$/)
+                        Solara.logger.failure("Invalid brand key.  It must start with at least a letter and contain no spaces.")
+                        next false # Use `next` to continue the loop
+                    end
+
+                    # Check if the brand exists in the list
+                    if !ignore_brand_check && BrandsManager.instance.find(input).nil?
+                        Solara.logger.failure("Brand key does not exist.")
+                        next false # Use `next` to continue the loop
+                    end
+
+                    true # Valid input and brand exists
+                end
+            end
+
+            # If brand_key is valid and exists, return it
+            brand_key
+        end
+
+        def validate_brand_name(brand_name)
+            if brand_name.nil? || brand_name.empty?
+                message = "Please enter brand name: "
+                return TerminalInputManager.new.get(message)
+            end
+            brand_name
+        end
+
+
+        def setup
+            Solara.logger.verbose = options[:verbose] || false
+
+            ensure_platform
+
+            # Solara version is mandatory because the structure and logic may change in the future and need to migrate.
+            SolaraVersionManager.instance.version = Gem.loaded_specs['solara'].version.to_s
+        end
+
+    end
+
+end

data/solara/lib/solara_initializer.rb

@@ -0,0 +1,44 @@
+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 'json'
+require 'xcodeproj'
+
+class SolaraInitializer
+
+    def initialize(brand_key, brand_name)
+        @brand_key = brand_key
+        @brand_name = brand_name
+        @project_root = SolaraSettingsManager.instance.project_root
+    end
+
+    def init
+        Solara.logger.header("Initializing Solara")
+        confirm_init_if_necessary
+        message = "Initialized #{SolaraSettingsManager.instance.platform} successfully."
+        SolaraManager.new.onboard(@brand_key, @brand_name, init: true, success_message: message)
+    end
+
+    def confirm_init_if_necessary
+        brand_path = File.join(FilePath.solara, 'brands')
+        # Check if Solara path exists
+        if Dir.exist?(brand_path)
+            Solara.logger.warn("Solara already initialized! Be aware that reinitializing will delete all current brands!")
+            Solara.logger.warn("Don't say I didn't warn you!")
+            Solara.logger.warn("Do you want to proceed? (y/n)")
+            confirmation = STDIN.gets.chomp.downcase
+
+            unless confirmation == 'y'
+                Solara.logger.info("Solara initialization cancelled.")
+                exit 1
+            end
+            FileUtils.rm_rf(brand_path)
+        end
+    end
+
+end

data/solara/lib/solara_manager.rb

@@ -0,0 +1,73 @@
+Dir.glob("#{__dir__}/*.rb").each { |file| require file }
+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 'json'
+require 'xcodeproj'
+
+class SolaraManager
+
+    def initialize
+    end
+
+    def init(platform, brand_key, brand_name)
+        SolaraInitializer.new(brand_key, brand_name).init
+    end
+
+    def import(configurations)
+        BrandImporter.new.start(configurations)
+    end
+
+    def export(brand_keys, path)
+        BrandExporter.new.start(brand_keys, path)
+    end
+
+    def status
+        SolaraStatusManager.new.start
+    end
+
+    def onboard(brand_key, brand_name, init: false, clone_brand_key: nil, open_dashboard: true, success_message: nil)
+        Solara.logger.header("Onboarding #{brand_key}")
+
+        if !init && BrandsManager.instance.exists(brand_key)
+            Solara.logger.fatal("Brand with key (#{brand_key}) already added to brands!")
+            return
+        end
+
+        BrandOnboarder.new(brand_key, brand_name, clone_brand_key: clone_brand_key).onboard
+
+        switch(brand_key, ignore_health_check: true)
+
+        clone_message = clone_brand_key.nil? || clone_brand_key.empty? ? '.' : ", cloned from #{clone_brand_key}."
+        message = success_message || "Onboarded #{brand_key} successfully#{clone_message}"
+        Solara.logger.success(message)
+
+        if open_dashboard
+            Solara.logger.success("Openning the dashboard for #{brand_key} to complete its details.")
+            dashboard(brand_key)
+        end
+    end
+
+    def offboard(brand_key, confirm: true)
+        BrandOffboarder.new.offboard(brand_key, confirm: confirm)
+    end
+
+    def switch(brand_key, ignore_health_check: false)
+        BrandSwitcher.new(brand_key, ignore_health_check: ignore_health_check).start
+    end
+
+    def dashboard(brand_key, port = 8000)
+        DashboardManager.new.start(brand_key, port)
+    end
+
+    def doctor(brand_key = nil, print_logs: true)
+        keys = brand_key.nil? || brand_key.empty? ? [] : [brand_key]
+        DoctorManager.new.visit_brands(keys, print_logs: print_logs)
+    end
+
+end