fwtoolkit 0.9.3 → 1.0.1

data/lib/fwtoolkit/cli/project.rb

@@ -0,0 +1,83 @@
+require 'thor'
+require 'fwtoolkit/cli/xcode'
+require 'fwtoolkit/cli/cocoapods'
+require 'fwtoolkit/cli/git'
+require 'fwtoolkit/projectfile'
+require 'fwtoolkit/git_client'
+require 'fwtoolkit/cli/thorutils'
+
+module FWToolkit
+  class Project < Thor
+    include Thor::Actions
+
+    include FWToolkit::ThorUtils
+    source_root_templates!
+
+    desc "new [PROJECT NAME] [CLASS PREFIX]", "Create a new Xcode project with FW's settings"
+    def new(project_name, class_prefix)
+      destination_root = File.join(Dir.pwd, project_name)
+
+      say "Creating new project in: #{File.expand_path destination_root}"
+
+      invoke :conf_rvm, [destination_root]
+
+      invoke FWToolkit::Xcode, 'new', [project_name, class_prefix.upcase, File.join(Dir.pwd, project_name)]
+
+      #invoke FWToolkit::Cocoapods, 'setup', []  #needs empty arg list or it will propagate father'
+      invoke FWToolkit::Cocoapods, 'install', [destination_root]
+
+      #invoke FWToolkit::Frank, 'setup', [destination_root, project_name, class_prefix.upcase]
+
+      git_repo = GitClient::Repository.new destination_root
+      # gitignore is included on xcode new.. for now
+      
+      if(git_repo.initialized?)
+        say_status :skip, 'The git repository is already initialized', :yellow
+      else
+        invoke FWToolkit::Git, 'new', [destination_root]
+      end
+    end
+
+    desc "conf_rvm [PROJECT_DIR]", "Configure rvm/gem environment on a project's folder"
+    def conf_rvm(project_root=Dir.pwd)
+      @project_name = File.basename(project_root)
+      @ruby_version = Config.ruby_version
+      destination_root = project_root
+
+      say 'Configuring rvm'
+
+      directory 'templates/default_project/rvm', destination_root
+
+      inside(destination_root) do
+        run! "rvm #{Config.ruby_version} do rvm --rvmrc --create ruby-#{Config.ruby_version}@#{@project_name}", {:capture => true}
+        bundle_update
+      end
+    end
+
+    desc "update [PROJECT_DIR]", "Update project's pods/gems and submodules"
+    def update(project_root=Dir.pwd)
+      bundle_update
+      
+      invoke FWToolkit::Git, 'update', [project_root]
+      invoke FWToolkit::Cocoapods, 'install', [project_root]
+      
+    end
+
+    private
+
+    def bundle_update
+      if File.exists? 'Gemfile'
+        begin
+          retried ||= false
+          run! 'bundle'
+        rescue Thor::Error
+          run! 'gem install bundler' 
+          retried = true
+          retry unless retried
+        end
+      end
+
+    end
+
+  end
+end

data/lib/fwtoolkit/cli/thorutils.rb

@@ -0,0 +1,14 @@
+module FWToolkit
+  module ThorUtils
+    
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def source_root_templates!
+        source_root File.join(File.dirname(__FILE__), '..', '..', '..')
+      end
+    end
+  end
+end

data/lib/fwtoolkit/cli/xcode.rb

