seagull 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dec044af9abfb2bf1b35d3633f422c59621d825a
-  data.tar.gz: 181d0e91c8bbc4fb04e988fd94919db2944753b3
+  metadata.gz: eca246ae739c6916e531c26e71df1abd766e44db
+  data.tar.gz: 091a023531c9958b84c4e899d8a9b191de2697b2
 SHA512:
-  metadata.gz: 6357bb17d446592aedfb925a28691eefcfa63295f5cb4031afce9b66345427ade30578b155567a958a05f309ef4667f81b4cc1bcfed1a136f62dadfeb555b157
-  data.tar.gz: 632292d5442f91a05eab8f66b9c687f70da3175497c24200cf7d29438f1b387e3c9aee74a62d2077dacd6d5f3b8170fa56dc031eb05df87fb0116f18d56ae82a
+  metadata.gz: c9ae3d32e76a7c0b6fc4cef7d848eb0c42083b18b34fadd61f7fcb33741bc92f3548aa70629d83cf1d496285885eb190fa1272bc21d5f2ce94baf666858d12fc
+  data.tar.gz: 4f6de74dc40da0910ea3ec23dff467a4266da1a6c36f96c73787500be6418d498f323f58af8b9e757052ffabb13c560c05e9cfae1de92d50cd0684be7e0c696b

data/lib/seagull/configuration.rb

@@ -0,0 +1,136 @@
+require 'app_conf'
+require 'seagull/deployment_strategies'
+
+module Seagull
+  class Configuration < AppConf
+    def initialize(defaults = {})
+      super()
+
+      # Set defaults
+      from_hash({
+        :configuration   => {:debug => 'Debug', :beta => 'AdHoc', :release => 'Release'},
+        :build_dir       => 'build',
+        :auto_archive    => true,
+        :changelog_file  => File.expand_path('CHANGELOG.md'),
+        :archive_path    => File.expand_path("~/Library/Developer/Xcode/Archives"),
+        :ipa_path        => File.expand_path("~/Library/Developer/Xcode/Archives"),
+        :dsym_path       => File.expand_path("~/Library/Developer/Xcode/Archives"),
+        :xcpretty        => true,
+        :xctool_path     => "xctool",
+        :xcodebuild_path => "xcodebuild",
+        :workspace_path  => nil,
+        :scheme          => nil,
+        :app_name        => nil,
+        :arch            => nil,
+        :skip_clean      => false,
+        :verbose         => false,
+        :dry_run         => false,
+        
+        :deploy                => {
+          :release_notes_items => 5,
+        },
+        :release_type          => :beta,
+        :deployment_strategies => {},
+      })
+      
+      self.load('.seagull.yml') if File.exists?(".seagull.yml")
+      self.from_hash(defaults)
+    end
+    
+    # Configuration
+    def deployment(release_type, strategy_name, &block)
+      if DeploymentStrategies.valid_strategy?(strategy_name.to_sym)
+        deployment_strategy = DeploymentStrategies.build(strategy_name, self)
+
+        self.deployment_strategies.send("#{release_type}=", deployment_strategy)
+        self.deployment_strategies.send("#{release_type}").configure(&block)
+      else
+        raise "Unknown deployment strategy '#{strategy_name}'."
+      end
+    end
+
+    def deployment_strategy(type)
+      self.active_release_type = type
+      self.deployment_strategies.send(type)
+    end
+    
+    # Accessors
+    def archive_name
+      app_name || target || scheme
+    end
+    
+    def archive_file_name(override = {})
+      "#{archive_name}-#{full_version}_#{configuration.send(override.fetch(:release_type, release_type))}.xcarchive"
+    end
+    
+    def archive_full_path(type)
+      File.join(archive_path, archive_file_name(release_type: type))
+    end
+    
+    def ipa_name
+      app_name || target || scheme
+    end
+    
+    def ipa_file_name(override = {})
+      "#{archive_name}-#{full_version}_#{configuration.send(override.fetch(:release_type, release_type))}.ipa"
+    end
+    
+    def ipa_full_path(type)
+      File.join(ipa_path, ipa_file_name(release_type: type))
+    end
+    
+    def dsym_file_name(override = {})
+      "#{archive_name}-#{full_version}_#{configuration.send(override.fetch(:release_type, release_type))}.dSYM.zip"
+    end
+    
+    def dsym_full_path(type)
+      File.join(dsym_path, dsym_file_name(release_type: type))
+    end
+    
+    def version_data
+      @version_data ||= begin
+        vers    = %x{agvtool vers -terse|tail -1}.strip
+        mvers   = %x{agvtool mvers -terse1|tail -1}.strip
+        {marketing: mvers, version: vers}
+      end
+    end
+    
+    def reload_version!
+      @version_data = nil; version_data
+    end
+    
+    def marketing_version
+      version_data[:marketing]
+    end
+    
+    def version
+      version_data[:version]
+    end
+    
+    def full_version
+      "#{marketing_version}.#{version}"
+    end
+    
+    def version_tag
+      "v#{full_version}"
+    end
+    
+    def build_arguments(override = {})
+      args = {}
+      if workspace
+        args[:workspace]     = "#{workspace}.xcworkspace"
+        args[:scheme]        = scheme
+      else
+        args[:target]  = target
+        args[:project] = project_file_path if project_file_path
+      end
+
+      args[:configuration] = configuration.send(release_type)
+      args[:arch]          = arch unless arch.nil?
+      
+      args.merge!(override)
+      
+      args.collect{|k,v| "-#{k} #{Shellwords.escape(v)}"}
+    end
+  end
+end

