generamba 0.6.0

data/lib/generamba/module_generator.rb

@@ -0,0 +1,97 @@
+require 'fileutils'
+
+require 'generamba/helpers/xcodeproj_helper.rb'
+
+module Generamba
+
+	# Responsible for creating the whole code module using information from the CLI
+	class ModuleGenerator
+
+		def generate_module(template_name, name, description)
+			# Setting up CodeModule and ModuleTemplate objects.
+			# TODO: Move it to the CLI infrastructure
+			code_module = CodeModule.new(name, description)
+			template = ModuleTemplate.new(template_name)
+
+			# Setting up Xcode objects
+			project = XcodeprojHelper.obtain_project(ProjectConfiguration.xcodeproj_path)
+			project_target = XcodeprojHelper.obtain_target(ProjectConfiguration.project_target,
+																										 project)
+			test_target = XcodeprojHelper.obtain_target(ProjectConfiguration.test_target,
+																									project)
+
+			# Configuring file paths
+			module_dir_path = Pathname.new(ProjectConfiguration.project_file_path)
+														.join(name)
+			test_dir_path = Pathname.new(ProjectConfiguration.test_file_path)
+													.join(name)
+			FileUtils.mkdir_p module_dir_path
+			FileUtils.mkdir_p test_dir_path
+
+			# Configuring group paths
+			module_group_path = Pathname.new(ProjectConfiguration.project_group_path)
+															.join(name)
+			test_group_path = Pathname.new(ProjectConfiguration.test_group_path)
+														.join(name)
+
+			# Creating code files
+			puts('Creating code files...')
+			process_files(template.code_files,
+										name,
+									 	code_module,
+									 	template,
+										project,
+									 	project_target,
+										module_group_path,
+										module_dir_path)
+
+			# Creating test files
+			puts('Creating test files...')
+			process_files(template.test_files,
+										name,
+										code_module,
+										template,
+										project,
+										test_target,
+										test_group_path,
+										test_dir_path)
+
+			# Saving the current changes in the Xcode project
+			project.save
+			puts("Module #{name} successfully created!")
+		end
+
+		def process_files(files, name, code_module, template, project, target, group_path, dir_path)
+			XcodeprojHelper.clear_group(project, group_path)
+			files.each do |file|
+				# The target file's name consists of three parameters: project prefix, module name and template file name.
+				# E.g. RDS + Authorization + Presenter.h = RDSAuthorizationPresenter.h
+				file_basename = name + File.basename(file[TEMPLATE_NAME_KEY])
+				prefix = ProjectConfiguration.prefix
+				file_name = prefix ? prefix + file_basename : file_basename
+
+				file_group = File.dirname(file[TEMPLATE_NAME_KEY])
+
+				# Generating the content of the code file
+				file_content = ContentGenerator.create_file_content(file,
+																														code_module,
+																														template)
+				file_path = dir_path
+												.join(file_group)
+												.join(file_name)
+
+				# Creating the file in the filesystem
+				FileUtils.mkdir_p File.dirname(file_path)
+				File.open(file_path, 'w+') do |f|
+					f.write(file_content)
+				end
+
+				# Creating the file in the Xcode project
+				XcodeprojHelper.add_file_to_project_and_target(project,
+																											 target,
+																											 group_path.join(file_group),
+																											 file_path)
+			end
+		end
+	end
+end

data/lib/generamba/template/creator/new_template/Code/Service/service.h.liquid

@@ -0,0 +1,11 @@
+//
+//  {{ prefix }}{{ module_info.name }}{{ module_info.file_name }}
+//  {{ module_info.project_name }}
+//
+//  Created by {{ developer.name }} on {{ date }}.
+//  Copyright {{ year }} {{ developer.company }}. All rights reserved.
+//
+
+@interface {{ prefix }}{{ module_info.name }}Service : NSObject
+
+@end

data/lib/generamba/template/creator/new_template/Code/Service/service.m.liquid

@@ -0,0 +1,13 @@
+//
+//  {{ prefix }}{{ module_info.name }}{{ module_info.file_name }}
+//  {{ module_info.project_name }}
+//
+//  Created by {{ developer.name }} on {{ date }}.
+//  Copyright {{ year }} {{ developer.company }}. All rights reserved.
+//
+
+#import "{{ prefix }}{{ module_info.name }}Service.h"
+
+@implementation {{ prefix }}{{ module_info.name }}Service
+
+@end

data/lib/generamba/template/creator/new_template/Tests/Service/service_tests.m.liquid