@@ -0,0 +1,105 @@
+require 'thor'
+require 'fileutils'
+require 'fwtoolkit/config'
+require 'fwtoolkit/projectfile'
+require 'fwtoolkit/cli/fw_actions'
+require 'fwtoolkit/cli/thorutils'
+require 'xcodebuild'
+
+# This little hack is necesary to use XcodeBuild outside the context of rake
+module XcodeBuild
+  module Tasks
+    class BuildTask 
+      def define; end
+
+      def build!; xcodebuild :build end
+      def archive!; xcodebuild :archive end
+      def clean!; xcodebuild :clean end
+    end
+  end
+end
+
+module FWToolkit
+  class Xcode < Thor
+    include Thor::Actions
+    include FWToolkit::ThorUtils
+    source_root_templates!
+
+    desc "new [PROJECT_NAME] [CLASS_PREFIX]", "Create a new Xcode project with FW's settings"
+    def new(project_name, class_prefix, root_dir=File.join(Dir.pwd, project_name))
+      say 'Creating Xcode project'
+      destination_root = root_dir
+
+      #raise Thor::Error, "Can't create the project. The directory #{destination_root} already exists" if Dir.exist?(destination_root)
+
+      Projectfile.load_with_config! :project_name => project_name, :class_prefix => class_prefix.upcase
+
+      template_config = { :target_platform => Config.target_platform,
+                          :organization_name => Config.organization_name,
+                          :project_creator => Config.developer_name } 
+      template_config.merge! Projectfile.config 
+      template_directory 'templates/default_project/xcode', destination_root, template_config
+    end
+
+    desc "build [PROJECT_NAME]", "Compile a version of the Xcode project"
+    option :clean,
+           :type => :boolean,
+           :desc => 'Clean the project before building',
+           :default => true
+    option :archive,
+           :type => :boolean,
+           :desc => 'Archive the project after building',
+           :default => false
+    option :type,
+           :banner => 'type of build',
+           :desc => "The kind of build can be one of the following: dev, testing, release. Default: dev",
+           :default => 'dev'
+    option :sdk,
+           :banner => 'iphoneos/iphonesimulator',
+           :desc => "The platform to buy for: iphoneos or iphonesimulator. Default: iphoneos",
+           :default => 'iphoneos'
+    def build(project_dir)
+      build_types = ['dev', 'testing', 'release']
+      raise Thor::Error, 'Build type should be one of the following: dev, testing, release' unless build_types.include?(options[:type].downcase) 
+
+      Projectfile.load! project_dir
+      output_dir = File.join artifacts_dir_for_project(Config.project_name), Projectfile.project_name
+      say_status :run, "Compiling the project and putting the output in: #{output_dir}", :blue
+
+      t = XcodeBuild::Tasks::BuildTask.new
+      t.invoke_from_within = 'project_dir'
+      t.sdk = options[:sdk]
+      t.workspace = Projectfile.xcode_workspace
+      t.scheme = Projectfile.xcode_scheme[options[:type].to_sym]
+      t.formatter = XcodeBuild::Formatters::ProgressFormatter.new
+      t.add_build_setting 'CONFIGURATION_BUILD_DIR', output_dir
+
+      if options[:clean]
+        FileUtils.rm_rf output_dir
+        t.clean!
+      end
+      options[:archive] ? t.archive! : t.build!
+    end
+
+
+    private
+    def artifacts_dir_for_project(project_name)
+      File.join  Config.artifacts_tmp_dir, project_name
+    end
+  end
+end
+
+#            :project_name -> OracleProject
+#            :binary_name -> OracleProject.app
+#            :class_prefix -> FWO
+#            :target_platform -> 6.0
+#            :provisioning
+#
+#binary_name  -> app_name.app
+#target_name  -> app_name
+#tests_target_name -> app_nameTests
+#class_prefix -> XXX
+#project_name -> app_name
+#workspace_name -> app_name
+#project_creator -> dev_name
+#organization_name -> Future Workshops

data/lib/fwtoolkit/cli.rb

@@ -1,40 +1,31 @@
-require 'fwtoolkit'
-require 'frank-cucumber/cli'
-require 'rake'
+require 'thor'
+require 'fwtoolkit/config'
+
+require 'fwtoolkit/cli/ext/thor'
+require 'fwtoolkit/cli/fw_actions'
+
+require 'fwtoolkit/cli/cocoapods'
+require 'fwtoolkit/cli/xcode'
+require 'fwtoolkit/cli/project'
+require 'fwtoolkit/cli/bootstrap'
+require 'fwtoolkit/cli/ci'
+require 'fwtoolkit/cli/frank'
+require 'fwtoolkit/cli/git'
+#require 'fwtoolkit/cli/ota'
 
 module FWToolkit
   class CLI < Thor
