ccios 4.1.0 → 5.1.0

data/lib/ccios/config.rb

@@ -2,11 +2,12 @@ require 'yaml'
 
 class Config
 
-  attr_reader :app, :core, :data, :templates
+  attr_reader :variables, :templates_collection
 
   def self.parse(source_path)
     if File.exist?(source_path)
       config = YAML.load_file(source_path)
+      raise "Invalid config file" unless config.is_a?(Hash)
       self.new config, source_path
     else
       puts "File #{source_path} does not exist. Using default config."
@@ -14,120 +15,69 @@ class Config
     end
   end
 
-  def self.default_config_hash
-    project = "*.xcodeproj"
-    {
-      "app" => {
-        "project" => project,
-        "presenter" => {"group" => "Classes/App"},
-        "coordinator" => {"group" => "Classes/Coordinator"}
-      },
-      "core" => {
-        "project" => project,
-        "interactor" => {"group" => "Classes/Core/Interactor"},
-        "repository" => {"group" => "Classes/Core/Data"}
-      },
-      "data" => {
-        "project" => project,
-        "repository" => {"group" => "Classes/Data"}
-      },
-      "templates" => self.default_templates_hash
-    }
-  end
-
   def self.default
     self.new default_config_hash
   end
 
-  def self.default_templates_hash
-    { "path" => File.join(File.dirname(__FILE__), "templates") }
+  def self.default_config_hash
+    {}
   end
 
   def initialize(config_hash, source_path = nil)
-    @source_path = source_path
-    validate config_hash
-    @app = AppConfig.new config_hash["app"]
-    @core = CoreConfig.new config_hash["core"]
-    @data = DataConfig.new config_hash["data"]
-    if config_hash["templates"].nil?
-      @templates = TemplatesConfig.new Config.default_templates_hash
-    else
-      @templates = TemplatesConfig.new config_hash["templates"]
+    @variables = config_hash["variables"] || {}
+    @templates_collection = config_hash["templates_collection"] || nil
+    @templates_config = {}
+
+    raise "Invalid \"templates_collection\" in config, should be a string" unless @templates_collection.is_a?(String) || @templates_collection.nil?
+
+    templates_config = config_hash["templates_config"] || {}
+    raise "Invalid \"templates_config\" in configuration, it should be a dictionary" unless templates_config.is_a?(Hash)
+    templates_config.each do |key, hash|
+      raise "Invalid template configuration for \"#{key}\"" unless hash.is_a?(Hash)
+      template_config = TemplateConfig.new(hash)
+      @templates_config[key] = template_config
     end
   end
 
-  def validate(hash)
-    validate_path hash, "app.project"
-    validate_path hash, "app.presenter.group"
-    validate_path hash, "app.coordinator.group"
-
-    validate_path hash, "core.project"
-    validate_path hash, "core.interactor.group"
-    validate_path hash, "core.repository.group"
-
-    validate_path hash, "data.project"
-    validate_path hash, "data.repository.group"
+  def variables_for_template(template)
+    template_config = @templates_config[template.name] || TemplateConfig.new({})
+    @variables.merge(template.variables).merge(template_config.variables)
   end
 
-  def validate_path(hash, path)
-    components = path.split(".")
-    keys = []
-    components.each do |component|
-      hash = hash[component]
-      keys << component
-      if hash.nil?
-        message = "Key \"#{keys.join(".")}\" is missing"
-        message += " in #{@source_path}" unless @source_path.nil?
-        raise message
-      end
-    end
+  def variables_for_template_element(template, element_name, element_default_variables = {})
+    template_config = @templates_config[template.name] || TemplateConfig.new({})
+    element_config = template_config.element_configuration_for(element_name)
+    template_variables = @variables.merge(template.variables).merge(template_config.variables)
+    template_variables.merge(element_default_variables).merge(element_config.variables)
   end
 end
 
-class AppConfig
-  attr_reader :project, :target, :presenter, :coordinator
+class TemplateConfig
 
-  def initialize(hash)
-    @project = hash["project"]
-    @target = hash["target"]
-    @presenter = ObjectConfig.new hash["presenter"]
-    @coordinator = ObjectConfig.new hash["coordinator"]
-  end
-end
-
-class CoreConfig
-  attr_reader :project, :target, :interactor, :repository
+  attr_reader :variables
 
   def initialize(hash)