data/lib/seagull/deployment_strategies/file.rb

@@ -0,0 +1,37 @@
+module Seagull
+  module DeploymentStrategies
+    class File < DeploymentStrategy
+      def extended_configuration_for_strategy
+        proc do
+          def generate_release_notes(&block)
+            self.release_notes = block if block
+          end
+        end
+      end
+
+      def prepare
+      end
+
+      def deploy
+        # Make sure destionation directoy exists
+        FileUtils.mkpath(@configuration.deploy.path) unless ::File.directory?(@configuration.deploy.path)
+        
+        # Copy xcarchive
+        Dir.chdir(@configuration.archive_path) do
+          deploy_path = ::File.join(@configuration.deploy.path, @configuration.archive_file_name(release_type: @configuration.active_release_type) + ".zip")
+          FileUtils.rm deploy_path if ::File.exists?(deploy_path)
+          system("/usr/bin/zip --symlinks --recurse-paths #{Shellwords.escape(deploy_path)} #{Shellwords.escape(@configuration.archive_file_name(release_type: @configuration.active_release_type))}")
+        end
+        
+        [
+          @configuration.ipa_full_path(@configuration.active_release_type),
+          @configuration.dsym_full_path(@configuration.active_release_type),
+        ].each do |f|
+          FileUtils.cp_r f, @configuration.deploy.path
+        end
+      end
+      
+      private
+    end
+  end
+end

data/lib/seagull/deployment_strategies/hockey_app.rb

@@ -0,0 +1,61 @@
+require 'tempfile'
+require 'json'
+require 'launchy'
+
+module Seagull
+  module DeploymentStrategies
+    class HockeyApp < DeploymentStrategy
+      
+      def defaults
+        {
+          :allow_download => true,
+          :notify         => true,
+          :mandatory      => false,
+          :tags           => '',
+        }
+      end
+      
+      # Nothing to prepare
+      def prepare
+      end
+      
+      def deploy
+        # Create response file
+        response_file = Tempfile.new('seagull_deploy_hockey')
+        payload = {
+          status: @configuration.deploy.allow_download ? 2 : 1,
+          notify: @configuration.deploy.notify ? 1 : 0,
+          mandatory: @configuration.deploy.mandatory ? 1 : 0,
+          tags: @configuration.deploy.tags,
+          notes: release_notes,
+          notes_type: 1,
+          ipa: "@#{Shellwords.escape(@configuration.ipa_full_path(@configuration.active_release_type))}",
+          dsym: "@#{Shellwords.escape(@configuration.dsym_full_path(@configuration.active_release_type))}",
+          commit_sha: %x{git rev-parse HEAD}.strip,
+          repository_url: %x{git remote -v|grep fetch|awk '{print $2;}'}.strip,
+        }
+        opts = payload.collect{|k,v| "-F #{k}=#{Shellwords.escape(v)}"}.join(" ")
+        
+        puts "Uploading to Hockeyapp... Please wait..."
+        system("curl #{opts} -o #{response_file.path} -H 'X-HockeyAppToken: #{@configuration.deploy.token}' https://rink.hockeyapp.net/api/2/apps/#{@configuration.deploy.appid}/app_versions/upload")
+
+        response_body = if response_file.size > 0
+          response_file.read
+        else
+          "{}"
+        end
+        response = JSON.parse(response_body)
+        if response['config_url']
+          puts "Version page: #{response['config_url']}"
+          Launchy.open(response['config_url'])
+        else
+          puts "FAILED to upload app"
+        end
+      ensure
+        response_file.unlink
+      end
+      
+    private
+    end
+  end
+end

