solara 0.4.0 → 0.6.0

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

@@ -5,23 +5,19 @@ class FileManager
         source_path = Pathname.new(source_dir).expand_path
         destination_path = Pathname.new(destination_dir).expand_path
 
-        if Dir.exist?(source_path)
-          Dir.glob(source_path.join('*')).each do |item|
-            relative_path = Pathname.new(item).relative_path_from(source_path).to_s
-            destination_item_path = destination_path.join(relative_path)
-
-            if File.directory?(item)
-              FileUtils.mkdir_p(destination_item_path)
-              FileUtils.cp_r(item + '/.', destination_item_path) # Ensure to copy contents
-            else
-              FileUtils.mkdir_p(destination_item_path.dirname) # Create parent directory
-              FileUtils.cp(item, destination_item_path)
-            end
+        Dir.glob(source_path.join('*')).each do |item|
+        relative_path = Pathname.new(item).relative_path_from(source_path).to_s
+        destination_item_path = destination_path.join(relative_path)
 
-            Solara.logger.debug("🚗 Copied #{relative_path} \n\t↑ From: #{source_path} \n\t↓ To:   #{destination_path}")
-          end
+        if File.directory?(item)
+            FileUtils.mkdir_p(destination_item_path)
+            FileUtils.cp_r(item + '/.', destination_item_path) # Ensure to copy contents
         else
-          Solara.logger.failure("#{source_path} not found!")
+            FileUtils.mkdir_p(destination_item_path.dirname) # Create parent directory
+            FileUtils.cp(item, destination_item_path)
+        end
+
+        Solara.logger.debug("🚗 Copied #{relative_path} \n\t↑ From: #{source_path} \n\t↓ To:   #{destination_path}")
         end
       end
 

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

@@ -99,6 +99,14 @@ module FilePath
         File.join(brands, brand_key)
     end
 
+    def self.brand_json_dir(brand_key, platform = nil)
+        File.join(brand(brand_key), platform || SolaraSettingsManager.instance.platform, 'json')
+    end
+
+    def self.brand_global_json_dir
+        File.join(global, 'json')
+    end
+
     def self.android_config(brand_key)
         File.join(android_brand_root(brand_key), 'android_config.json')
     end
@@ -116,7 +124,15 @@ module FilePath
     end
 
     def self.brand_fonts
-        File.join(solara_brand, 'global', 'fonts')
+        File.join(global, 'fonts')
+    end
+
+    def self.resources_manifest
+        File.join(global, 'resources_manifest.json')
+    end
+
+    def self.global
+        File.join(solara_brand, 'global')
     end
 
     def self.brand_config(brand_key)
@@ -287,6 +303,10 @@ module FilePath
         File.join(root, 'core', 'template')
     end
 
+    def self.brand_configurations
+        File.join(solara_template, 'configurations.json')
+    end
+
     def self.solara_aliases_json
         File.join(dot_solara, 'aliases', 'aliases.json')
     end

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

@@ -4,7 +4,7 @@ class GitignoreManager
         create_gitignore_if_not_exists
     end
 
-    def self.ignore
+    def self.ignore_common_files
         Solara.logger.start_step("Exclude Brand-Generated Files and Folders from Git")
 
         items = [
@@ -18,9 +18,7 @@ class GitignoreManager
          ]
 
         if Platform.is_flutter || Platform.is_ios
-            items << FileManager.get_relative_path_to_root(FilePath.project_infoplist_string_catalog)
-            # The excluded InfoPlist.xcstrings maybe at the root. In this case we have to avoid ignoring the brands files.
-            items << '!solara/brand/brands/**/InfoPlist.xcstrings'
+            items << "/#{FileManager.get_relative_path_to_root(FilePath.project_infoplist_string_catalog)}"
         end
 
         GitignoreManager.new(FilePath.project_root).add_items(items)
@@ -29,7 +27,7 @@ class GitignoreManager
         
     def add_items(items)
         items.each do |item|
-            add_item(item)
+            add_item(FileManager.get_relative_path_to_root(item))
         end
     end
 
@@ -39,7 +37,15 @@ class GitignoreManager
         if existing_items.include?(item)
             Solara.logger.debug("'#{item}' already exists in .gitignore")
         else
-            File.open(@gitignore_path, 'a') do |file|
+            File.open(@gitignore_path, 'a+') do |file|
+                # Move the file pointer to the beginning to check the last character
+                file.seek(0, IO::SEEK_END)
+                if file.size > 0
+                    # Only add a new line if the last character is not a newline
+                    file.seek(-1, IO::SEEK_END)
+                    last_char = file.getc
+                    file.puts if last_char != "\n"
+                end
                 file.puts(item)
             end
             Solara.logger.debug("Added '#{item}' to .gitignore")

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

