ccios 4.0.2 → 5.0.0

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
 
@@ -24,39 +25,51 @@ class FileCreator
     FileCreator.logger
   end
 
-  def initialize(options = {})
-    @options = options
-  end
-
   def templater_options(target)
     defaults = {
       project_name: target.display_name,
       full_username: git_username,
       date: DateTime.now.strftime("%d/%m/%Y"),
     }
-    defaults.merge(@options)
+    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, 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)
-    file_content = code_templater.content_for_suffix(prefix, suffix)
+    context = context.merge(templater_options(targets[0]))
+    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)
@@ -67,16 +80,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)
-    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,94 @@
+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 = 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)
+      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,
+      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

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/template.yml

@@ -0,0 +1,20 @@
+name: "coordinator"
+description: "Generate NameCoordinator"
+variables:
+  project: "*.xcodeproj"
+  base_path: "Coordinator"
+  target: ""
+parameters:
+  - argument: "name"
+    removeSuffix: "Coordinator"
+  - flag: "delegate"
+    short_name: "d"
+    template_variable_name: "generate_delegate"
+    description: "Generate delegate protocols when provided"
+generated_elements:
+  - name: "coordinator"
+    file: "{{ name }}Coordinator.swift"
+    template: "coordinator"
+    variables: {}
+template_file_source:
+  coordinator: "coordinator.mustache"

data/lib/ccios/templates/Interactor/template.yml

@@ -0,0 +1,25 @@
+name: "interactor"
+description: "Generate NameInteractor and NameInteractorImplementation"
+parameters:
+  - argument: "name"
+    removeSuffix: "Interactor"
+variables:
+  project: "*.xcodeproj"
+  base_path: "Core/Interactor"
+  target: ""
+generated_elements:
+  - name: "interactor"
+    file: "{{ name }}Interactor/{{ name }}Interactor.swift"
+    template: "interactor"
+    variables: {}
+  - name: "interactor_implementation"
+    file: "{{ name }}Interactor/{{ name }}InteractorImplementation.swift"
+    template: "interactor_implementation"
+    variables: {}
+code_snippets:
+  - name: InteractorAssembly
+    template: "interactor_assembly"
+template_file_source:
+  interactor: "interactor.mustache"
+  interactor_implementation: "interactor_implementation.mustache"
+  interactor_assembly: "interactor_assembly.mustache"

data/lib/ccios/templates/Presenter/template.yml

@@ -0,0 +1,49 @@
+name: "presenter"
+description: "Generate NamePresenter, NamePresenterImplementation, NameViewContract and NameViewController"
+parameters:
+  - argument: "name"
+    removeSuffix: "Presenter"
+    lowercased_variable_name: "lowercased_name"
+  - flag: "delegate"
+    short_name: "d"
+    template_variable_name: "generate_delegate"
+    description: "Generate delegate protocols when provided"
+variables:
+  project: "*.xcodeproj"
+  base_path: "App"
+  target: ""
+generated_elements:
+  - name: "ui_view_group"
+    group: "{{ name }}/UI/View"
+    variables: {}
+  - name: "view_controller"
+    file: "{{ name }}/UI/ViewController/{{ name }}ViewController.swift"
+    template: "view_controller"
+    variables: {}
+  - name: "view_contract"
+    file: "{{ name }}/UI/{{ name }}ViewContract.swift"
+    template: "view_contract"
+    variables: {}
+  - name: "presenter"
+    file: "{{ name }}/Presenter/{{ name }}Presenter.swift"
+    template: "presenter"
+    variables: {}
+  - name: "presenter_implementation"
+    file: "{{ name }}/Presenter/{{ name }}PresenterImplementation.swift"
+    template: "presenter_implementation"
+    variables: {}
+  - name: "model_group"
+    group: "{{ name }}/Model"
+    variables: {}
+code_snippets:
+  - name: DependencyProvider
+    template: "dependency_provider"
+  - name: PresenterAssembly
+    template: "presenter_assembly"
+template_file_source:
+  view_controller: "view_controller.mustache"
+  view_contract: "view_contract.mustache"
+  presenter: "presenter.mustache"
+  presenter_implementation: "presenter_implementation.mustache"
+  dependency_provider: "dependency_provider.mustache"
+  presenter_assembly: "presenter_assembly.mustache"

data/lib/ccios/templates/{repository_implementation.mustache → Repository/repository_implementation.mustache}

@@ -5,7 +5,6 @@
 //  Created by {{full_username}} on {{date}}.
 //
 //
-//
 
 import Foundation
 import Core

data/lib/ccios/templates/Repository/template.yml

@@ -0,0 +1,26 @@
+name: "repository"
+description: "Generate NameRepository and NameRepositoryImplementation"
+parameters:
+  - argument: "name"
+    removeSuffix: "Repository"
+variables:
+  project: "*.xcodeproj"
+  target: ""
+generated_elements:
+  - name: "repository"
+    file: "{{ name }}/{{ name }}Repository.swift"
+    template: "repository"
+    variables:
+      base_path: "Core/Data"
+  - name: "repository_implementation"
+    file: "{{ name }}/{{ name }}RepositoryImplementation.swift"
+    template: "repository_implementation"
+    variables:
+      base_path: "Data"
+code_snippets:
+  - name: RepositoryAssembly
+    template: "repository_assembly"
+template_file_source:
+  repository: "repository.mustache"
+  repository_implementation: "repository_implementation.mustache"
+  repository_assembly: "repository_assembly.mustache"

data/lib/ccios/templates_loader.rb

@@ -0,0 +1,31 @@
+require_relative 'config'
+require_relative 'template_definition'
+
+class TemplatesLoader
+
+  def get_templates(config)
+    default_template_folder = File.join(File.dirname(__FILE__), "templates")
+    default_templates = load_templates_from_collection(default_template_folder)
+    custom_templates = []
+    if !config.templates_collection.nil?
+      custom_templates = load_templates_from_collection(config.templates_collection)
+    end
+    templates = {}
+    all_templates = default_templates + custom_templates
+    all_templates.each do |template|
+      templates[template.name] = template
+    end
+    Hash[templates.sort_by{|k,v| k}]
+  end
+
+  private
+
+  def load_templates_from_collection(collection_path)
+    template_paths = Dir.children(collection_path)
+      .map { |name| File.join(collection_path, name) }
+      .select { |path| File.directory? path }
+    template_paths
+      .map { |template_path| TemplateDefinition.parse(template_path) }
+      .compact
+  end
+end