generamba-udf 2.0.1

data/docs/2.x/roadmap.md

@@ -0,0 +1,365 @@
+# Generamba 2.0 Roadmap
+### Overview
+
+The main aim of 2.0 release is to decouple Generamba from iOS/macOS development and make it available for other areas as well: backend, frontend, Android. 
+
+We'll definitely break the backwards compatibility with *Rambafile* and templates created for the 1.x Generamba versions. To simplify the upgrading process we're considering writing some automatic migration tools.
+
+### High-Level Tasks
+
+* Switch *Rambafile* from `yml` to a custom DSL format.
+	* Wrap repetitive tasks into *ramba*'s - the nearest analogs are *lane*'s from `fastlane`.
+	* Introduce the concept of two types of *plugins*: system (validation, save) and general-purpose.
+	* Allow the usage of different types of hooks - `before`, `after`, `error`.
+* Add validation plugins, that are available to check the environment before code generation.
+	* Extract the saving logic from the Generamba core to plugins, both to filesystem and Xcode.
+* Add saving plugins, that are available to process the text snippet created by generamba and save it somewhere.
+	* Extract the validation logic from the Generamba core to plugins, both for CocoaPods and Carthage.
+
+### Generamba Flow
+
+A typical generation process consists of three steps:
+	* validation
+	* generation
+	* saving
+
+#### Validation
+
+That step is used to validate the environment status before code generation. 	It's a perfect place to implement logic of checking the required packages versions, the presence of system libraries, git status and so on.
+
+If one of checks returns an error, the overall validation process doesn't stop until all of validation methods execute. This is crucial for a smooth user experience.
+
+#### Generation
+
+That's the core functionality of Generamba. A user provides a template name and some options which are used as an input. After the generation Generamba produces a text snippet as an output.
+
+There can be multiple generation actions as well. All of them are executed in the writing order and their results are stored in-memory.
+
+#### Saving
+
+This step defines what to do with a generation output. The most obvious options are to store it as a file in some directory on the disk, embed it in your IDE, upload somewhere or print in log.
+
+If there are multiple saving actions, each of them is applied to each generation output. They are executed in the writing order.
+
+### DSL
+
+#### Basic Rambafile Structure
+
+The main building block of *Rambafile* is `ramba`:
+
+```
+desc "Creates a new Xcode project"
+ramba :viper_module do
+  # Detailed description of generation steps
+end
+```
+
+The *Rambafile* may be monolithic as well as decomposed to multiple files. This is available via special functions:
+	- `ramba_import_local('path')` - imports the contents of `Rambafile` stored locally.
+	- `ramba_import_git('git', 'branch')` - imports the contents of Rambafile stored in remote git repository.
+
+#### Setting Options
+
+A user can set options in any part of *Rambafile* structure. It's important to note, that option, defined on the next level of method hierarchy, overwrites it's previous declaration. That allows to have a default value for some key and redefine it in each `ramba`.
+```
+set :project_name, 'MyProject'
+
+ramba :viper_module do
+  set :project_name, 'MyProject'
+end
+```
+
+It's also available to set an option using lambda:
+```
+set :date_string,  -> { 
+	"Current date: #{Date.now}"
+}
+```
+
+> How options are set in Rambafile...
+> 
+
+Besides `ramba` -specific options, there are template-specific options as well. They may correspond to a specific template and be defined in the *.rambaspec* file. 
+
+> The saving action for Xcode should behave differently depending on whether a generated file it's a code file or some resource. So, there is a special option for each file of Xcode templates:
+> `- {name: Router/RouterTests.m, path: Tests/Router/router_tests.m.liquid, is_resource: false}` 
+
+#### Hooks
+
+There are multiple types of hooks, which make possible to perform some action or redefine an option in certain moments of generation cycle.
+
+##### `before` hooks
+
+A user can specify a hook, that'll execute before a specific `ramba`:
+```
+before :viper_module do
+	# Some logic here...
+end
+```
+
+It's also possible to write a hook that'll execute before each `ramba`:
+```
+before_each do |ramba_name|
+	# Some logic here...
+end
+```
+
+##### `after` hooks
+
+A user can specify a hook, that'll execute after a specific `ramba`:
+```
+after :viper_module do
+	# Some logic here...
+end
+```
+
+It's also possible to write a hook that'll execute after each `ramba`:
+```
+after_each do |ramba_name|
+	# Some logic here...
+end
+```
+
+##### `error` hooks
+
+If any action returns an error, it's possible to customize the resulting behavior for a specific `ramba` :
+```
+error :viper_module do
+	# Some logic here...
+end
+```
+It's also possible to write a hook that'll execute in case of error in any `ramba`:
+```
+error_each do |ramba_name|
+	# Some logic here...
+end
+```
+
+#### `ramba` structure
+
+As we've already mentioned, `ramba` consists of three main steps. Multiple actions in each step are executed in the writing order.
+
+##### Validation actions
+
+```
+ramba :viper_module do
+	...
+	validate :validate_plugin_name do
+    set :some_option, 'some_value'
+    any_custom_action()
+  end
+  ...
+end
+```
+
+This notation means the following steps:
+	- The lambda passed to the validate action is executed.
+	- The plugin with name `validate_plugin_name` is called with options modified by lambda.
+
+The notation can be simplified to:
+```
+validate :validate_plugin_name
+```	
+
+##### Generation actions
+
+```
+ramba :viper_module do
+	...
+  gen :viper_module do
+    set :some_option, 'some_value'
+    any_custom_action(parameter1)
+ 	end
+  ...
+end
+```
+
+This notation means the following steps:
+	- The lambda passed to the gen action is executed.
+	* The `gen` command is called with a template *viper_module* and options modified by lambda.
+
+The notation can be simplified to:
+```
+gen :viper_module
+```	
+
+##### Saving actions
+
+```
+ramba :viper_module do
+	...
+	save :save_plugin_name do
+    set :some_option, 'some_value'
+    any_custom_action()
+  end
+  ...
+end
+```
+
+This notation means the following steps:
+	- The lambda passed to the saving action is executed.
+	- The plugin with name `save_plugin_name` is called with options modified by lambda.
+
+The notation can be simplified to:
+```
+save :save_plugin_name
+```	
+
+##### Custom Actions
+
+Besides system plugins (validation and saving), a user can create a general-purpose plugin which contains some specific reusable logic. E.g. a plugin which clears the environment - calls `git reset`, uninstalls some packages and so on. It's called simply by calling it's name:
+```
+ramba :viper_module do
+	...
+	any_custom_action()
+  ...
+end
+```
+
+##### Templates and Catalogs
+
+Templates and tempalte catalogs, used for code generation, can be specified right in the `ramba`'s.
+
+```
+ramba :viper_module do
+	catalog 'https://github.com/user/catalog', branch:'develop'
+	template 'viper_ios', version:'1.2.5'
+	template 'viper_ios2', path:'/local_templates'
+end
+```
+
+- `catalog` keyword specifies a custom template catalog (like https://github.com/rambler-digital-solutions/generamba-catalog).
+  - `branch` parameter specifies a concrete catalog branch
+- `template` keyword declares a template that needs to be installed
+  - `version` parameter specifies a concrete template version.
+  - `path` parameter specifies a local path to the template.
+  - `git` parameter specifies a remote repository path to a template.
+  - `branch` parameter is used together with `git` to specify a branch.
+  
+The `generamba template install` command aggregates all of the templates from the `Rambafile` and installs them in a `.generamba` hidden directory. When a user triggers some `ramba`, templates are loaded from this directory. The only exception are local templates - they are always installed from the specified in the `Rambafile` local path.
+
+### Plugins
+
+The main ideas behind plugin system are:
+
+	- Increase code reusability between different projects,
+	* Keep the Generamba core as simple as possible,
+	* Abstract from specific implementations of different IDEs,
+	* Allow users to easily extend Generamba functionality for their needs.
+
+As we've already mentioned, there are two types of plugins:
+
+	- System plugins - validation and saving,
+	* Custom plugins.
+
+The main difference between them is how system calls them during `ramba` execution.
+
+#### Plugin Structure
+
+```
+module Generamba
+  module Plugins
+		class CocoaPodsPackageVersionValidationPlugin < ValidationPlugin
+			# The main body of a plugin
+			def self.run(params)
+				# Loads Podfile
+				# Analyzez dependencies version
+				# Compares these versions to the passed options
+			end
+			
+			# The description of what this plugin does
+			def self.description
+        'Verifies dependencies version in the project Podfile'
+      end
+
+			# Explicitly declaring available plugin options
+			def self.available_options
+        [
+          Generamba::ConfigItem.new(key: :package_versions,
+                                    description: "The hash with dependencies names and required versions",
+                                    default_value: [])
+          ]
+      end
+
+			# Declaring the output parameters
+      def self.output
+        [
+          ['COCOAPODS_CHECK_RESULT', 'The result of dependency checking']
+        ]
+      end
+
+			# Who created this plugin
+      def self.authors
+        ["etolstoy"]
+      end
+		end
+	end
+end
+```
+
+The same structure applies to other kinds of plugins. The only difference is the base class for the plugin - it can be `ValidationPlugin`, `SavingPlugin`, `Plugin`. 
+
+We've borrowed the plugin structure from `fastlane`.
+
+#### Plugin Distribution
+
+To avoid over-engineering in this version plugins will be distributed together with Generamba binary. If there'll be a lot of community-created plugins, will think about switching to other distribution system.
+
+It's also possible to store plugins near the `Rambafile` in a separate directory `/plugins`. They'll be loaded by Generamba automatically.
+
+### Rambafile Example
+
+```
+ramba_import_local('path')
+ramba_import_git('git', 'branch')
+
+set :project_name, 'LiveJournal'
+
+before :viper_module do
+  set :company, 'Rambler&Co'
+  set :xcodeproj_path, 'LiveJournal.xcodeproj'
+  set :project_targets, ['LiveJournal1', 'LiveJournal2']
+  set :test_target, 'LiveJournalTests'
+end
+
+desc "Creates a simple VIPER module"
+ramba :viper_module do
+  validate :plugin_validate_name do
+    set :some_option, '456'
+    any_custom_action()
+  end
+
+  gen :template_name do
+    set :some_option, '123'
+    any_custom_action(parameter1)
+  end
+
+  save :file_system do
+    set :some_option, '789'
+  end
+
+  save :xcode_proj
+end
+
+desc "Creates a new Xcode project"
+ramba :create_project do
+  sh("liftoff") # Calling a shell script which invokes a 'liftoff' utility
+  add_pods(["Typhoon", "MagicalRecord"])
+
+  gen :app_delegate
+  gen :core_data_stack
+
+  save :file_system
+  save :xcode_proj
+end
+
+# It's called after each 'ramba' execution
+after_each do |ramba_name|
+  # Some logic here
+end
+
+# It's called in case of an error in any 'ramba'
+error :viper_module do
+  # Some error handling logic here
+end
+```

data/generamba.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'generamba/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'generamba-udf'
+  spec.version       = Generamba::VERSION
+  spec.authors       = ['Egor Tolstoy', 'Andrey Zarembo', 'Beniamin Sarkisyan', 'Aleksandr Sychev']
+  spec.email         = 'rambler.ios@rambler-co.ru'
+
+  spec.summary       = 'Advanced code generator for Xcode projects with a nice and flexible template system.'
+  spec.description   = 'Generamba is a powerful and easy-to-use Xcode code generator. It provides a project-based configuration, flexible templates system, the ability to generate code and tests simultaneously.'
+  spec.homepage      = 'https://github.com/rambler-digital-solutions/Generamba'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = ['generamba']
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.2'
+
+  spec.add_runtime_dependency 'thor', '0.19.1'
+  spec.add_runtime_dependency 'xcodeproj', '>= 1.6.0', '< 2.0.0'
+  spec.add_runtime_dependency 'liquid', '4.0.0'
+  spec.add_runtime_dependency 'git', '1.2.9.1'
+  spec.add_runtime_dependency 'cocoapods-core', '>= 1.4.0', '< 2.0.0'
+  spec.add_runtime_dependency 'terminal-table', '1.4.5'
+
+  spec.add_development_dependency 'bundler', '~> 2.2.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.4'
+  spec.add_development_dependency 'fakefs', '~> 0.6.1'
+  # ActiveSupport dependency is not used by dashramba; instead some other dependency
+  # requires it. We lock it to 4.2.7 so as to avoid using 5.0, which is
+  # not compatible with older versions of Ruby.
+  spec.add_development_dependency 'activesupport', '~> 4.2', '>= 4.2.7'
+end

data/lib/generamba/cli/cli.rb

@@ -0,0 +1,16 @@
+require 'thor'
+require 'xcodeproj'
+require 'liquid'
+require 'git'
+require 'generamba/cli/gen_command.rb'
+require 'generamba/cli/setup_command.rb'
+require 'generamba/cli/version_command.rb'
+require 'generamba/cli/setup_username_command.rb'
+require 'generamba/cli/thor_extension.rb'
+require 'generamba/cli/template/template_group.rb'
+
+module Generamba::CLI
+	class Application < Thor
+		
+	end
+end

data/lib/generamba/cli/gen_command.rb

@@ -0,0 +1,119 @@
+require 'thor'
+require 'generamba/helpers/print_table.rb'
+require 'generamba/helpers/rambafile_validator.rb'
+require 'generamba/helpers/xcodeproj_helper.rb'
+require 'generamba/helpers/dependency_checker.rb'
+require 'generamba/helpers/gen_command_table_parameters_formatter.rb'
+require 'generamba/helpers/module_validator.rb'
+require 'generamba/helpers/module_info_generator.rb'
+
+module Generamba::CLI
+  class Application < Thor
+
+    include Generamba
+
+    desc 'gen [MODULE_NAME] [TEMPLATE_NAME]', 'Creates a new VIPER module with a given name from a specific template'
+    method_option :description, :aliases => '-d', :desc => 'Provides a full description to the module'
+    method_option :author, :desc => 'Specifies the author name for generated module'
+    method_option :project_targets, :desc => 'Specifies project targets for adding new module files'
+    method_option :project_file_path, :desc => 'Specifies a location in the filesystem for new files'
+    method_option :project_group_path, :desc => 'Specifies a location in Xcode groups for new files'
+    method_option :module_path, :desc => 'Specifies a location (both in the filesystem and Xcode) for new files'
+    method_option :test_targets, :desc => 'Specifies project targets for adding new test files'
+    method_option :test_file_path, :desc => 'Specifies a location in the filesystem for new test files'
+    method_option :test_group_path, :desc => 'Specifies a location in Xcode groups for new test files'
+    method_option :test_path, :desc => 'Specifies a location (both in the filesystem and Xcode) for new test files'
+    method_option :custom_parameters, :type => :hash, :default => {}, :desc => 'Specifies extra parameters in format `key1:value1 key2:value2` for usage during code generation'
+    def gen(module_name, template_name)
+      does_rambafile_exist = Dir[RAMBAFILE_NAME].count > 0
+
+      unless does_rambafile_exist
+        puts('Rambafile not found! Run `generamba setup` in the working directory instead!'.red)
+        return
+      end
+
+      rambafile_validator = Generamba::RambafileValidator.new
+      rambafile_validator.validate(RAMBAFILE_NAME)
+
+      setup_username_command = Generamba::CLI::SetupUsernameCommand.new
+      setup_username_command.setup_username
+
+      rambafile = YAML.load_file(RAMBAFILE_NAME)
+
+      code_module = CodeModule.new(module_name, rambafile, options)
+
+      module_validator = ModuleValidator.new
+      module_validator.validate(code_module)
+
+      module_info = ModuleInfoGenerator.new(code_module)
+      template = ModuleTemplate.new(template_name, module_info.scope)
+
+      parameters = GenCommandTableParametersFormatter.prepare_parameters_for_displaying(code_module, template_name)
+      PrintTable.print_values(
+          values: parameters,
+          title: "Summary for gen #{module_name}"
+      )
+
+      DependencyChecker.check_all_required_dependencies_has_in_podfile(template.dependencies, code_module.podfile_path)
+      DependencyChecker.check_all_required_dependencies_has_in_cartfile(template.dependencies, code_module.cartfile_path)
+
+      project = XcodeprojHelper.obtain_project(code_module.xcodeproj_path)
+      module_group_already_exists = XcodeprojHelper.module_with_group_path_already_exists(project, code_module.project_group_path, code_module.create_logical_groups)
+
+      if module_group_already_exists
+        replace_exists_module = yes?("#{module_name} module already exists. Replace? (yes/no)")
+      
+        unless replace_exists_module
+          return
+        end
+      end
+
+      generator = Generamba::ModuleGenerator.new
+      generator.generate_module(module_name, code_module, template)
+    end
+
+    desc 'udf [TEMPLATE_NAME]', 'Creates a new SwiftUI-UDF module with a given name'
+    method_option :description, :aliases => '-d', :desc => 'Provides a full description to the storage'
+    method_option :author, :desc => 'Specifies the author name for generated storage'
+    method_option :project_targets, :desc => 'Specifies project targets for adding new module files'
+    method_option :project_file_path, :desc => 'Specifies a location in the filesystem for new files'
+    method_option :project_group_path, :desc => 'Specifies a location in Xcode groups for new files'
+    method_option :module_path, :desc => 'Specifies a location (both in the filesystem and Xcode) for new files'
+    method_option :test_targets, :desc => 'Specifies project targets for adding new test files'
+    method_option :test_file_path, :desc => 'Specifies a location in the filesystem for new test files'
+    method_option :test_group_path, :desc => 'Specifies a location in Xcode groups for new test files'
+    method_option :test_path, :desc => 'Specifies a location (both in the filesystem and Xcode) for new test files'
+    method_option :test_unit_target, :desc => 'Specifies unit tests target for adding new files'
+    method_option :test_unit_path, :desc => 'Specifies a location (both in the filesystem and Xcode) for new unit test files'
+    method_option :test_unit_testable_import, :desc => 'Specifies unit tests testable import target'
+    method_option :test_snapshot_target, :desc => 'Specifies snapshot tests target for adding new files'
+    method_option :test_snapshot_path, :desc => 'Specifies a location (both in the filesystem and Xcode) for new snapshot test files'
+    method_option :test_snapshot_testable_import, :desc => 'Specifies snapshot tests testable import target'
+    method_option :custom_parameters, :type => :hash, :default => {}, :desc => 'Specifies extra parameters in format `key1:value1 key2:value2` for usage during code generation'
+    def udf(module_name)
+      gen(module_name, 'udf')
+    end
+
+    desc 'storage [TEMPLATE_NAME]', 'Creates a new SwiftUI-UDF storage with a given name'
+    method_option :description, :aliases => '-d', :desc => 'Provides a full description to the storage'
+    method_option :author, :desc => 'Specifies the author name for generated storage'
+    method_option :project_targets, :desc => 'Specifies project targets for adding new module files'
+    method_option :project_file_path, :desc => 'Specifies a location in the filesystem for new files'
+    method_option :project_group_path, :desc => 'Specifies a location in Xcode groups for new files'
+    method_option :module_path, :desc => 'Specifies a location (both in the filesystem and Xcode) for new files'
+    method_option :test_targets, :desc => 'Specifies project targets for adding new test files'
+    method_option :test_file_path, :desc => 'Specifies a location in the filesystem for new test files'
+    method_option :test_group_path, :desc => 'Specifies a location in Xcode groups for new test files'
+    method_option :test_path, :desc => 'Specifies a location (both in the filesystem and Xcode) for new test files'
+    method_option :test_unit_target, :desc => 'Specifies unit tests target for adding new files'
+    method_option :test_unit_path, :desc => 'Specifies a location (both in the filesystem and Xcode) for new unit test files'
+    method_option :test_unit_testable_import, :desc => 'Specifies unit tests testable import target'
+    method_option :test_snapshot_target, :desc => 'Specifies snapshot tests target for adding new files'
+    method_option :test_snapshot_path, :desc => 'Specifies a location (both in the filesystem and Xcode) for new snapshot test files'
+    method_option :test_snapshot_testable_import, :desc => 'Specifies snapshot tests testable import target'
+    method_option :custom_parameters, :type => :hash, :default => {}, :desc => 'Specifies extra parameters in format `key1:value1 key2:value2` for usage during code generation'
+    def storage(module_name)
+      gen(module_name, 'udf-storage')
+    end
+  end
+end

data/lib/generamba/cli/setup_command.rb

@@ -0,0 +1,127 @@
+require 'thor'
+require 'xcodeproj'
+require 'liquid'
+require 'git'
+require 'generamba/constants/rambafile_constants.rb'
+require 'generamba/helpers/print_table.rb'
+
+module Generamba::CLI
+  class Application < Thor
+    include Generamba
+
+    desc 'setup', 'Creates a Rambafile with a config for a given project'
+    def setup
+      properties = {}
+
+      setup_username_command = Generamba::CLI::SetupUsernameCommand.new
+      setup_username_command.setup_username
+
+      properties[COMPANY_KEY] = ask('The company name which will be used in the headers:')
+
+      project_name = Pathname.new(Dir.getwd).basename.to_s
+      is_right_project_name = yes?("The name of your project is #{project_name}. Do you want to use it? (yes/no)")
+
+      properties[PROJECT_NAME_KEY] = is_right_project_name ? project_name : ask_non_empty_string('The project name:', 'Project name should not be empty')
+      properties[PROJECT_PREFIX_KEY]  = ask('The project prefix (if any):')
+
+      xcodeproj_path = ask_file_with_path('*.xcodeproj',
+                                          '.xcodeproj file of the project')
+
+      properties[XCODEPROJ_PATH_KEY] = xcodeproj_path
+      project = Xcodeproj::Project.open(xcodeproj_path)
+
+      targets_prompt = ''
+      project.targets.each_with_index { |element, i| targets_prompt += ("#{i}. #{element.name}" + "\n") }
+      project_target = ask_index("Select the appropriate target for adding your MODULES (type the index):\n" + targets_prompt,project.targets)
+      include_tests = yes?('Are you using unit-tests in this project? (yes/no)')
+
+      test_target = nil
+
+      if include_tests
+        test_target = ask_index("Select the appropriate target for adding your TESTS (type the index):\n" + targets_prompt,project.targets)
+      end
+
+      should_add_all_modules_by_one_path = yes?('Do you want to add all your modules by one path? (yes/no)')
+
+      project_file_path = nil
+      project_group_path = nil
+
+      test_file_path = nil
+      test_group_path = nil
+      
+      create_logical_groups = nil
+
+      if should_add_all_modules_by_one_path || include_tests
+        should_use_same_paths = false
+
+        if should_add_all_modules_by_one_path
+          should_use_same_paths = yes?('Do you want to use the same paths for your files both in Xcode and the filesystem? (yes/no)')
+        end
+
+        if should_use_same_paths
+          if should_add_all_modules_by_one_path
+            project_group_path = ask('The default path for creating new modules:')
+            project_file_path = project_group_path
+          end
+
+          if include_tests
+            test_group_path = ask('The default path for creating tests:')
+            test_file_path = test_group_path
+          end
+        else
+          if should_add_all_modules_by_one_path
+            project_group_path = ask('The default path for creating new modules (in Xcode groups):')
+            project_file_path = ask('The default path for creating new modules (in the filesystem):')
+          end
+
+          if include_tests
+            test_group_path = ask('The default path for creating tests (in Xcode groups):')
+            test_file_path = ask('The default path for creating tests (in the filesystem):')
+          end
+        end
+      end
+
+      create_logical_groups = yes?('Do you want to create Groups in Xcode without folders in filesystem? (yes/no)')
+      
+      using_pods = yes?('Are you using Cocoapods? (yes/no)')
+      if using_pods
+        properties[PODFILE_PATH_KEY] = ask_file_with_path('Podfile', 'Podfile')
+      end
+
+      using_carthage = yes?('Are you using Carthage? (yes/no)')
+      if using_carthage
+        properties[CARTFILE_PATH_KEY] = ask_file_with_path('Cartfile', 'Cartfile')
+      end
+
+      should_add_templates = yes?('Do you want to add some well known templates to the Rambafile? (yes/no)')
+      if should_add_templates
+        properties[TEMPLATES_KEY] = [
+            '{name: rviper_controller}',
+            '{name: mvvm_controller}',
+            '{name: swifty_viper}'
+        ]
+      end
+
+      properties[PROJECT_TARGET_KEY] = project_target.name if project_target
+      properties[PROJECT_FILE_PATH_KEY] = project_file_path if project_file_path
+      properties[PROJECT_GROUP_PATH_KEY] = project_group_path if project_group_path
+      properties[TEST_TARGET_KEY] = test_target.name if test_target
+      properties[TEST_FILE_PATH_KEY] = test_file_path if test_file_path
+      properties[TEST_GROUP_PATH_KEY] = test_group_path if test_group_path
+      properties[CREATE_LOGICAL_GROUPS_KEY] = create_logical_groups if create_logical_groups
+      
+      PrintTable.print_values(
+          values: properties,
+          title: 'Summary for generamba setup'
+      )
+
+      Generamba::RambafileGenerator.create_rambafile(properties)
+      if should_add_templates
+        puts('Rambafile successfully created! Now run `generamba template install`.'.green)
+      else
+        puts('Rambafile successfully created!\n Go on and find some templates in our catalog using `generamba template list` command.\n Add any of them to the Rambafile and run `generamba template install`.'.green)
+      end
+
+    end
+  end
+end