ccios 4.1.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6854ecea6f4dd2478a49675e65dac4f292ddd1e2cae94d526b5903ea507efaf0
-  data.tar.gz: eeaa057288fe8c0d0c6d02e0a94453e967e8c1d904a068d5c185f0d49224c252
+  metadata.gz: d0173944aad4daed89817a5a20eb66ebeb7cacb57d96f6bd1ab60ff79569680b
+  data.tar.gz: 927fecdf93f40d5636a1fcdefa173410b307ece874ffc6015ec9bb6e405cd7af
 SHA512:
-  metadata.gz: 34837239dd73f4e62f167a078a48fb3083b49296c9970032f86ba768128af08b991c5f46adc72b032fbc909d4937e82487fcdea65d0cb6b9eaaa9049c2261580
-  data.tar.gz: a480d7df1ee5dc7a9d595ec6fcb4c68ad968ca2b62e9c57065ff7a3e3ad5528f2ffd0e3d76dfe01f6f6ba2cad71fab65ffafc5148b2fbbf202e978b0a65c1f61
+  metadata.gz: 35a7291a319e2384a3c25662d58925dc8a77ca459fabc606a16d84ed257618f03584c42eb7dfd98d3103e3f2b3b2ceabcfe0a5663397c16d58a98e7b18e2b9c7
+  data.tar.gz: 5a254c0e5d56a4f9076da36dabab143673ae58a12351fc93eccb30ab7a1f07a9d240ee97f500d1a5023b210fcaf6fc6fbaa25507bca0257786fb79b97c31eabd

data/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [5.0.0]
+
+This release is an entire rewrite of the templating system, allowing customization of template and settings.
+
+### Added
+
+- New templating system that allows definition of custom templates per project
+- A template can now declare multiple CLI arguments and flags
+- Generated files can be added to multiple targets
+- The base_path group and target can be configured independently for each generated file if needed.
+- Add validation that each variable used in a mustache file is provided by the template. The default provided variables are: `filename`, `lowercase_filename`, `project_name`, `full_username` and `date`
+- List of known templates is available using `ccios --help`
+
+### Changed
+
+- Default templates has been migrated to the new format
+- Configuration file (`.ccios`) format has been changed
+- Command line invocation has changed:
+    - `ccios -p Example [-d]` is now `ccios presenter Example [-d]`
+    - `ccios -c Example [-d]` is now `ccios coordinator Example [-d]`
+    - `ccios -i Example [-d]` is now `ccios interactor Example`
+    - `ccios -r Example [-d]` is now `ccios repository Example`
+- Some default provided mustache variables have been renamed:
+    - `name` is now `filename`
+    - `lowercased_name` is now `lowercased_filename`
+
 ## [4.1.0]
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ccios (4.1.0)
+    ccios (5.0.0)
       activesupport (> 4)
       mustache (~> 1.0)
       xcodeproj (~> 1.4)

data/README.md

@@ -21,14 +21,24 @@ To run the tests run:
 Go to your `.xcodeproj` folder `cd /paht/to/my/xcodeproj`.
 Then generate files with prefix `Example`:
 
+```bash
+ccios <template_name> [template_arguments...] [template_options]
 ```
-ccios [-p|-i|-r|-c] Example [-d]
+
+The list of known templates is visible using the following command:
+```bash
+ccios --help
 ```
 