-    
-    include Rake::DSL
-    include Thor::Actions
-    
-    desc "model CORE_DATA_MODEL", "create model files for cucumber"
-    method_option :no_prefix, :aliases => "-np", :default => false, :type => :boolean
-    def model(core_data_model_path)
-      # validation step - core_data_model should be of type .xcdatamodel
-      output_dir = File.join('Frank', 'features', 'support', 'models')
-      FWToolkit::CLI.source_root(FWToolkit.root)
-      
-      @no_prefix = options.no_prefix
-      
-      model = CoreData::DataModel.new(File.join(core_data_model_path, 'contents'))
-      @models = model.entities
-      
-      @models.each do |entity|
-        @model = entity
-        factory_template =  File.join 'templates', 'models', 'model.rb.erb'        
-        template(factory_template, File.join(output_dir, "#{class_name(@model).ruby_format}.rb"))
-      end
-      
-      factory_template =  File.join 'templates', 'models', 'factories.rb.erb'
-      template(factory_template, File.join(output_dir, 'factories.rb'))
-    end
-    
-    no_tasks do
-      def class_name(entity)
-        @no_prefix ? entity.name : entity.name[3..-1]
-      end
-    end
+
+    register FWToolkit::Cocoapods, 'pods', 'pods SUBCOMMAND ...ARGS', 'Manage cocoapods'
+    register FWToolkit::Project, 'proj', 'proj SUBCOMMAND ...ARG', 'Create projects and manage settings'
+    register FWToolkit::Xcode, 'xcode', 'xcode SUBCOMMAND ...ARGS', 'Manage Xcode build process'
+    register FWToolkit::Bootstrap, 'bootstrap', 'bootstrap', 'Install and configure system tools'
+    register FWToolkit::Ci, 'ci', 'ci SUBCOMMAND ...ARGS', 'Manage the configuration of projects on the CI'
+    register FWToolkit::Frank, 'test', 'test SUBCOMMAND ...ARGS', 'Manage the testing framework'
+
+    register FWToolkit::Git, 'git', 'git SUBCOMMAND ...ARGS', 'Manage git flow'
+    #register FWToolkit::Ota, 'fwbuild', 'fwbuild SUBCOMMAND ...ARGS', 'Manage publishing build to the OTA server'
   end
-  
-end
+end
+
+#

data/lib/fwtoolkit/config/config.sample

@@ -0,0 +1,8 @@
+#developer_name:    'MANDATORY'
+
+organization_name:  'Future Workshops'
+ruby_version:       '1.9.3'
+target_platform:    '6.0'
+ci_server_url:      'http://ci.office.futureworkshops.com'
+
+hockeyapp_api_token: # Create a token by going to hockeyapp.net

data/lib/fwtoolkit/config.rb

@@ -0,0 +1,41 @@
+require 'fwtoolkit/configfile'
+require 'fileutils'
+
+module FWToolkit
+  module Config 
+    include FWToolkit::ConfigFile
+
+    def self.config_file
+      File.join(ENV['HOME'], '.fwtoolkit', 'config')
+    end
+
+    def load!
+      unless File.exists? config_file
+        FileUtils.copy_file File.join(File.dirname(__FILE__), 'config', 'config.sample'), config_file
+        raise "Please configure fwtoolkit by editing the file at path: #{config_file}"
+      end
+
+      default_config = {  :organization_name => 'Future Workshops',
+                          :ruby_version => '1.9.3',
+                          :target_platform => '6.0',
+                          :ci_server_url => 'http://ci.office.futureworkshops.com',
+                          :artifacts_tmp_dir => '/tmp/fwtoolkit/artifacts' }
+
+      load_config! config_file
+    end
+
+    def validate_config
+      unless @config.has_key?(:developer_name) 
+        raise NameError, "Please configure fwtoolkit by editing the file at path: #{config_file}"
+      end
+    end
+
+    def conf_item_missing(name)
+      raise NoMethodError, "Please provide a valid '#{name}' by editing the conf file at path: #{config_file}"
+    end
+
+    extend self
+  end
+end
+
+FWToolkit::Config.load!

data/lib/fwtoolkit/configfile.rb

@@ -0,0 +1,36 @@
+require 'fwtoolkit/ext/hash_yaml'
+
+# Mixin module that reads a yaml file into a hash and responds to config values
+module FWToolkit
+  module ConfigFile
+
+    attr_accessor :default_config
+
+    def config
+      @config ||= Hash.new
+    end
+
+    def load_config_hash!(config)
+      @config = config
+      merge_config @default_config if @default_config
+      validate_config if self.method_defined? :validate_config
+    end
+
+    def load_config!(config_file)
+      load_config_hash! Hash.hash_from_yaml(config_file)
+    end
+
+    def merge_config(default_config)
+      default_config.each { |key, value| config[key] ||= value }
+    end
+
+    def configure
+      yield config
+    end
+
+    def method_missing(name, *args, &block)
+      puts name
+      config[name.to_sym] || conf_item_missing(name) if self.method_defined? :conf_item_missing
+    end
+  end
+end

data/lib/fwtoolkit/executable/executable.rb