@@ -0,0 +1,35 @@
+//
+//  {{ prefix }}{{ module_info.name }}{{ module_info.file_name }}
+//  {{ module_info.project_name }}
+//
+//  Created by {{ developer.name }} on {{ date }}.
+//  Copyright {{ year }} {{ developer.company }}. All rights reserved.
+//
+
+#import <XCTest/XCTest.h>
+
+#import "{{ prefix }}{{ module_info.name }}Service.h"
+
+@interface {{ prefix }}{{ module_info.name }}ServiceTests : XCTestCase
+
+@property (strong, nonatomic) {{ prefix }}{{ module_info.name }}Service *service;
+
+@end
+
+@implementation {{ prefix }}{{ module_info.name }}ServiceTests
+
+#pragma mark - Test environment setup
+
+- (void)setUp {
+    [super setUp];
+
+    self.service = [[{{ prefix }}{{ module_info.name }}Service alloc] init];
+}
+
+- (void)tearDown {
+    self.service = nil;
+
+    [super tearDown];
+}
+
+@end

data/lib/generamba/template/creator/new_template/template.rambaspec.liquid

@@ -0,0 +1,20 @@
+# Template information section
+name: {{ name }}
+summary: {{ summary }}
+author: {{ author }}
+version: 1.0.0
+license: {{ license }}
+
+# The declarations for code files
+code_files:
+- {name: Service/Service.h, path: Code/Service/service.h.liquid}
+- {name: Service/Service.m, path: Code/Service/service.m.liquid}
+
+# The declarations for test files
+test_files:
+- {name: Service/ServiceTests.m, path: Tests/Service/service_tests.m.liquid}
+
+# Template dependencies
+dependencies:
+{% for dependency in dependencies %}- {{ dependency }}
+{% endfor %}

data/lib/generamba/template/creator/template_creator.rb

@@ -0,0 +1,38 @@
+module Generamba
+
+  # Responsible for generating new .rambaspec files
+  class TemplateCreator
+
+    NEW_TEMPLATE_FOLDER = 'new_template'
+    RAMBASPEC_TEMPLATE_NAME = 'template.rambaspec.liquid'
+    CODE_FOLDER = 'Code'
+    TESTS_FOLDER = 'Tests'
+
+    # Generates and saves to filesystem a new template with a .rambaspec file and sample code and tests files
+    # @param properties [Hash] User-inputted template properties
+    #
+    # @return [Void]
+    def create_template(properties)
+      template_dir_path = Pathname.new(File.dirname(__FILE__))
+                          .join(NEW_TEMPLATE_FOLDER)
+      rambaspec_template_file_path = template_dir_path.join(RAMBASPEC_TEMPLATE_NAME)
+      code_file_path = template_dir_path.join(CODE_FOLDER)
+      tests_file_path = template_dir_path.join(TESTS_FOLDER)
+
+      template = Tilt.new(rambaspec_template_file_path)
+      output = template.render(properties)
+
+      result_name = properties[TEMPLATE_NAME_KEY] + RAMBASPEC_EXTENSION
+      result_dir_path = Pathname.new(properties[TEMPLATE_NAME_KEY])
+
+      FileUtils.mkdir_p result_dir_path
+      FileUtils.cp_r(code_file_path, result_dir_path)
+      FileUtils.cp_r(tests_file_path, result_dir_path)
+
+      File.open(result_dir_path.join(result_name), 'w+') {|f|
+        f.write(output)
+      }
+    end
+
+  end
+end

data/lib/generamba/template/helpers/rambaspec_validator.rb

@@ -0,0 +1,47 @@
+require 'settingslogic'
+
+module Generamba
+
+  # Provides methods that validate .rambaspec file existance and structure
+  class RambaspecValidator
+
+    # Validates the existance of a .rambaspec file for a given template
+    #
+    # @param template_name [String] The name of the template
+    # @param template_path [String] The local filepath to the template
+    #
+    # @return [Bool]
+    def self.validate_spec_existance(template_name, template_path)
+      local_spec_path = self.obtain_spec_path(template_name, template_path)
+      rambaspec_exist = File.file?(local_spec_path)
+    end
+
+    # Validates the structure of a .rambaspec file for a given template
+    #
+    # @param template_name [String] The name of the template
+    # @param template_path [String] The local filepath to the template
+    #
+    # @return [Bool]
+    def self.validate_spec(template_name, template_path)
+      spec_path = self.obtain_spec_path(template_name, template_path)
+      spec = Settingslogic.new(spec_path)
+
+      is_spec_valid = spec.name != nil && spec.author != nil && spec.version != nil && spec.code_files != nil
+      return is_spec_valid
+    end
+
+    private
+
+    # Returns a filepath for a given .rambaspec filename
+    #
+    # @param template_name [String] The name of the template
+    # @param template_path [String] The local filepath to the template
+    #
+    # @return [Bool]
+    def self.obtain_spec_path(template_name, template_path)
+      spec_filename = template_name + RAMBASPEC_EXTENSION
+      full_path = Pathname.new(template_path)
+                      .join(spec_filename)
+    end
+  end
+end