-    @project = hash["project"]
-    @target = hash["target"]
-    @interactor = ObjectConfig.new hash["interactor"]
-    @repository = ObjectConfig.new hash["repository"]
+    @variables = hash["variables"] || {}
+    @template_element_config = {}
+
+    elements_variables = hash["elements_variables"] || {}
+    raise "Invalid configuration, \"elements_variables\" should be a dictionary" unless elements_variables.is_a?(Hash)
+    elements_variables.each do |key, hash|
+      raise "Invalid element variable configuration for \"#{key}\"" unless hash.is_a?(Hash)
+      @template_element_config[key] = TemplateElementConfig.new(hash)
+    end
   end
-end
 
-class DataConfig
-  attr_reader :project, :target, :repository
-
-  def initialize(hash)
-    @project = hash["project"]
-    @target = hash["target"]
-    @repository = ObjectConfig.new hash["repository"]
+  def element_configuration_for(element)
+    @template_element_config[element] || TemplateConfig.new({})
   end
 end
 
-class ObjectConfig
-  attr_reader :group
+class TemplateElementConfig
 
-  def initialize(hash)
-    @group = hash["group"]
-  end
-end
-
-class TemplatesConfig
-  attr_reader :path
+  attr_reader :variables
 
   def initialize(hash)
-    @path = hash["path"]
+    @variables = hash
   end
-end
+end

data/lib/ccios/file_creator.rb

@@ -1,6 +1,7 @@
 require_relative 'code_templater'
 require 'fileutils'
 require 'logger'
+require 'xcodeproj'
 
 class Xcodeproj::Project::Object::PBXGroup
 
@@ -14,6 +15,13 @@ class Xcodeproj::Project::Object::PBXGroup
   end
 end
 
+class Xcodeproj::Project
+
+  def project_name_from_path
+    File.basename(@path, File.extname(@path))
+  end
+end
+
 class FileCreator
 
   def self.logger
@@ -24,40 +32,55 @@ class FileCreator
     FileCreator.logger
   end
 
-  def initialize(options = {}, config)
-    @options = options
-    @config = config
-  end
-
-  def templater_options(target)
+  def templater_options(targets, project)
     defaults = {
-      project_name: target.display_name,
       full_username: git_username,
       date: DateTime.now.strftime("%d/%m/%Y"),
     }
-    defaults.merge(@options)
+    if targets.count == 1
+      defaults["project_name"] = targets[0].display_name
+    else
+      defaults["project_name"] = project.project_name_from_path
+    end
+    defaults
   end
 
   def git_username
     `git config user.name`.strip
   end
 
-  def create_file(prefix, suffix, group, target)
-    file_path = File.join(group.real_path, prefix + suffix + '.swift')
+  def get_unknown_template_tags_for(template_path)
+    tags = CodeTemplater.new.get_unknown_context_keys_for_template(template_path)
+    tags.subtract(Set["project_name", "full_username", "date"])
+    tags
+  end
+
+  def create_file_using_template_path(template_path, generated_filename, group, targets, project, context)
+    file_path = File.join(group.real_path, generated_filename)
 
     raise "File #{file_path} already exists" if File.exist?(file_path)
     dirname = File.dirname(file_path)
     FileUtils.mkdir_p dirname unless File.directory?(dirname)
     file = File.new(file_path, 'w')
 
-    templater_options = templater_options(target)
-    code_templater = CodeTemplater.new(templater_options, @config.templates.path)
-    file_content = code_templater.content_for_suffix(prefix, suffix)
+    context = context.merge(templater_options(targets, project))
+    file_content = CodeTemplater.new.render_file_content_from_template(template_path, generated_filename, context)
+
     file.puts(file_content)
 
     file.close
     file_ref = group.new_reference(file_path)
-    target.add_file_references([file_ref])
+    targets.each do |target|
+      target.add_file_references([file_ref])
+    end
+  end
+
+  def print_file_content_using_template(filename, template_path, context)
+    file_content = CodeTemplater.new.render_file_content_from_template(template_path, filename, context)
+    Mustache.render(File.read(template_path), context)
+
+    logger.info "Add this snippet to #{filename}"
+    logger.info file_content
   end
 
   def create_empty_directory(group)
@@ -68,16 +91,6 @@ class FileCreator
     FileUtils.touch(git_keep_path) if Dir.empty?(dirname)
   end
 
-  def print_file_content(prefix, suffix)
-    file_name = suffix + '.swift'
-
-    code_templater = CodeTemplater.new(@options, @config.templates.path)
-    template = code_templater.content_for_suffix(prefix, suffix)
-
-    logger.info "Add this snippet to #{file_name}"
-    logger.info template
-  end
-
   private
 
   def self.create_logger