data/lib/seagull/deployment_strategies.rb

@@ -0,0 +1,60 @@
+require 'vandamme'
+
+module Seagull
+  module DeploymentStrategies
+    def self.valid_strategy?(strategy_name)
+      strategies.keys.include?(strategy_name.to_sym)
+    end
+
+    def self.build(strategy_name, configuration)
+      strategies[strategy_name.to_sym].new(configuration)
+    end
+
+    class DeploymentStrategy
+      def initialize(configuration)
+        @configuration = configuration
+
+        if respond_to?(:extended_configuration_for_strategy)
+          @configuration.instance_eval(&extended_configuration_for_strategy)
+        end
+      end
+
+      def configure(&block)
+        @configuration.deploy.from_hash(defaults)
+        
+        yield @configuration.deploy
+      end
+      
+      def defaults
+        {}
+      end
+      
+      def prepare
+        puts "Nothing to prepare!"
+      end
+      
+      def deploy
+        raise "NOT IMPLEMENTED"
+      end
+      
+      def release_notes
+        changelog = ::File.exists?(@configuration.changelog_file) ? ::File.read(@configuration.changelog_file) : ""
+
+        parser = Vandamme::Parser.new(changelog: changelog, version_header_exp: '^\*\*?([\w\d\.-]+\.[\w\d\.-]+[a-zA-Z0-9])( \/ (\d{4}-\d{2}-\d{2}|\w+))?\*\*\n?[=-]*', format: 'markdown')
+        changes = parser.parse
+        
+        changes.first(@configuration.deploy.release_notes_items).collect{|v, c| "**#{v}**\n\n#{c}" }.join("\n\n")
+      end
+    end
+
+    private
+
+    def self.strategies
+      {:file => File, :hockeyapp => HockeyApp}
+    end
+  end
+end
+
+require 'seagull/deployment_strategies/file'
+require 'seagull/deployment_strategies/hockey_app'
+

data/lib/seagull/tasks.rb