data/lib/generamba/template/installer/abstract_installer.rb

@@ -0,0 +1,9 @@
+module Generamba
+
+  # Abstract template installer class
+  class AbstractInstaller
+    def install_template(template_declaration)
+      raise 'Abstract Method - you should implement it in the concrete subclass'
+    end
+  end
+end

data/lib/generamba/template/installer/catalog_installer.rb

@@ -0,0 +1,40 @@
+require 'generamba/template/installer/abstract_installer.rb'
+require 'generamba/template/helpers/rambaspec_validator.rb'
+require 'fileutils'
+require 'tmpdir'
+
+module Generamba
+
+  # Incapsulates the logic of installing Generamba templates from the template catalog
+  class CatalogInstaller < AbstractInstaller
+    def install_template(template_declaration)
+      template_name = template_declaration.name
+      puts("Installing #{template_name}...")
+
+      template_name = template_declaration.name
+      catalog_path = Pathname.new(ENV['HOME'])
+                         .join(GENERAMBA_HOME_DIR)
+                         .join(CATALOGS_DIR)
+                         .join(GENERAMBA_CATALOG_NAME)
+      template_path = catalog_path.join(template_name)
+
+      rambaspec_exist = Generamba::RambaspecValidator.validate_spec_existance(template_name, template_path)
+
+      if rambaspec_exist == false
+        error_description = "Cannot find #{template_name + RAMBASPEC_EXTENSION} in the template catalog. Try another name."
+        raise StandardError.new(error_description)
+      end
+
+      rambaspec_valid = Generamba::RambaspecValidator.validate_spec(template_name, template_path)
+      if rambaspec_valid == false
+        error_description = "#{template_name + RAMBASPEC_EXTENSION} is not valid."
+        raise StandardError.new(error_description)
+      end
+
+      install_path = Pathname.new(TEMPLATES_FOLDER)
+                         .join(template_name)
+      FileUtils.mkdir_p install_path
+      FileUtils.copy_entry(template_path, install_path)
+    end
+  end
+end

data/lib/generamba/template/installer/local_installer.rb

@@ -0,0 +1,32 @@
+require 'generamba/template/installer/abstract_installer.rb'
+require 'generamba/template/helpers/rambaspec_validator.rb'
+
+module Generamba
+
+  # Incapsulates the logic of verifying and installing local templates
+  class LocalInstaller < AbstractInstaller
+    def install_template(template_declaration)
+      template_name = template_declaration.name
+      puts("Installing #{template_name}...")
+
+      local_path = template_declaration.local
+      rambaspec_exist = Generamba::RambaspecValidator.validate_spec_existance(template_name, local_path)
+
+      if rambaspec_exist == false
+        error_description = "Cannot find #{template_name + RAMBASPEC_EXTENSION} in the specified directory. Try another path or name."
+        raise StandardError.new(error_description)
+      end
+
+      rambaspec_valid = Generamba::RambaspecValidator.validate_spec(template_name, local_path)
+      if rambaspec_valid == false
+        error_description = "#{template_name + RAMBASPEC_EXTENSION} is not valid."
+        raise StandardError.new(error_description)
+      end
+
+      install_path = Pathname.new(TEMPLATES_FOLDER)
+                         .join(template_name)
+      FileUtils.mkdir_p install_path
+      FileUtils.copy_entry(local_path, install_path)
+    end
+  end
+end

data/lib/generamba/template/installer/remote_installer.rb

@@ -0,0 +1,43 @@
+require 'generamba/template/installer/abstract_installer.rb'
+require 'generamba/template/helpers/rambaspec_validator.rb'
+require 'git'
+require 'fileutils'
+require 'tmpdir'
+
+module Generamba
+
+  # Incapsulates the logic of fetching remote templates, verifying and installing them
+  class RemoteInstaller < AbstractInstaller
+    def install_template(template_declaration)
+      template_name = template_declaration.name
+      puts("Installing #{template_name}...")
+
+      repo_url = template_declaration.git
+
+      temp_path = Dir.tmpdir()
+      template_dir = Pathname.new(temp_path)
+                         .join(template_name)
+      Git.clone(repo_url, template_name, :path => temp_path)
+
+      rambaspec_exist = Generamba::RambaspecValidator.validate_spec_existance(template_name, template_dir)
+      if rambaspec_exist == false
+        FileUtils.rm_rf(temp_path)
+        error_description = "Cannot find #{template_name + RAMBASPEC_EXTENSION} in the root directory of specified repository."
+        raise StandardError.new(error_description)
+      end
+
+      rambaspec_valid = Generamba::RambaspecValidator.validate_spec(template_name, template_dir)
+      if rambaspec_valid == false
+        error_description = "#{template_name + RAMBASPEC_EXTENSION} is not valid."
+        raise StandardError.new(error_description)
+      end
+
+      install_path = Pathname.new(TEMPLATES_FOLDER)
+                         .join(template_name)
+      FileUtils.mkdir_p install_path
+      FileUtils.copy_entry(template_dir, install_path)
+
+      FileUtils.rm_rf(temp_path)
+    end
+  end
+end