data/lib/ccios/file_template_definition.rb

@@ -0,0 +1,95 @@
+require_relative 'code_templater'
+require_relative 'file_creator'
+require_relative 'pbxproj_parser'
+
+class FileTemplateDefinition
+  def initialize(file_template_definition_hash)
+    @name = file_template_definition_hash["name"]
+    @path = file_template_definition_hash["file"]
+    @template = file_template_definition_hash["template"]
+    @variables = file_template_definition_hash["variables"] || {}
+  end
+
+  def validate(parser, project, context, template_definition, config)
+
+    merged_variables = config.variables_for_template_element(template_definition, @name, @variables)
+
+    code_templater = CodeTemplater.new
+    expected_context_keys = template_definition.provided_context_keys
+    pathTags = code_templater.get_unknown_context_keys_for_string(@path)
+    pathTags.each do |tag|
+      raise "Unknown parameter \"#{tag}\" in path \"#{@path}\"" unless expected_context_keys.include?(tag)
+    end
+
+    file_path = code_templater.render_string(@path, context)
+    raise "File #{file_path} already exists" if File.exist?(file_path)
+
+    file_creator = FileCreator.new
+    contentTags = file_creator.get_unknown_template_tags_for(template_definition.template_source_file(@template))
+    contentTags.each do |tag|
+      raise "Unknown parameter \"#{tag}\" in template \"#{@template}\"" unless expected_context_keys.include?(tag)
+    end
+
+    base_path = merged_variables["base_path"]
+    raise "Missing base_path variable" if base_path.nil?
+
+    base_group = project[base_path]
+    raise "Base path \"#{base_path}\" is missing" if base_group.nil?
+
+    target_name = merged_variables["target"]
+    if target_name.is_a?(String) || target_name.nil?
+      target = parser.target_for(project, target_name)
+      raise "Unable to find target \"#{target_name}\"" if target.nil?
+    elsif target_name.is_a?(Array)
+      target_name.each do |target_name|
+        target = parser.target_for(project, target_name)
+        raise "Unable to find target \"#{target_name}\"" if target.nil?
+      end
+    else
+      raise "Invalid target in template #{@name}"
+    end
+
+  end
+
+  def generate(parser, project, context, template_definition, config)
+    merged_variables = config.variables_for_template_element(template_definition, @name, @variables)
+
+    base_path = merged_variables["base_path"]
+    base_group = project[base_path]
+    file_path = CodeTemplater.new.render_string(@path, context)
+
+    intermediates_groups = file_path.split("/")[0...-1]
+    generated_filename = file_path.split("/")[-1]
+
+    group = base_group
+    associate_path_to_group = !base_group.path.nil?
+
+    intermediates_groups.each do |group_name|
+      new_group_path = File.join(group.real_path, group_name)
+      existing_group = group.groups.find { |g| g.display_name == group_name }
+      group = existing_group || group.pf_new_group(
+        associate_path_to_group: associate_path_to_group,
+        name: group_name,
+        path: new_group_path
+      )
+    end
+
+    target_name = merged_variables["target"]
+
+    targets = []
+    if target_name.is_a?(String) || target_name.nil?
+      targets = [parser.target_for(project, target_name)]
+    elsif target_name.is_a?(Array)
+      targets = target_name.map { |name| parser.target_for(project, name) }
+    end
+
+    FileCreator.new.create_file_using_template_path(
+      template_definition.template_source_file(@template),
+      generated_filename,
+      group,
+      targets,
+      project,
+      context
+    )
+  end
+end

data/lib/ccios/flag_template_parameter.rb

@@ -0,0 +1,17 @@
+class FlagTemplateParameter
+  attr_reader :name, :short_name, :description, :template_variable_name
+
+  def initialize(parameter_template_definition_hash)
+    @name = parameter_template_definition_hash["flag"]
+    @short_name = parameter_template_definition_hash["short_name"]
+    @description = parameter_template_definition_hash["description"] || ""
+    @template_variable_name = parameter_template_definition_hash["template_variable_name"] || @name
+
+    raise "Missing flag name" if @name.nil? || @name.empty?
+    raise "Invalid flag template_variable_name for #{@name}" if @template_variable_name.nil? || template_variable_name.empty?
+  end
+
+  def provided_context_keys
+    [@template_variable_name]
+  end
+end

data/lib/ccios/group_template_definition.rb