@@ -0,0 +1,207 @@
+require 'rake'
+require 'rake/tasklib'
+require 'vandamme'
+require 'date'
+require 'term/ansicolor'
+require 'seagull/configuration'
+
+module Seagull
+  class Tasks < ::Rake::TaskLib
+    def initialize(namespace = :seagull, &block)
+      @configuration = Configuration.new
+      @namespace     = namespace
+      
+      yield @configuration if block_given?
+      
+      # Check we can find our xctool
+      unless File.executable?(%x{which #{@configuration.xctool_path}}.strip)
+        raise "xctool is required. Please install using Homebrew: brew install xctool."
+      end
+
+      unless File.executable?(%x{which #{@configuration.xcodebuild_path}}.strip)
+        raise "xcodebuild is required. Please install XCode."
+      end
+      
+      define
+    end
+    
+  private
+    def define
+      # Detect some defaults
+      namespace(@namespace) do
+        task :clean do
+          unless @configuration.skip_clean
+            xctool @configuration.build_arguments, "clean"
+          end
+        end
+
+        desc "Build and run tests"
+        task test: [] do
+          xctool @configuration.build_arguments(configuration: @configuration.configuration.debug, arch: 'i386', sdk: 'iphonesimulator'), "clean", "test", "-freshInstall", "-freshSimulator"
+        end
+        
+        # File dependencies
+        @configuration.configuration.to_hash.each do |type, conf|
+          file @configuration.archive_full_path(type) do
+            xctool @configuration.build_arguments(configuration: conf), "archive", "-archivePath", Shellwords.escape(@configuration.archive_full_path(type))
+          end
+        
+          file @configuration.ipa_full_path(type) => @configuration.archive_full_path(type) do
+            xcodebuild "-exportArchive", "-exportFormat", "ipa", "-archivePath", Shellwords.escape(@configuration.archive_full_path(type)), "-exportPath", Shellwords.escape(@configuration.ipa_full_path(type))
+          end
+          
+          file @configuration.dsym_full_path(type) => @configuration.archive_full_path(type) do
+            dsym_path = File.expand_path(Dir["#{@configuration.archive_full_path(type)}/dSYMS/*"].first)
+            Dir.chdir dsym_path do
+              sh("/usr/bin/zip --symlinks --verbose --recurse-paths '#{@configuration.dsym_full_path(type)}' .")
+            end
+          end
+        end
+        
+        ['beta', 'release'].each do |type|
+          namespace(type) do
+            desc "Archive the #{type} version as an XCArchive file"
+            task archive: [@configuration.archive_full_path(type)]
+          
+            desc "Package the #{type} version as an IPA file"
+            task package: [@configuration.ipa_full_path(type), @configuration.dsym_full_path(type)]
+            
+            if @configuration.deployment_strategies
+              desc "Prepare your app for deployment"
+              task prepare: ['git:verify', :package] do
+                @configuration.deployment_strategy(type).prepare
+              end
+          
+              desc "Deploy the beta using your chosen deployment strategy"
+              task deploy: [:prepare] do
+                @configuration.deployment_strategy(type).deploy
+              end
+          
+              desc "Deploy the last build"
+              task redeploy: [:prepre, :deploy]
+            end
+            
+          end
+          
+          desc "Build, package and deploy beta build"
+          task type => ["#{type}:deploy"] do
+          end
+        end
+        
+        # Version control
+        namespace(:version) do
+          desc "Bumps build number"
+          task bump: ['git:verify:dirty'] do
+            sh("agvtool bump -all")
+            @configuration.reload_version!
+            
+            # Edit changelog
+            Rake::Task["#{@namespace}:changelog:edit"].invoke
+            Rake::Task["#{@namespace}:version:commit"].invoke
+            Rake::Task["#{@namespace}:version:tag"].invoke
+          end
+          
+          task :tag do
+            current_tag = %x{git describe --exact-match `git rev-parse HEAD` 2>/dev/null}.strip
+            unless current_tag == @configuration.version_tag
+              sh("git tag -m 'Released version #{@configuration.full_version}' -s '#{@configuration.version_tag}'")
+            end
+          end
+          
+          task :commit do
+            ver_files = %x{git status --porcelain}.split("\n").collect{|a| Shellwords.escape(a.gsub(/[ AM\?]+ (.*)/, '\1'))}
+            
+            Dir.chdir(git_directory) do
+              sh("git add #{ver_files.join(' ')}")
+              sh("git commit -m 'Bumped version to #{@configuration.full_version}' #{ver_files.join(' ')}")
+            end
+          end
+        end
+        
+        namespace(:changelog) do
+          desc "Edit changelog for current version"
+          task :edit do
+            changelog = if File.exists?(@configuration.changelog_file)
+              File.read(@configuration.changelog_file)
+            else
+              ""
+            end
+
+            tag      = %x{git describe --exact-match `git rev-parse HEAD` 2>/dev/null}.strip
+            tag_date = Date.parse(%x{git log -1 --format=%ai #{tag}})
+            
+            # Parse current changelog
+            parser = Vandamme::Parser.new(changelog: changelog, version_header_exp: '^\*\*?([\w\d\.-]+\.[\w\d\.-]+[a-zA-Z0-9])( \/ (\d{4}-\d{2}-\d{2}|\w+))?\*\*\n?[=-]*', format: 'markdown')
+            changes = parser.parse
+            
+            # Write entry to changelog
+            File.open('CHANGELOG.md', 'w') do |io|
+              unless @configuration.full_version
+                io.puts "**#{@configuration.full_version} / #{tag_date.strftime('%Y-%m-%d')}**"
+                io.puts ""
+                %w{FIXED SECURITY FEATURE ENHANCEMENT PERFORMANCE}.each do |kw|
+                  io.puts " * **#{kw}** Describe changes here or remove if not required"
+                end
+                io.puts ""
+              end
+              io.puts changelog
+            end
+            sh("#{ENV['EDITOR']} CHANGELOG.md")
+          end
+        end
+        
+        namespace(:git) do
+          namespace(:verify) do
+            # Verify GIT tag
+            task :tag do
+              current_tag = %x{git describe --exact-match `git rev-parse HEAD` 2>/dev/null}.strip
+              unless current_tag == @configuration.version_tag
+                puts ""
+                puts Term::ANSIColor.red("!!! Current commit is not properly tagged in GIT. Please tag and release version.")
+                puts ""
+
+                fail unless ENV['IGNORE_GIT_TAG']
+              end
+            end
+            
+            # Verify dirty
+            task :dirty do
+              unless %x{git status -s --ignore-submodules=dirty 2> /dev/null}.empty?
+                puts ""
+                puts Term::ANSIColor.red("!!! Current GIT tree is dirty. Please commit changes before building release.")
+                puts ""
+                
+                fail unless ENV['IGNORE_GIT_DIRTY']
+              end
+            end
+          end
+          
+          task verify: ['verify:tag', 'verify:dirty']
+        end
+        
+        def xctool(*args)
+          sh("#{@configuration.xctool_path} #{args.join(" ")}")
+        end
+
+        def xcodebuild(*args)
+          sh("#{@configuration.xcodebuild_path} #{args.join(" ")} | xcpretty -c; exit ${PIPESTATUS[0]}")
+        end
+      end
+    end
+
+    def git_directory
+      original_cwd = Dir.pwd
+
+      loop do
+        if File.directory?('.git')
+          git_dir = Dir.pwd
+          Dir.chdir(original_cwd) and return git_dir
+        end
+
+        Dir.chdir(original_cwd) and return if Pathname.new(Dir.pwd).root?
+        
+        Dir.chdir('..')
+      end
+    end
+  end
+end

data/lib/seagull/version.rb

@@ -1,170 +1,9 @@
-require 'singleton'
-require 'seagull/config'
-require 'versionomy'
-require 'seagull/versionomy/format_definitions/apple'
-
 module Seagull
   class Version
-    include Singleton
-    
-    def initialize
-      @config = Seagull::Config.instance
-      
-      @version = if File.exists?(@config.version.file)
-        Versionomy.create(YAML.load_file(@config.version.file), @config.version.format)
-      else
-        Versionomy.create({}, @config.version.format)
-      end
-    end
-    
-    def peek(what)
-      peek = case what
-      when :release
-        bump(:major)
-      when :patch
-        bump(:minor)
-      when :update
-        bump(:update)
-      when :build
-        bump(:build)
-      else
-        @version
-      end
-      
-      peek.unparse
-    end
-    
-    # Output marketing version
-    def marketing
-      case @config.version.format
-      when :apple
-        major, minor = if @config.versions![@version.major]
-          @config.versions[@version.major].split('.')
-        else
-          [@version.major, @version.minor]
-        end
-        tiny         = @version.convert(:standard).tiny
-        
-        Versionomy.create(major: major, minor: minor, tiny: tiny).unparse(:required_fields => :tiny)
-      else
-        @version.convert(:standard).unparse(:required_fields => [:major, :minor, :tiny])
-      end
-    end
-    
-    def bundle
-      case @config.version.format
-      when :apple
-        @version.unparse
-      else
-        @version.convert(:standard).tiny2
-      end
-    end
-    
-    def bundle_numeric
-      case @config.version.format
-      when :apple
-        @version.build
-      else
-        @version.convert(:standard).tiny2
-      end      
-    end
-    
-    def save
-      if File.extname(@config.version.file) == '.yml'
-        yaml = if File.exists?(@config.version.file)
-          YAML.load_file(@config.version.file)
-        else
-          {}
-        end
-      
-        yaml.merge!(@version.values_hash)
-        
-        # Some shortcuts
-        yaml.merge!({
-          marketing: self.marketing,
-          bundle: self.bundle,
-          bundle_numeric: self.bundle_numeric,
-          short: self.marketing,
-          string: self.marketing,
-        })
-        
-        File.open(@config.version.file, 'w') {|io| io.puts yaml.to_yaml }
-        
-      else
-        File.open(@config.version.file, 'w') {|io| io.puts @version.unparse }
-      end
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
 
-      # Commit
-      system "git commit #{@config.version.file} -m 'Bumped version to #{self.bundle}'"
-    end
-    
-    # Accessors
-    def build
-      bump!(:build); self
-    end
-    
-    def update
-      bump!(:update); self
-    end
-    
-    def patch
-      bump!(:minor); self
-    end
-    
-    def release(major = nil, version = nil)
-      old_major   = @version.major
-      old_version = @config.versions![old_major.to_s]
-      
-      bump!(:major)
-      
-      major   ||= @version.major
-      version ||= Versionomy.parse(@config.versions![old_major.to_s] || "0.#{major}").bump(:minor).unparse
-      
-      if @config.versions![major] or @config.versions!.invert[version]
-        raise "Version #{version} or major #{major} already exists"
-      end
-      
-      @config.versions![major] = version; @config.save
-      
-      # Commit
-      system "git tag 'v#{self.marketing}' -m 'Released version #{self.marketing}'"
-      
-      self
-    end
-    
-    def bump(field)
-      _tr = {
-        :apple => {},
-        :standard => {
-          :update => :tiny, :build => :tiny2
-        }
-      }
-      
-      _field = _tr[@config.version.format][field] || field
-      
-      if @config.version.format == :apple and field == :update and @version.update.empty?
-        @version.change(update: 'a')
-      else
-        @version.bump(field)
-      end
-    end
-    
-    def bump!(field)
-      @version = bump(field); save; self
-    end
-    
-    def to_s(format = @config.version.format)
-      @version.convert(format).unparse
-    end
-    
-    # Proxy
-    def method_missing(m, *args, &blk)
-      @version.send(m, *args, &blk)
-    end
-    
-    def respond_to?(m)
-      @version.respond_to?(m)
-    end
-    
+    STRING = [MAJOR, MINOR, PATCH].join('.')
   end
 end

data/lib/seagull.rb

@@ -1,4 +1 @@
-require "seagull/version"
-
-module Seagull
-end
+require 'seagull/tasks'

data/seagull.gemspec

@@ -1,10 +1,11 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'seagull/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "seagull"
-  spec.version       = "0.0.1"
+  spec.version       = Seagull::Version::STRING
   spec.authors       = ["Mikko Kokkonen"]
   spec.email         = ["mikko@owlforestry.com"]
   spec.description   = %q{Seagull makes managing XCode projects easy as flying is for seagulls}
@@ -17,9 +18,16 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "versionomy", "~> 0.4"
-  spec.add_dependency "thor", "~> 0.18"
-  spec.add_dependency "hashie"
+  spec.add_dependency "rake",           "~> 10.1"
+  spec.add_dependency "xcpretty",       "~> 0.1.3"
+  spec.add_dependency "app_conf",       "~> 0.4.2"
+  spec.add_dependency "unicode",        "~> 0.4.4"
+  spec.add_dependency "nokogiri",       "~> 1.6.1"
+  spec.add_dependency "vandamme",       "~> 0.0.7"
+  spec.add_dependency "json",           "~> 1.8.1"
+  spec.add_dependency "term-ansicolor", "~> 1.3.0"
+  spec.add_dependency "launchy",        "~> 2.4.2"
+  
+
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake", "~> 10.1"
 end

metadata

@@ -1,107 +1,174 @@
 --- !ruby/object:Gem::Specification
 name: seagull
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Mikko Kokkonen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-13 00:00:00.000000000 Z
+date: 2014-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: versionomy
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '10.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '10.1'
 - !ruby/object:Gem::Dependency
-  name: thor
+  name: xcpretty
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: 0.1.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: 0.1.3
 - !ruby/object:Gem::Dependency
-  name: hashie
+  name: app_conf
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.2
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: unicode
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
+        version: 0.4.4
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: 0.4.4
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: vandamme
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+- !ruby/object:Gem::Dependency
+  name: term-ansicolor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: launchy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.4.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: '1.3'
 description: Seagull makes managing XCode projects easy as flying is for seagulls
 email:
 - mikko@owlforestry.com
-executables:
-- seagull
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
-- VERSION.yml
-- bin/seagull
 - lib/seagull.rb
-- lib/seagull/cli.rb
-- lib/seagull/config.rb
-- lib/seagull/tasks/config.rb
-- lib/seagull/tasks/version.rb
+- lib/seagull/configuration.rb
+- lib/seagull/deployment_strategies.rb
+- lib/seagull/deployment_strategies/file.rb
+- lib/seagull/deployment_strategies/hockey_app.rb
+- lib/seagull/tasks.rb
 - lib/seagull/version.rb
-- lib/seagull/versionomy/format_definitions/apple.rb
 - seagull.gemspec
 homepage: ''
 licenses:
@@ -113,17 +180,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Manage Xcode projects with total control

data/VERSION.yml

@@ -1,5 +0,0 @@
----
-:major: 2
-:minor: B
-:build: 1
-:update: a

data/bin/seagull

@@ -1,17 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
-
-# Do we have seagull inside bundler?
-if File.exists?("Gemfile") and File.read("Gemfile") =~ /#{File.basename($0)}/
-  # Restart tool from bundle if facing load error
-  require 'bundler'
-  begin
-    Bundler.require(:default)
-  rescue LoadError
-    exec "bundle", "exec", File.basename($0), *ARGV
-  end
-end
-
-require 'seagull/cli'
-Seagull::CLI.start

data/lib/seagull/cli.rb

@@ -1,30 +0,0 @@
-require 'thor'
-# require 'seagull/config'
-
-module Seagull
-  class CLI < Thor
-    def initialize(*args)
-      super
-      
-      # @config = Seagull::Config.instance      
-    end
-    
-    desc "debug", "Opens debug console"
-    def debug
-      require 'pry'
-
-      binding.pry
-    end
-  end
-end
-
-# 
-require 'seagull/tasks/config'
-require 'seagull/tasks/version'
-
-module Seagull
-  class CLI
-    register(Seagull::Tasks::Config,  'config',  'config <command>',  'Manage and display configuration settings')
-    register(Seagull::Tasks::Version, 'version', 'version <command>', 'Version release tasks')
-  end
-end

data/lib/seagull/config.rb

@@ -1,41 +0,0 @@
-require 'singleton'
-require 'hashie/mash'
-require 'yaml'
-
-module Seagull
-  class Config
-    include Singleton
-    
-    def initialize
-      @config = Hashie::Mash.new({
-        config:  {file: '.seagull'},
-        version: {file: 'VERSION.yml', format: :apple}
-      })
-      
-      load
-    end
-    
-    def load
-      if File.exists?(@config.config.file)
-        @config.deep_merge!(YAML.load_file(@config.config.file))
-      end
-    end
-    
-    def save
-      File.open(@config.config.file, 'w') {|io| io.puts self.to_yaml }
-    end
-    
-    def to_yaml
-      @config.to_hash.to_yaml
-    end
-    
-    # Proxy
-    def method_missing(m, *args, &blk)
-      @config.send(m, *args, &blk)
-    end
-    
-    def respond_to?(m)
-      @config.respond_to?(m)
-    end
-  end
-end

data/lib/seagull/tasks/config.rb

@@ -1,57 +0,0 @@
-module Seagull
-  module Tasks
-    class Config < Thor
-      def initialize(*args)
-        super
-
-        @config = Seagull::Config.instance
-      end
-      
-      desc "print [KEY]", "Prints current config, with optionally filtering using key"
-      def print(key = nil)
-        cfgs = _build_config_array(@config.to_hash)
-      
-        cfgs.select!{|cfg| cfg.first[/#{key}/] } if key
-
-        print_table(cfgs)
-      end
-    
-      desc "set KEY VALUE", 'Sets given key (as path) to given value'
-      def set(key, value)
-        _value = case value
-        when 'true'         then true
-        when 'yes'          then true
-        when 'false'        then false
-        when 'no'           then false
-        when /^[0-9]+$/     then value.to_i
-        when /^:[a-zA-Z]+$/ then value[1..-1].to_sym
-        else                value
-        end
-
-        keypath = key.split('/')
-        cfg = Hash[keypath.pop, _value]
-        while k = keypath.pop
-          cfg = Hash[k, cfg]
-        end
-        @config.deep_merge!(cfg)
-      
-        @config.save
-        say_status "config", "#{key} set to #{_value}", :green
-      end
-    
-      private
-        def _build_config_array(cfg, prefix = '')
-          cfgs = []
-        
-          cfg.each do |key, value|
-            if value.kind_of?(Hash)
-              cfgs += _build_config_array(value, "#{prefix}/#{key}")
-            else
-              cfgs << ["#{prefix}/#{key}", value]
-            end
-          end
-          cfgs
-        end
-    end
-  end
-end

data/lib/seagull/tasks/version.rb

@@ -1,79 +0,0 @@
-require 'seagull/version'
-
-module Seagull
-  module Tasks
-    class Version < Thor
-      VERSION = Seagull::Version.instance
-      CONFIG  = Seagull::Config.instance
-      
-      desc "print", "Prints current version (#{VERSION.to_s})"
-      def print
-        say_status "current", "Version %s (%s)" % [VERSION.marketing, VERSION.bundle], :blue
-      end
-      
-      desc "list", "List all versions and majors"
-      def list
-        if CONFIG.version.format != :apple
-          say_status "UNKNOWN", "Used version format not using version <-> major coding"
-          exit
-        end
-        
-        if !CONFIG.versions?
-          say_status "UNKNOWN", "Versions and majors have not been defined"
-          exit
-        end
-        
-        table = [['Version', 'Major Version']]
-        table += CONFIG.versions.collect{|k,v| ["%6s.%-3s" % v.split('.'), k.to_i]}.sort
-
-        print_table table
-      end
-      
-      desc "bumplist", "List all possible bump versions"
-      def bumplist
-        peeks    = [:release, :patch, :update, :build]
-        versions = [['Type', 'Version']]
-        versions += peeks.collect{|t| [t.to_s, VERSION.peek(t)]}
-        
-        print_table versions
-      end
-      
-      desc "release [MAJOR] [VERSION]", "Releases new version (#{VERSION.peek(:release)})"
-      def release(major = nil, version = nil)
-        VERSION.release(major, version)
-        
-        say_status "RELEASE", "Version #{VERSION.to_s} has been released", :green
-      rescue => e
-        say_status "FAILED", e.message, :red
-      end
-      
-      desc "name [VERSION_NAME]", "Name current major release (#{VERSION.major})"
-      def name(ver_name)
-        CONFIG.versions![VERSION.major] = ver_name; CONFIG.save
-        say_status "version", "Version #{VERSION.major} named as #{ver_name}"
-      end
-      
-      desc "patch", "Release new patch version (#{VERSION.peek(:patch)})"
-      def patch
-        VERSION.patch
-        say_status "PATCH", "Version increased #{VERSION.to_s}"
-      end
-      
-      desc "update", "Release new update (#{VERSION.peek(:update)})"
-      def update
-        VERSION.update
-        say_status "update", "Version update to #{VERSION.to_s}"
-      end
-      
-      desc "build [BUILDNUMBER]", "Increases build number (#{VERSION.peek(:build)}), optionally set to given number"
-      def build(buildnumber = nil)
-        if buildnumber
-          VERSION.set(build: buildnumber)
-        else
-          VERSION.build
-        end
-        say_status "version", "Increased build number to #{VERSION.to_s}"
-      end
-    end
-  end
-end

data/lib/seagull/versionomy/format_definitions/apple.rb

@@ -1,91 +0,0 @@
-require 'versionomy'
-
-module Versionomy
-  module Format
-    def self.apple
-      get('apple')
-    end
-    
-    module Apple
-      module ExtraMethods
-        
-      end
-      
-      def self.create
-        schema_ = Schema.create do
-          field(:major, :type => :integer, :default_value => 1) do
-            field(:minor, :type => :string, :default_value => 'A') do
-              field(:build, :type => :integer, :default_value => 1) do
-                field(:update, :type => :string)
-              end
-            end
-          end
-          
-          add_module(Format::Apple::ExtraMethods)
-        end
-        
-        Format::Delimiter.new(schema_) do
-          field(:major) do
-            recognize_number(:delimiter_regexp => '', :default_delimiter => '')
-          end
-          
-          field(:minor) do
-            recognize_regexp('[A-Z]',:delimiter_regexp => '', :default_delimiter => '')
-          end
-          
-          field(:build) do
-            recognize_number(:delimiter_regexp => '', :default_delimiter => '')
-          end
-          
-          field(:update) do
-            recognize_regexp('[a-z]', :delimiter_regexp => '', :default_delimiter => '', :default_value_optional => true)
-          end
-        end
-      end
-    end
-      
-    register('apple', Format::Apple.create, true)
-  end
-  
-  module Conversion
-    module Apple
-      def self.create_standard_to_apple
-        Conversion::Parsing.new do
-          to_modify_original_value do |original_, convert_params_|
-            apple_version = {
-              major: original_.major,
-              minor: ('A'..'Z').to_a[original_.minor],
-              build: original_.tiny2,
-              update: (original_.tiny > 0 ? ('a'..'z').to_a[original_.tiny - 1] : nil),
-            }
-            Versionomy.create(apple_version, :apple)
-          end
-        end
-      end
-      
-      def self.create_apple_to_standard
-        Conversion::Parsing.new do
-          to_modify_original_value do |original_, convert_params_|
-            if convert_params_[:versions]
-              major, minor = convert_params_[:versions][original_.major].split(".").map(&:to_i)
-              tiny         = ('A'..'Z').to_a.index(original_.minor)
-              tiny2        = original_.build
-              patchlevel   = !original_.update.empty? ? (('a'..'z').to_a.index(original_.update) + 1) : nil
-            else
-              major      = original_.major
-              minor      = ('A'..'Z').to_a.index(original_.minor)
-              tiny       = !original_.update.empty? ? (('a'..'z').to_a.index(original_.update) + 1) : nil
-              tiny2      = original_.build
-              patchlevel = nil
-            end
-
-            Versionomy.create({major: major, minor: minor, tiny: tiny, tiny2: tiny2, patchlevel: patchlevel})
-          end
-        end
-      end
-    end
-    
-    register(:standard, :apple, Conversion::Apple.create_standard_to_apple, true)
-    register(:apple, :standard, Conversion::Apple.create_apple_to_standard, true)
-  end
-end