-Generated templates can be found [here](https://github.com/felginep/ccios/tree/master/lib/ccios/templates)
+Generated templates can be found [here](https://github.com/fabernovel/ccios/tree/master/lib/ccios/templates)
+
+## Default templates
+
+### `presenter`
 
-### `-p`
-`-p` stands for `presenter`
+```bash
+ccios presenter Example [-d]
+```
 
 This generates 4 files: `ExampleViewController`, `ExampleViewContract`, `ExamplePresenter`, `ExamplePresenterImplementation`. If the `-d` option is supplied the protocol `ExamplePresenterDelegate` will be generated.
 
@@ -51,8 +61,11 @@ The following structure is created for you in the Xcode project:
 |   |   +-- Model/
 ```
 
-### `-i`
-`-i` stands for `interactor`
+### `interactor`
+
+```bash
+ccios interactor Example
+```
 
 This generates 2 files: `ExampleInteractor` and `ExampleInteractorImplementation`.
 
@@ -69,8 +82,11 @@ The following structure is created for you in the Xcode project:
 |   |   |   +-- ExampleInteractorImplementation
 ```
 
-### `-r`
-`-r` stands for `repository`
+### `repository`
+
+```bash
+ccios repository Example
+```
 
 This generates 2 files: `ExampleRepository` and `ExampleRepositoryImplementation`.
 
@@ -89,8 +105,11 @@ The following structure is created for you in the Xcode project:
 |   |   +-- ExampleRepositoryImplementation
 ```
 
-### `-c`
-`-c` stands for `coordinator`
+### `coordinator`
+
+```bash
+ccios coordinator Example [-d]
+```
 
 This generates one file: `ExampleCoordinator`. If the `-d` option is supplied the protocol `ExampleCoordinatorDelegate` will be generated.
 
@@ -104,64 +123,176 @@ The following structure is created for you in the Xcode project:
 
 ## Configuration
 
-
-Each project is different. You can configure the groups to use in the xcodeproj for the new files.
+Each project is different. You can configure the available templates that can be used 
+You can configure the groups to use in the xcodeproj for the new files.
 
 Create a file `.ccios.yml` at the root of your project.
 
-By default, if no file is present, the following configuration will be used:
-```
-app:
-  project: MyProject.xcodeproj
+An empty config file is valid as all properties are optional.
+
+```yml
+# Path to an additional collection of templates. [Optional]
+# Templates present in this folder will be available. If the collection use the same name as a default template, it will override it.
+templates_collection: ccios/templates
+
+# Global overrides of variables [Optional]
+variables:
+  project: Project.xcodeproj
+
+# Per template variables override
+templates_config:
+  # Use the template name (in template.yml) to specify overrides on this template:
+  TEMPLATE_NAME:
+    # This overrides the default template variables
+    variables:
+      project: "Project.pbxproj"
+      # You can specify multiple target for generated files.
+      target: 
+        - SomeTarget
+        - SomeOtherTarget
+        - ThirdTarget
+    # Per element variable override
+    elements_variables:
+      # This overrides the default variables for the element named "ELEMENT_NAME_1"
+      ELEMENT_NAME_1:
+        base_path: Core/Data
+        target: Core
+      ELEMENT_NAME_2:
+        base_path: Data
+        target: Data
+  # Another template variable override
   presenter:
-    group: Classes/App
+    variables:
+      base_path: MyProject/App
+    elements_variables:
+      repository:
+        base_path: "Core/Data"
   coordinator:
-    group: Classes/Coordinator
-
-core:
-  project: MyProject.xcodeproj
-  interactor:
-    group: Classes/Core/Interactor
-  repository:
-    group: Classes/Core/Data
-
-data:
-  project: MyProject.xcodeproj
-  repository:
-    group: Classes/Data
+    variables:
+      base_path: MyProject/Coordinator
 ```
 
-But you could imagine more complex project structures with multiple xcodeproj:
-```
-app:
-  project: MyProject/MyProject.xcodeproj
-  target: MyProject # optional
-  presenter:
-    group: Classes/App
-  coordinator:
-    group: Classes/Coordinator
+*Note*: The path of the new files will be infered from the path of the group. It works with *Group with folder* and *Group without folder* in Xcode.
 
-core:
-  project: MyProjectCore/MyProjectCore.xcodeproj
-  target: MyProjectCore # optional
-  interactor:
-    group: MyProjectCore/Interactors
-  repository:
-    group: MyProjectCore/Repository
+## Template definition
 
-data:
-  project: MyProjectData/MyProjectData.xcodeproj
-  target: MyProjectData # optional
-  repository:
-    group: MyProjectData/Sources/Repositories
-```
+Default templates can be found [here](https://github.com/fabernovel/ccios/tree/master/lib/ccios/templates), and can be used to see what is possible.
 
-*Note*: The path of the new files will be infered from the path of the group. It works with *Group with folder* and *Group without folder* in Xcode.
+A template is a folder containing a file `template.yml` next to all templating files that will be used during generation.
+Example for the default Interactor template:
+```
+Interactor/
+    template.yml
+    interactor.mustache
+    interactor_assembly.mustache
+    interactor_implementation.mustache
+```
 
-And lastly you may want to use your own templates, by adding this parameter to the file:
+### `template.yml` format
+
+```yml
+# name of the template to use in the CLI. [required]
+name: "custom_template"
+# description of the template. [optional]
+description: "Custom template definition"
+# List of the parameters that will be given to the file templates. [required]
+# The parameters can be used in template files, and in file path.
+parameters:
+  # Use this to represent a string argument parameter in the CLI
+  # By default the argument will be passed to template renderer under the name "name", to use another name, specify a `template_variable_name`
+  - argument: "name" 
+    # Description used in the help command. [Optional]
+    description: "name argument description"
+    # When present, the argument will be usable in templates under the provided name. [Optional]
+    template_variable_name: "in_template_variable_name"
+    # When present, will remove the provided suffix from the argument given. Example "MySuffix" will be tranformed into "My". [Optional]
+    removeSuffix: "Suffix"
+    # When present, the lowercased argument will be usable in templates under the provided name. [Optional]
+    lowercased_variable_name: "name_of_the_lowercased_variable"
+  # Use this to represent a flag parameter in the CLI, the flag will be provided to templates as `true` when present in the executed command.
+  - flag: "long_name"
+    # The short name of this flag to use on CLI. [optional]
+    short_name: "n"
+    # Description used in the help command. [Optional]
+    description: "Description for the long_name flag"
+    # When present, the argument will be usable in templates under the provided name. [Optional]
+    template_variable_name: "in_template_flag_name"
+# List of templates variables that is used to generate files in an xcode project. [Optional]
+# Those variables can be overridden in config file, see section "Variable hierarchy" for more informations.
+variables:
+  # The name of the xcode project. "*.xcodeproj" will use the first it finds. [required]
+  project: "*.xcodeproj"
+  # The base path used to generate an element. This variable must be defined once here, or on each elements below.
+  base_path: "path/to/base_group"
+  # The target in which files are added. Can be a string, a list of strings, or an empty string. This variable must be defined once here, or on each elements below. If an empty string is provided, it will use the first target found in the Xcode project.
+  target: ""
+# List of generated elements. [Required]
+# Each element can be a file (using `file`), or an empty folder (using `group`)
+generated_elements:
+    # Path from the `base_path` variable where the file will be generated
+  - file: "{{ name }}/{{ name }}File.swift"
+    # This name identifies this generated file to allow variable overrides in config file. [Required]
+    name: "file"
+    # The template specifies the name of template that will be used from `template_file_source`
+    template: "file"
+    # List of default element variable. [Optional]
+    variables: {}
+    # Path from the `base_path` variable where the directory will be generated
+  - group: "{{ name }}/group"
+    # This name identifies this generated file to allow variable overrides in config file. [Required]
+    name: "group"
+    # List of default element variable. [Optional]
+    variables:
+      - base_path: "path/override/to/base_group"
+# List of code snippets that will be printed by the CLI after the generation of files. [Optional]
+code_snippets:
+    # The name will be used in the printed line "Add this snippet to FilenameInWhichTheSnippetIsExpected" before the generated code snippet.
+    # This name will also be given to the snippet template under the variable `filename` and `lowercased_filename`. [Required]
+  - name: FilenameInWhichTheSnippetIsExpected
+    # The template specifies the name of template that will be used from `template_file_source`. [Required]
+    template: "file_snippets"
+# List of templating files used for element generation or code snippets. [Required]
+# The key is used as an identifier in `generated_elements` or `code_snippets`, the value is the path from the template directory.
+template_file_source: 
+  file: "file.mustache"
+  file_snippets: "file_snippets.mustache"
 ```
-templates:
-  path: Path/To/Users/Templates
+
+### Variable hierarchy
+
+In `template.yml`
+```yml
+# [...]
+variables:
+  # -> Default templates variables
+generated_elements:
+  - name: element_name
+    # [...]
+    variables:
+      # -> Default Element variables
 ```
 
+In `.ccios.yml`
+```yml
+variables:
+  # -> Config Global variables
+templates_config:
+ repository:
+   variables:
+     # -> Config Template variables
+   element_variables:
+     element_name:
+       # -> Config Element variables
+```
 
+Templates will use variables in this order (first in this list is used):
+- Config Template variables
+- Default templates variables
+- Config Global variables
+
+Element will use variables in this order (first in this list is used): (For files, groups and code snippets)
+- Config Element variables
+- Default Element variables
+- Config Template variables
+- Default templates variables
+- Config Global variables

data/ccios.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'ccios'
-  s.version     = '4.1.0'
+  s.version     = '5.0.0'
   s.executables << 'ccios'
   s.date        = '2016-08-03'
   s.summary     = "Clean Code iOS Generator"

data/lib/ccios/argument_template_parameter.rb

@@ -0,0 +1,33 @@
+class ArgumentTemplateParameter
+  attr_reader :name, :description, :template_variable_name
+
+  def initialize(parameter_template_definition_hash)
+    @name = parameter_template_definition_hash["argument"]
+    @description = parameter_template_definition_hash["description"] || ""
+    @template_variable_name = parameter_template_definition_hash["template_variable_name"] || @name
+    @removeSuffix = parameter_template_definition_hash["removeSuffix"] || ""
+    @lowercased_name = parameter_template_definition_hash["lowercased_variable_name"] || ""
+
+    raise "Missing argument name" if @name.nil? || @name.empty?
+    raise "Invalid argument template_variable_name for #{@name}" if @template_variable_name.nil? || template_variable_name.empty?
+  end
+
+  def update_context(context)
+    if !@removeSuffix.empty?
+      value = context[@template_variable_name]
+      context[@template_variable_name] = value.gsub(@removeSuffix, "")
+    end
+    if !@lowercased_name.empty? && !context[@lowercased_name]
+      context[@lowercased_name] = context[@template_variable_name].camelize(:lower)
+    end
+    context
+  end
+
+  def provided_context_keys
+    context_keys = [@template_variable_name]
+    if !@lowercased_name.empty?
+      context_keys.append(@lowercased_name)
+    end
+    context_keys
+  end
+end

data/lib/ccios/code_templater.rb

@@ -2,15 +2,31 @@ require 'mustache'
 require 'active_support/core_ext/string'
 
 class CodeTemplater
-  def initialize(options = {}, templates_path)
-    @options = options
-    @templates_path = templates_path
+
+  def render_string(template, context)
+    Mustache.render(template, context)
+  end
+
+  def get_unknown_context_keys_for_string(template)
+    stringView = Mustache.new
+    stringView.template = template
+    tags = stringView.template.tags || []
+    tags = tags.map { |t| t.split(".")[-1] }.to_set
+    tags
+  end
+
+  def render_file_content_from_template(template_path, filename, context)
+    filename = File.basename(filename, File.extname(filename))
+    context = context.merge({filename: filename, lowercased_filename: filename.camelize(:lower)})
+    Mustache.render(File.read(template_path), context)
   end
 
-  def content_for_suffix(prefix, suffix)
-    template_name = suffix.underscore
-    options = @options.merge({name: prefix, lowercased_name: prefix.camelize(:lower)})
-    template_file = File.join(@templates_path, "#{template_name}.mustache")
-    Mustache.render(File.read(template_file), options)
+  def get_unknown_context_keys_for_template(template_path)
+    templateView = Mustache.new
+    templateView.template_file = template_path
+    tags = (templateView.template.tags || [])
+    tags = tags.map { |t| t.split(".")[-1] }.to_set
+    tags.subtract(Set["filename", "lowercased_filename"])
+    tags
   end
 end

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