@@ -0,0 +1,54 @@
+require_relative 'code_templater'
+require_relative 'file_creator'
+require_relative 'pbxproj_parser'
+
+class GroupTemplateDefinition
+  def initialize(group_template_definition_hash)
+    @name = group_template_definition_hash["name"]
+    @path = group_template_definition_hash["group"]
+    @template = group_template_definition_hash["path"]
+    @variables = group_template_definition_hash["variables"] || {}
+  end
+
+  def validate(parser, project, context, template_definition, config)
+    merged_variables = config.variables_for_template_element(template_definition, @name, @variables)
+
+    code_templater = CodeTemplater.new
+    pathTags = code_templater.get_unknown_context_keys_for_string(@path)
+    pathTags.each do |tag|
+      raise "Unknown parameter \"#{tag}\" in path \"#{@path}\"" if context[tag].nil?
+    end
+
+    base_path = merged_variables["base_path"]
+    raise "Missing base_path variable" if base_path.nil?
+
+    base_group = project[base_path]
+    raise "Base path \"#{base_path}\" is missing" if base_group.nil?
+  end
+
+  def generate(parser, project, context, template_definition, config)
+    merged_variables = config.variables_for_template_element(template_definition, @name, @variables)
+
+    base_path = merged_variables["base_path"]
+    base_group = project[base_path]
+    group_path = CodeTemplater.new.render_string(@path, context)
+
+    group_path = group_path.split("/")
+
+    group = base_group
+    associate_path_to_group = !base_group.path.nil?
+
+    group_path.each do |group_name|
+      new_group_path = File.join(group.real_path, group_name)
+      existing_group = group.groups.find { |g| g.display_name == group_name }
+      group = existing_group || group.pf_new_group(
+        associate_path_to_group: associate_path_to_group,
+        name: group_name,
+        path: new_group_path
+      )
+    end
+
+    file_creator = FileCreator.new
+    file_creator.create_empty_directory(group)
+  end
+end

data/lib/ccios/pbxproj_parser.rb

@@ -11,63 +11,12 @@ class PBXProjParser
     @projects = {}
   end
 
-  def app_project
-    project_for(@config.app.project)
-  end
-
-  def core_project
-    project_for(@config.core.project)
-  end
-
-  def data_project
-    project_for(@config.data.project)
-  end
-
-  def presenter_group
-    path = @config.app.presenter.group
-    app_project[path]
-  end
-
-  def coordinator_group
-    path = @config.app.coordinator.group
-    app_project[path]
-  end
-
-  def interactor_group
-    path = @config.core.interactor.group
-    core_project[path]
-  end
-
-  def repository_core_group
-    path = @config.core.repository.group
-    core_project[path]
-  end
-
-  def repository_data_group
-    path = @config.data.repository.group
-    data_project[path]
-  end
-
-  def app_target
-    target_for(app_project, @config.app.target)
-  end
-
-  def core_target
-    target_for(core_project, @config.core.target)
-  end
-
-  def data_target
-    target_for(data_project, @config.data.target)
-  end
-
   def save
-    app_project.save
-    core_project.save
-    data_project.save
+    @projects.each do |path, value|
+        value.save
+    end
   end
 
-  private
-
   def project_for(path)
     module_project_path = File.join(source_path, path)
     resolved_module_project_path = Dir.glob(module_project_path).first
@@ -78,7 +27,7 @@ class PBXProjParser
   end
 
   def target_for(project, target_name)
-    if target_name.blank?
+    if target_name.blank? || target_name.nil?
       project.targets.find { |t| t.product_type == "com.apple.product-type.application" }
     else
       project.targets.find { |t| t.name == target_name }

data/lib/ccios/snippet_template_definition.rb

@@ -0,0 +1,27 @@
+require_relative 'file_creator'
+
+class SnippetTemplateDefinition
+  def initialize(snippet_template_definition_hash)
+    @name = snippet_template_definition_hash["name"]
+    @template = snippet_template_definition_hash["template"]
+  end
+
+  def validate(template_definition)
+    expected_context_keys = template_definition.provided_context_keys
+    file_creator = FileCreator.new
+    contentTags = file_creator.get_unknown_template_tags_for(template_definition.template_source_file(@template))
+    contentTags.each do |tag|
+      raise "Unknown parameter \"#{tag}\" in template \"#{@template}\""  unless expected_context_keys.include?(tag)
+    end
+  end
+
+  def generate(context, template_definition)
+
+    file_creator = FileCreator.new
+    file_creator.print_file_content_using_template(
+      @name,
+      template_definition.template_source_file(@template),
+      context
+    )
+  end
+end

data/lib/ccios/template_definition.rb