@@ -0,0 +1,136 @@
+require 'json'
+
+class JsonManifestProcessor
+  def initialize(json_path, language, output_path)
+    @json_path = json_path
+    @language = language
+    @output_path = output_path
+    @manifest = read_manifest
+  end
+
+  def process
+    # First process files specified in manifest
+    process_manifest_files if @manifest && @manifest['files']
+
+    # Then process remaining JSON files
+    process_remaining_files
+  end
+
+  private
+
+  def read_manifest
+    manifest_path = File.join(@json_path, 'json_manifest.json')
+    JSON.parse(File.read(manifest_path))
+  rescue JSON::ParserError => e
+    Solara.logger.debug("Error parsing manifest JSON: #{e.message}")
+    nil
+  rescue Errno::ENOENT => e
+    Solara.logger.debug("Manifest file not found: #{e.message}")
+    nil
+  rescue StandardError => e
+    Solara.logger.debug("Unexpected error reading manifest: #{e.message}")
+    nil
+  end
+
+  def process_manifest_files
+    @manifest['files'].each do |file|
+      process_manifest_file(file)
+    end
+  end
+
+  def process_manifest_file(file)
+    return unless file['generate']
+
+    file_name = file['fileName']
+    class_name = file['parentClassName']
+
+    return if file_name.empty? || class_name.empty?
+
+    custom_class_names = convert_to_map(file['customClassNames'])
+    process_json_file(
+      File.join(@json_path, file_name),
+      class_name,
+      custom_class_names,
+      true
+    )
+  end
+
+  def process_remaining_files
+    manifest_files = @manifest&.dig('files')&.map { |f| f['fileName'] } || []
+
+    json_files = get_json_files
+    json_files.each do |file_path|
+      file_name = File.basename(file_path)
+      # Skip files that were already processed via manifest
+      next if manifest_files.include?(file_name)
+      next if file_name == 'json_manifest.json'
+
+      class_name = derive_class_name(file_name)
+      process_json_file(file_path, class_name, {}, false)
+    end
+  end
+
+  def get_json_files
+    Dir.glob(File.join(@json_path, '**', '*.json'))
+  rescue StandardError => e
+    Solara.logger.debug("Error reading directory #{@json_path}: #{e.message}")
+    []
+  end
+
+  def process_json_file(file_path, class_name, custom_types, is_manifest_file)
+    begin
+      json_content = JSON.parse(File.read(file_path))
+      code_generator = CodeGenerator.new(
+        json: json_content,
+        language: @language,
+        parent_class_name: class_name,
+        custom_types: custom_types
+      )
+
+      generated_code = code_generator.generate
+      output_path = File.join(@output_path, generated_filename(class_name))
+      write_to_file(output_path, generated_code)
+    rescue JSON::ParserError => e
+      Solara.logger.debug("Error parsing JSON file #{File.basename(file_path)}: #{e.message}")
+    rescue StandardError => e
+      Solara.logger.debug("Error processing file #{File.basename(file_path)}: #{e.message}")
+    end
+  end
+
+  def derive_class_name(file_name)
+    # Remove .json extension and convert to PascalCase
+    base_name = File.basename(file_name, '.json')
+    base_name.split('_').map(&:capitalize).join
+  end
+
+  def convert_to_map(custom_class_names)
+    return {} unless custom_class_names
+    custom_class_names.each_with_object({}) do |item, result|
+      result[item['originalName']] = item['customName']
+    end
+  end
+
+  def generated_filename(class_name)
+    case SolaraSettingsManager.instance.platform
+    when Platform::Flutter
+      "#{to_snake_case(class_name)}.dart"
+    when Platform::IOS
+      "#{class_name}.swift"
+    when Platform::Android
+      "#{class_name}.kt"
+    else
+      raise ArgumentError, "Invalid platform: #{@platform}"
+    end
+  end
+
+  def to_snake_case(string)
+    string.gsub(/[A-Z]/) { |match| "_#{match.downcase}" }.sub(/^_/, '')
+  end
+
+  def write_to_file(output, content)
+    File.write(output, content)
+    Solara.logger.debug("Generated #{output}")
+  rescue StandardError => e
+    Solara.logger.debug("Error writing to file #{output}: #{e.message}")
+  end
+end

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

@@ -2,12 +2,22 @@ require 'json'
 
 module StringCatalogUtils
   def load_string_catalog(path)
+    @path = path
     JSON.parse(File.read(path))
   end
 
   def get_value(data, key, target, language)
     lang = language || data['sourceLanguage']
-    data['strings'][key]['localizations'][lang]['stringUnit'][target]
+    localizations = data.dig('strings', key, 'localizations', lang)
+
+    unless localizations && localizations['stringUnit']
+      error_message = "The default language is #{lang}, but no localizations are available for key '#{key}'. Please address this issue in {@path}. You can easily open the file in Xcode to make the necessary adjustments."
+      Solara.logger.fatal(error_message)
+      exit 1
+    end
+
+    string_unit = localizations['stringUnit']
+    string_unit[target]
   end
 
   def has_value?(data, key, language)

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