data/lib/generamba/template/processor/template_declaration.rb

@@ -0,0 +1,34 @@
+module Generamba
+
+  # This class acts as an Enumeration for TemplateDeclaration types
+  class TemplateDeclarationType
+    # A local template - usually it's stored somewhere outside the current project directory
+    LOCAL_TEMPLATE = 0
+
+    # A remote template - it's stored in a remote Git repository
+    REMOTE_TEMPLATE = 1
+
+    # A template from our shared catalog
+    CATALOG_TEMPLATE = 2
+  end
+
+  # Describes a Generamba template declaration model
+  class TemplateDeclaration
+    attr_reader :name, :local, :git, :type
+
+    def initialize(template_hash)
+      @name = template_hash[TEMPLATE_DECLARATION_NAME_KEY]
+      @local = template_hash[TEMPLATE_DECLARATION_LOCAL_KEY]
+      @git = template_hash[TEMPLATE_DECLARATION_GIT_KEY]
+
+      @type = TemplateDeclarationType::LOCAL_TEMPLATE if @local
+      @type = TemplateDeclarationType::REMOTE_TEMPLATE if @git
+      @type = TemplateDeclarationType::CATALOG_TEMPLATE if @git == nil && @local == nil
+    end
+
+    def install(strategy)
+      strategy.install_template(self)
+    end
+
+  end
+end

data/lib/generamba/template/processor/template_processor.rb

@@ -0,0 +1,77 @@
+require 'generamba/template/processor/template_declaration.rb'
+require 'generamba/template/installer/local_installer.rb'
+require 'generamba/template/installer/remote_installer.rb'
+require 'generamba/template/installer/catalog_installer.rb'
+require 'git'
+
+module Generamba
+
+  # Incapsulates logic of processing templates declaration section from Rambafile
+  class TemplateProcessor
+
+    # This method parses Rambafile, serializes templates hashes into model objects and install them
+    def install_templates
+      # We always clear previously installed templates to avoid conflicts in different versions
+      clear_installed_templates
+
+      rambafile = YAML.load_file(RAMBAFILE_NAME)
+
+      # Mapping hashes to model objects
+      templates = rambafile[TEMPLATES_KEY].map { |template_hash|
+        template_declaration = Generamba::TemplateDeclaration.new(template_hash)
+      }
+
+      if !templates || templates.count == 0
+        error_description = 'You must specify at least one template in Rambafile under the key *project_templates*'
+        raise StandardError.new(error_description)
+      end
+
+      # If there is at least one template from the shared catalog, we should update our local copy of the catalog
+      update_shared_catalog_if_needed(templates)
+
+      templates.each do |template_declaration|
+        strategy = strategy_for_type(template_declaration.type)
+        template_declaration.install(strategy)
+      end
+    end
+
+    private
+
+    # Clears all of the currently installed templates
+    def clear_installed_templates
+      install_path = Pathname.new(TEMPLATES_FOLDER)
+      FileUtils.rm_rf(Dir.glob(install_path))
+    end
+
+    # Clones remote template catalog to the local directory
+    def update_shared_catalog_if_needed(templates)
+      needs_update = templates.any? {|template| template.type == TemplateDeclarationType::CATALOG_TEMPLATE}
+
+      return unless needs_update
+
+      puts('Updating shared generamba-catalog specs...')
+
+      catalog_local_path = Pathname.new(ENV['HOME'])
+                               .join(GENERAMBA_HOME_DIR)
+                               .join(CATALOGS_DIR)
+      FileUtils.rm_rf catalog_local_path
+      FileUtils.mkdir_p catalog_local_path
+
+      Git.clone(RAMBLER_CATALOG_REPO, GENERAMBA_CATALOG_NAME, :path => catalog_local_path)
+    end
+
+    # Provides the appropriate strategy for a given template type
+    def strategy_for_type(type)
+      case type
+        when TemplateDeclarationType::LOCAL_TEMPLATE
+          return Generamba::LocalInstaller.new
+        when TemplateDeclarationType::REMOTE_TEMPLATE
+          return Generamba::RemoteInstaller.new
+        when TemplateDeclarationType::CATALOG_TEMPLATE
+          return Generamba::CatalogInstaller.new
+        else
+          return nil
+      end
+    end
+  end
+end