@@ -0,0 +1,116 @@
+require 'yaml'
+
+require_relative 'file_creator'
+require_relative 'pbxproj_parser'
+require_relative 'argument_template_parameter'
+require_relative 'flag_template_parameter'
+require_relative 'file_template_definition'
+require_relative 'group_template_definition'
+require_relative 'snippet_template_definition'
+
+class TemplateDefinition
+
+  attr_reader :name, :description, :template_path, :template_file_source, :parameters, :variables
+
+  def self.parse(template_path)
+    template_definition = File.join(template_path, 'template.yml')
+    if File.exist?(template_definition)
+      template_definition = YAML.load_file(template_definition)
+      self.new template_definition, template_path
+    else
+      puts "Template #{template_path} is invalid: file #{template_definition} not found."
+      nil
+    end
+  end
+
+  def initialize(template_definition_hash, template_path)
+    @template_definition_hash = template_definition_hash
+    @template_path = template_path
+
+    @name = template_definition_hash["name"]
+    @description = template_definition_hash["description"] || ""
+    @variables = template_definition_hash["variables"] || {}
+
+    @parameters = template_definition_hash["parameters"].map { |hash|
+      next ArgumentTemplateParameter.new(hash) unless hash["argument"].nil?
+      next FlagTemplateParameter.new(hash) unless hash["flag"].nil?
+    }.compact
+
+    @generated_elements = template_definition_hash["generated_elements"].map { |hash|
+      next FileTemplateDefinition.new(hash) unless hash["file"].nil?
+      next GroupTemplateDefinition.new(hash) unless hash["group"].nil?
+      next nil
+    }.compact
+
+    if template_definition_hash["code_snippets"].nil?
+        @snippets = []
+    else
+    @snippets = template_definition_hash["code_snippets"].map { |hash|
+      SnippetTemplateDefinition.new(hash)
+    }
+    end
+
+    @template_file_source = template_definition_hash["template_file_source"] || {}
+  end
+
+  def validate(parser, options, config)
+
+    raise "Error: missing name in template" if @name.nil?
+    raise "Error: invalid template name" unless @name.is_a? String
+
+    merged_variables = config.variables_for_template(self)
+    project_path = merged_variables["project"]
+
+    project = parser.project_for(project_path)
+    raise "Error: Unable to find project \"#{project_path}\"" if project.nil?
+
+    @template_file_source.each do |file_template_name, path|
+      raise "Missing template source file for \"#{file_template_name}\"" unless File.exist?(self.template_source_file(file_template_name))
+    end
+
+    options = agrument_transformed_options(options)
+
+    @generated_elements.each do |generated_element|
+      generated_element.validate(parser, project, options, self, config)
+    end
+
+    @snippets.each do |snippet|
+      snippet.validate(self)
+    end
+  end
+
+  def template_source_file(name)
+    raise "Unknown template file #{name}" if @template_file_source[name].nil?
+    File.join(@template_path, @template_file_source[name])
+  end
+
+  def provided_context_keys
+    @parameters.flat_map { |p| p.provided_context_keys }.to_set
+  end
+
+  def generate(parser, options, config)
+
+    options = agrument_transformed_options(options)
+
+    merged_variables = config.variables_for_template(self)
+    project_path = merged_variables["project"]
+
+    project = parser.project_for project_path
+
+    @generated_elements.each do |element|
+      element.generate(parser, project, options, self, config)
+    end
+
+    @snippets.each do |snippet|
+      snippet.generate(options, self)
+    end
+  end
+
+  def agrument_transformed_options(options)
+    @parameters.select { |p| p.is_a? ArgumentTemplateParameter }.each do |argument|
+      options = argument.update_context(options)
+    end
+    options
+  end
+
+end

data/lib/ccios/templates/{coordinator.mustache → Coordinator/coordinator.mustache}

@@ -10,6 +10,7 @@ import Foundation
 import ADCoordinator
 
 {{#generate_delegate}}
+@MainActor
 protocol {{name}}CoordinatorDelegate: AnyObject {
 
 }
@@ -23,8 +24,10 @@ class {{name}}Coordinator: Coordinator {
     private let dependencyProvider: ApplicationDependencyProvider
     private unowned var navigationController: UINavigationController
 
-    init(navigationController: UINavigationController,
-         dependencyProvider: ApplicationDependencyProvider) {
+    init(
+        navigationController: UINavigationController,
+        dependencyProvider: ApplicationDependencyProvider
+    ) {
         self.navigationController = navigationController
         self.dependencyProvider = dependencyProvider
     }