@@ -0,0 +1,151 @@
+require 'json'
+require 'fileutils'
+
+class ResourceManifestProcessor
+  def initialize(brand_key, ignore_health_check:)
+    @brand_key = brand_key
+    @ignore_health_check = ignore_health_check
+    @manifest_file = FilePath.resources_manifest
+    @config = load_manifest_file
+  end
+
+  def copy
+    @base_source_path = FilePath.brands
+    @base_destination_path = FilePath.project_root
+    @config['files'].each do |item|
+      process_file_item(item)
+    end
+  end
+
+  private
+
+  def clean(item, src, dst)
+    paths = destinations(item, src, dst)
+    paths.each do |path|
+      File.delete(path) if File.exist?(path)
+    end
+  end
+
+  def process_file_item(item)
+    src = resolve_source_path(@brand_key, item['source'], @base_source_path)
+    dst = File.join(@base_destination_path, item['destination'])
+
+    clean(item, src, dst)
+
+    return skip_empty_paths(item) if empty_paths?(item)
+
+    check_mandatory_file(item, src)
+
+    if File.exist?(src)
+      copy_file(src, dst)
+      git_ignore(destinations(item, src, dst))
+    else
+      log_file_not_found(item)
+    end
+  end
+
+  def destinations(item, src, dst, visited = {})
+    return [] if visited[src]
+
+    visited[src] = true  # Mark the current source as visited
+
+    if File.file?(src)
+      if File.directory?(dst)
+        return [File.join(dst, File.basename(src))]
+      else
+        return [dst]
+      end
+    elsif File.directory?(src)
+      return destinations_of_directory_contents(src, dst)
+    end
+
+    if !item['mandatory'] && !File.file?(src)
+      return get_optional_resource_destination(item, dst, visited)
+    end
+
+    []
+  end
+
+  def get_optional_resource_destination(item, dst, visited)
+    return [] if item['mandatory']
+    keys = BrandsManager.instance.brands_list.map { |brand| brand['key'] }
+    keys.each do |key|
+      src = resolve_source_path(key, item['source'], @base_source_path)
+      result = destinations(item, src, dst, visited)
+      return result unless result.empty?
+    end
+    []
+  end
+
+  def destinations_of_directory_contents(src_dir, dst_dir)
+    items = []
+    Dir.foreach(src_dir) do |file|
+      next if file == '.' || file == '..'
+      full_dst_path = File.join(dst_dir, file)
+      items << full_dst_path
+    end
+    items
+  end
+
+  def git_ignore(files)
+    files.each do |file|
+      GitignoreManager.new(FilePath.project_root).add_items(["/#{file}"])
+    end
+  end
+
+  def resolve_source_path(brand_key, source, base_source_path)
+    source.gsub(/\{.*?\}/, brand_key).prepend(base_source_path + '/')
+  end
+
+  def empty_paths?(item)
+    item['source'].empty? || item['destination'].empty?
+  end
+
+  def skip_empty_paths(item)
+    Solara.logger.debug("Skipped (empty source or destination) for #{@brand_key}: #{item['source']} -> #{item['destination']}")
+  end
+
+  def check_mandatory_file(item, src)
+    return if @ignore_health_check
+
+    if item['mandatory'] && !File.exist?(src)
+      raise "Mandatory resource file/folder not found for #{@brand_key}: #{src}. Please add the resource or mark it as not mandatory in #{FilePath.resources_manifest}."
+    end
+
+  end
+
+  def copy_file(src, dst)
+    if File.directory?(src)
+      FileUtils.mkdir_p(dst)
+      FileUtils.cp_r(File.join(src, '.'), dst)
+    else
+      FileUtils.mkdir_p(File.dirname(dst))
+      FileUtils.cp(src, dst)
+    end
+    Solara.logger.debug("Copied resource for #{@brand_key}: #{File.basename(src)} to #{File.basename(dst)}")
+  end
+
+  def log_file_not_found(item)
+    Solara.logger.debug("Skipped resource (not found) for #{@brand_key}: #{item['source']}")
+  end
+
+  def load_manifest_file
+    validate_manifest_file_existence
+    parse_manifest_file
+  end
+
+  def validate_manifest_file_existence
+    unless File.exist?(@manifest_file)
+      raise "Resources manifest not found for #{@brand_key}: #{@manifest_file}"
+    end
+  end
+
+  def parse_manifest_file
+    begin
+      JSON.parse(File.read(@manifest_file))
+    rescue JSON::ParserError => e
+      raise "Invalid resources manifest for #{@brand_key}: #{e.message}"
+    end
+  end
+
+end

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

@@ -37,7 +37,7 @@ class SolaraStatusManager
         
             solara dashboard -k #{current_brand['key']}
      
-            Then, click the "Apply Changes" button.
+            Then, click the "Sync" button.
         MESSAGE
         Solara.logger.info(message)
     end