@@ -0,0 +1,45 @@
+module FWToolkit
+  module Executable
+
+    class ThorRunner
+      def run(command, config={})
+        Thor::Actions::run(command, config)
+      end
+
+      def report_error(command, command_output)
+        command_output.gsub!(/e\[\d+m/, '') #Stripping colors
+        say "An error has occured while running: \"#{command}\"", :red
+        say 'Command output:'
+        raise Thor::Error, "\n***\n#{command_output}***"
+      end
+    end
+
+    class CliRunner
+      def run(command, config={})
+        `#{command}`
+      end
+
+      def report_error(command, command_output)
+        command_output.gsub!(/e\[\d+m/, '')
+        puts "An error has occured while running: \"#{command}\"", :red
+        puts 'Command output:'
+        raise "\n***\n#{command_output}***"
+      end
+ 
+    end
+
+    def self.runner=(runner)
+      @@runner = runner
+    end
+
+    def run(command, options = {})
+      cmd_output = @@runner.run command, options
+      @@runner.report_error(command, cmd_output) if options[:raise_errors] && !$?.success?
+    end
+
+    def run!(command, options = {})
+      config.merge!({ :raise_errors => true })
+      run command config
+    end
+  end
+end

data/lib/fwtoolkit/executable.rb

@@ -0,0 +1 @@
+require 'fwtoolkit/executable/executable.rb'

data/lib/fwtoolkit/ext/gem.rb

@@ -0,0 +1,9 @@
+module Gem
+  def self.gem_available?(gem_name)
+    begin
+       Gem::Specification::find_by_name(gem_name)
+    rescue Gem::LoadError
+      false
+    end
+  end
+end

data/lib/fwtoolkit/ext/hash_yaml.rb

@@ -0,0 +1,17 @@
+require 'yaml'
+
+class Hash
+
+  def self.hash_from_yaml(yaml_file)
+    YAML::load_file(yaml_file).symbolize! 
+  end
+  
+  def symbolize!
+    keys.each do |k|
+      self[k.to_sym] = delete(k)
+      self[k.to_sym].symbolize! if self[k.to_sym].is_a? Hash
+    end
+    self
+  end 
+end
+

data/lib/fwtoolkit/git_client/git_client.rb

@@ -0,0 +1,225 @@
+
+module GitClient
+  class GitError < StandardError
+    attr_reader :git_output
+
+    def initialize(git_output)
+      super
+      @git_output = git_output
+    end
+
+    def conflict?
+      git_output.any { |line| line.include? 'CONFLICT' }
+    end
+  end
+
+  class Repository
+    def initialize(repo_path)
+      @repo_root = repo_path
+      @git_folder = File.join(repo_path, '.git')
+      @merge = false
+    end
+
+    def initialized?
+      File.exists? @git_folder
+    end
+
+    def merging?
+      return @merge
+    end
+
+    def init
+      raise GitError.new("The folder #{@repo_root} already contains a git repository") if initialized?
+      git 'init'
+    end
+
+    def current_branch
+      current_branch = git('branch').split("\n").delete_if { |line| line[0] != "*" }
+      current_branch.first.gsub("* ", "")
+    end
+
+    def add_files_to_index(files=nil)
+      files = files ? files : '.'
+      files = files.is_a?(Array) ? files : [files]
+      files.each do |file|
+        git "add \"#{file}\""
+      end
+    end
+
+    def workdir_clean?
+      return status.empty?
+    end
+    # x index, y working_dir
+    #       X          Y     Meaning
+    #       -------------------------------------------------
+    #                 [MD]   not updated
+    #       M        [ MD]   updated in index
+    #       A        [ MD]   added to index
+    #       D         [ M]   deleted from index
+    #       R        [ MD]   renamed in index
+    #       C        [ MD]   copied in index
+    #       [MARC]           index and work tree matches
+    #       [ MARC]     M    work tree changed since index
+    #       [ MARC]     D    deleted in work tree
+    #       -------------------------------------------------
+    #       D           D    unmerged, both deleted
+    #       A           U    unmerged, added by us
+    #       U           D    unmerged, deleted by them
+    #       U           A    unmerged, added by them
+    #       D           U    unmerged, deleted by us
+    #       A           A    unmerged, both added
+    #       U           U    unmerged, both modified
+    #       -------------------------------------------------
+    #       ?           ?    untracked
+    #       !           !    ignored
+    #       -------------------------------------------------
+
+    def status
+      output = git 'status -s'
+      status_hash = Hash.new
+      return status_hash if output.length == 0 || merging?
+
+      output.split("\n").each do |entry|
+        raw_status = entry[0..1]
+        status = case raw_status ##needs to split leaving the freaking spaces on!
+                 when / (M|D)/         then :idx_not_up_to_date
+                 when /(A|M|R)M/       then :idx_not_up_to_date
+                 when /A /             then :idx_added
+                 when /M /             then :idx_modified
+                 when /D /             then :idx_deleted
+                 when /R /             then :idx_renamed
+                 when /\?\?/           then :untracked
+                 when /(DD|AA|(U|D|A)(U|D|A))/ then :merging
+                 else                  :unknown
+                 end
+
+        filename = entry.split(' ')[1]
+        status_hash[status] ||= []
+        status_hash[status] << filename
+      end
+      status_hash
+    end
+
+    def remotes
+      remotes = git 'remote -v'
+      remotes_hash = Hash.new
+      remotes.split("\n").each do |line|
+        split = line.split(' ')[0..1]
+        remotes_hash[symbolicate(split[0])] = split[1]
+      end if remotes
+      remotes_hash
+    end
+
+    def submodules
+      submodules_hash = Hash.new
+      return submodules_hash unless File.exists? File.join(@repo_root, '.gitmodules')
+      
+      submodules = git "config -f .gitmodules --get-regexp '^submodule\..*\.path$'"
+      submodules.split("\n").each do |line|
+        split = line.split(' ')[0..1]
+        submodule_name = split[0][/^submodule.(.*).path$/, 1]
+        submodule_path = split[1]
+        submodule_remote = (git "config -f .gitmodules --get-all 'submodule.#{submodule_name}.url'").delete "\n" 
+
+        submodules_hash[submodule_path] = submodule_remote
+      end 
+      submodules_hash
+    end
+
+    def submodules_update(conf)
+      return if submodules.empty?
+      git "submodule init" if(conf[:init])
+      git "submodule update --recursive"
+    end
+
+    def branch_exist?(branch_name)
+      git('branch').split("\n").any? { |line| line.include? branch_name }
+    end
+
+    def ensure_branch_exists(branch_name)
+      return if branch_exist? branch_name
+      raise GitError, "Branch #{branch_name} doesn't exists"
+    end
+
+    def ensure_workdir_clean
+      return if workdir_clean?
+      raise GitError, 'The working directory is not clean'
+    end
+
+    # returns the commit hash
+    def commit(message)
+      output = git "commit -m\"#{message}\""
+      output[/\[\w* (\w*)\] .*/,1]
+    end
+
+    def switch_branch(branch_name, force_create=true)
+      ensure_branch_exists branch_name unless force_create
+
+      git "branch #{branch_name}" if force_create && !branch_exist?(branch_name)
+      git "checkout \"#{branch_name}\"" unless current_branch == branch_name
+    end
+
+    def merge(from_branch, into_branch=nil, msg=nil)
+      ensure_branch_exists from_branch
+      ensure_branch_exists into_branch if into_branch
+
+      ensure_workdir_clean
+      git "checkout \"#{into_branch}\""
+
+      begin
+        merge = true
+        msg.nil? ? git("merge --no-ff #{from_branch}"): git("merge --no-ff #{from_branch} -m \"#{msg}\"")
+      rescue GitError => e
+        git 'merge --abort' if e.conflict?
+        merge = false
+        raise e
+      end
+    end
+
+    def save_stash
+      git 'stash save'
+    end
+
+    def pop_stash
+      git 'stash pop'
+    end
+
+    def rebase(from_branch, into_branch=nil)
+      ensure_branch_exists from_branch
+      ensure_branch_exists into_branch if into_branch
+      ensure_workdir_clean
+
+      git "checkout \"#{into_branch}\""
+      begin
+        merge = true
+        git "rebase \"#{from_branch}\""
+      rescue GitError => e
+        git 'rebase --abort' if e.conflict?
+        merge = false
+        raise e
+      end
+    end
+
+    private
+
+    # good way of making this more robust:
+    # https://github.com/CocoaPods/CocoaPods/blob/master/lib/cocoapods/executable.rb
+    # and:
+    # https://github.com/CocoaPods/CocoaPods/blob/master/lib/cocoapods/downloader/git.rb
+    def git(git_cmd)
+      output = nil
+      FileUtils.cd(@repo_root) { output = safe_exec("git #{git_cmd}") }
+      output
+    end
+
+    def safe_exec(cmd)
+      cmd_output = `#{cmd} 2>&1 3>&1`
+      raise GitError.new(cmd_output) unless $?.success?
+      cmd_output
+    end
+
+    def symbolicate(string)
+      string.gsub(/\s+/, "_").downcase.to_sym
+    end
+  end
+end

data/lib/fwtoolkit/git_client.rb

@@ -0,0 +1 @@
+require 'fwtoolkit/git_client/git_client'