grenouille 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5fb6d6bb1e943d840ef1d4b37d6701d5d2c07071
+  data.tar.gz: 0514a9e6533a300b3a602fe81fb5e56d56e59256
+SHA512:
+  metadata.gz: aae2f47fb581590773f33df6341641a2cbec7f960f4cca7e6e7b7985356173f286c47a0af55588848b3eebe4c164cffa7924c9ee2726a5930999d9e5f380e880
+  data.tar.gz: fec7b7cc4946fe40e95fa3a95235ec44876600fe8b249922ce368b3a60bf6a8b77d5b63d3a0f97280eca687671b2c41ea61d533758670d9bcdec1b3b9ee64e26

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rubocop.yml

@@ -0,0 +1,14 @@
+Lint/Void:
+  Enabled: false
+
+Metrics/AbcSize:
+  Max: 30
+
+Metrics/LineLength:
+  Max: 142
+
+Metrics/MethodLength:
+  Max: 18
+
+Style/Documentation:
+  Enabled: false

data/.swift-version

@@ -0,0 +1 @@
+1.2

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'bacon'
+  gem 'mocha-on-bacon'
+  gem 'mocha', '~> 0.11.4'
+  gem 'prettybacon', git: 'git@github.com:irrationalfab/PrettyBacon.git', branch: 'master'
+  gem 'coveralls', require: false
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Boris Bügling
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,67 @@
+# Grenouille
+
+[![Build Status](https://img.shields.io/circleci/project/neonichu/grenouille.svg?style=flat)](https://circleci.com/gh/neonichu/grenouille)
+[![Coverage Status](https://coveralls.io/repos/neonichu/grenouille/badge.svg)](https://coveralls.io/r/neonichu/grenouille)
+[![Gem Version](http://img.shields.io/gem/v/grenouille.svg?style=flat)](http://badge.fury.io/rb/grenouille)
+[![Code Climate](http://img.shields.io/codeclimate/github/neonichu/grenouille.svg?style=flat)](https://codeclimate.com/github/neonichu/grenouille)
+
+![](perfume.gif)
+
+Grenouille uses Apple's `swift-update` tool to determine the version of Swift
+used in a set of files automatically.
+
+## Usage
+
+You can use it on the commandline:
+
+```bash
+$ grenouille Stargate.swift 
+1.2
+```
+
+or programmatically:
+
+```ruby
+su = Grenouille::SwiftUpdate.new
+su.determine_version('Stargate.swift')
+# 1.2
+```
+
+You can also get more detailled output:
+
+```ruby
+su.update_to_latest_swift('spec/fixtures/Blueprint.swift')
+# {:report=>[{"file"=>"spec/fixtures/Blueprint.swift", "offset"=>740, "remove"=>2, "text"=>"as!"}, {"file"=>"spec/fixtures/Blueprint.swift", "offset"=>6758, "remove"=>2, "text"=>"as!"}, {"file"=>"spec/fixtures/Blueprint.swift", "offset"=>10613, "remove"=>2, "text"=>"as!"}], :output=>""}
+```
+
+The value for the `:report` key represents the result of `swift-update`, a
+list of changes to perform to transform the current code to the version of
+Swift supported by the used Xcode. The value for the `:output` key is the
+aggregate of stdout and stderr of `swift-update`, e.g. compilation errors.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'grenouille'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install grenouille
+
+Note: The `swift-update` tool is a part of Xcode since 6.3, so it
+needs at least that version to function.
+
+## Contributing
+
+1. Fork it ( https://github.com/neonichu/grenouille/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+
+def specs(dir)
+  FileList["spec/#{dir}/*_spec.rb"].shuffle.join(' ')
+end
+
+desc 'Runs all the specs'
+task :spec do
+  sh "bundle exec bacon #{specs('**')}"
+end
+
+task default: :specs

data/bin/grenouille

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+if $PROGRAM_NAME == __FILE__
+  ENV['BUNDLE_GEMFILE'] = File.expand_path('../../Gemfile', __FILE__)
+  require 'rubygems'
+  require 'bundler/setup'
+  $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+end
+
+require 'grenouille'
+
+su = Grenouille::SwiftUpdate.new
+
+if su.current_version < Gem::Version.new('6.3')
+  puts 'Please install Xcode 6.3 or newer.'
+  exit(1)
+end
+
+begin
+  puts su.determine_version(ARGV)
+rescue StandardError => msg
+  puts "Error: #{msg}"
+  exit(1)
+end

data/circle.yml

@@ -0,0 +1,10 @@
+machine:
+  environment:
+    LANG: en_US.UTF-8
+    XCODE_PROJECT: yolo.xcodeproj
+    XCODE_SCHEME: shrugs
+  xcode:
+    version: "6.3.1"
+test:
+  override:
+    - rake spec

data/grenouille.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'grenouille/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'grenouille'
+  spec.version       = Grenouille::VERSION
+  spec.authors       = ['Boris Bügling']
+  spec.email         = ['boris@buegling.com']
+  spec.summary       = 'Automatically detect Swift versions from source code.'
+  spec.homepage      = 'https://github.com/neonichu/grenouille'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

data/lib/grenouille.rb

@@ -0,0 +1,3 @@
+require 'grenouille/swift_update'
+require 'grenouille/version'
+require 'grenouille/xcode'

data/lib/grenouille/swift_update.rb

@@ -0,0 +1,56 @@
+require 'grenouille/xcode'
+require 'pathname'
+require 'tempfile'
+require 'yaml'
+
+# check for xcrun: error: unable to find utility "swift-update", not a developer tool or in PATH
+
+module Grenouille
+  class SwiftUpdate < Xcode
+    def determine_version(file_glob)
+      required_changes = update_to_latest_swift(file_glob)[:report]
+      required_changes.count == 0 ? current_swift_version : previous_swift_version
+    end
+
+    def update_to_latest_swift(file_glob)
+      fail 'Non-Swift files in input' if Dir.glob(file_glob).reject { |f| Pathname.new(f).extname == '.swift' }.count > 0
+      files = Dir.glob(file_glob).join(' ')
+      fail 'No files in input' if files == ''
+
+      platform = guess_platform(file_glob)
+      sdk_path = xcrun("-sdk #{platform} -show-sdk-path").chomp
+      sdk_version = xcrun("-sdk #{platform} -show-sdk-version").chomp
+      target = platform == :iphoneos ? "-target arm64-apple-ios#{sdk_version}" : ''
+
+      output = xcrun("-sdk #{platform} swift-update 2>&1")
+      fail 'Unable to find "swift-update", install Xcode 6.3 or later' if output =~ /unable to find utility/
+
+      temp_file = Tempfile.new('swift-update')
+      begin
+        output = xcrun("-sdk #{platform} swift-update -sdk #{sdk_path} #{files} #{target} -o #{temp_file.path} 2>&1")
+        report = YAML.load(File.read(temp_file))
+        { report: report, output: output }
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+    end
+
+    private
+
+    def guess_platform(file_glob)
+      Dir.glob(file_glob).each do |file|
+        content = File.read(file)
+        return :macosx if content =~ /^import AppKit$/
+        return :macosx if content =~ /NSTask/
+      end
+
+      :iphoneos
+    end
+
+    def previous_swift_version
+      current = current_swift_version.segments
+      Gem::Version.new("#{current[0]}.#{current[1] - 1}")
+    end
+  end
+end

data/lib/grenouille/version.rb

@@ -0,0 +1,3 @@
+module Grenouille
+  VERSION = '0.0.1'
+end

data/lib/grenouille/xcode.rb

@@ -0,0 +1,33 @@
+require 'rubygems/version'
+
+module Grenouille
+  class Xcode
+    def initialize(developer_dir = `xcode-select -p`.chomp)
+      @developer_dir = developer_dir
+    end
+
+    def current_version
+      get_version('xcodebuild -version')
+    end
+
+    def current_swift_version
+      get_version('swift -version', 3) || get_version('swift -version', 2)
+    end
+
+    def xcrun(command)
+      `DEVELOPER_DIR=#{@developer_dir} xcrun #{command}`
+    end
+
+    private
+
+    def get_version(command, index = 1)
+      version_string = xcrun(command).split(' ')
+
+      if version_string.count >= index + 1 && Gem::Version.correct?(version_string[index])
+        return Gem::Version.new(version_string[index])
+      end
+
+      nil
+    end
+  end
+end

data/spec/fixtures/Blueprint.swift

@@ -0,0 +1,365 @@
+//
+//  Blueprint.swift
+//  Representor
+//
+//  Created by Kyle Fuller on 06/01/2015.
+//  Copyright (c) 2015 Apiary. All rights reserved.
+//
+
+import Foundation
+
+// MARK: Models
+
+/// A structure representing an API Blueprint AST
+public struct Blueprint {
+  /// Name of the API
+  public let name:String
+
+  /// Top-level description of the API in Markdown (.raw) or HTML (.html)
+  public let description:String?
+
+  /// The collection of resource groups
+  public let resourceGroups:[ResourceGroup]
+
+  public init(name:String, description:String?, resourceGroups:[ResourceGroup]) {
+    self.name = name
+    self.description = description
+    self.resourceGroups = resourceGroups
+  }
+
+  public init(ast:[String:AnyObject]) {
+    name = ast["name"] as String
+    description = ast["description"] as? String
+    resourceGroups = parseBlueprintResourceGroups(ast)
+  }
+
+  public init?(named:String, bundle:NSBundle? = nil) {
+    func loadFile(named:String, bundle:NSBundle) -> [String:AnyObject]? {
+      if let url = bundle.URLForResource(named, withExtension: nil) {
+        if let data = NSData(contentsOfURL: url) {
+          let object: AnyObject? = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions(0), error: nil)
+          return object as? [String:AnyObject]
+        }
+      }
+
+      return nil
+    }
+
+    let ast = loadFile(named, bundle ?? NSBundle.mainBundle())
+    if let ast = ast {
+      self.init(ast: ast)
+    } else {
+      return nil
+    }
+  }
+}
+
+/// Logical group of resources.
+public struct ResourceGroup {
+  /// Name of the Resource Group
+  public let name:String
+
+  /// Description of the Resource Group (.raw or .html)
+  public let description:String?
+
+  /// Array of the respective resources belonging to the Resource Group
+  public let resources:[Resource]
+
+  public init(name:String, description:String?, resources:[Resource]) {
+    self.name = name
+    self.description = description
+    self.resources = resources
+  }
+}
+
+/// Description of one resource, or a cluster of resources defined by its URI template
+public struct Resource {
+  /// Name of the Resource
+  public let name:String
+
+  /// Description of the Resource (.raw or .html)
+  public let description:String?
+
+  /// URI Template as defined in RFC6570
+  // TODO, make this a URITemplate object
+  public let uriTemplate:String
+
+  /// Array of URI parameters
+  public let parameters:[Parameter]
+
+  /// Array of actions available on the resource each defining at least one complete HTTP transaction
+  public let actions:[Action]
+
+  public init(name:String, description:String?, uriTemplate:String, parameters:[Parameter], actions:[Action]) {
+    self.name = name
+    self.description = description
+    self.uriTemplate = uriTemplate
+    self.actions = actions
+    self.parameters = parameters
+  }
+}
+
+/// Description of one URI template parameter
+public struct Parameter {
+  /// Name of the parameter
+  public let name:String
+
+  /// Description of the Parameter (.raw or .html)
+  public let description:String?
+
+  /// An arbitrary type of the parameter (a string)
+  public let type:String?
+
+  /// Boolean flag denoting whether the parameter is required (true) or not (false)
+  public let required:Bool
+
+  /// A default value of the parameter (a value assumed when the parameter is not specified)
+  public let defaultValue:String?
+
+  /// An example value of the parameter
+  public let example:String?
+
+  /// An array enumerating possible parameter values
+  public let values:[String]?
+
+  public init(name:String, description:String?, type:String?, required:Bool, defaultValue:String?, example:String?, values:[String]?) {
+    self.name = name
+    self.description = description
+    self.type = type
+    self.required = required
+    self.defaultValue = defaultValue
+    self.example = example
+    self.values = values
+  }
+}
+
+// An HTTP transaction (a request-response transaction). Actions are specified by an HTTP request method within a resource
+public struct Action {
+  /// Name of the Action
+  public let name:String
+
+  /// Description of the Action (.raw or .html)
+  public let description:String?
+
+  /// HTTP request method defining the action
+  public let method:String
+
+  /// Array of URI parameters
+  public let parameters:[Parameter]
+
+  /// URI Template for the action, if it differs from the resource's URI
+  public let uriTemplate:String?
+
+  /// Link relation identifier of the action
+  public let relation:String?
+
+  /// HTTP transaction examples for the relevant HTTP request method
+  public let examples:[TransactionExample]
+
+  public init(name:String, description:String?, method:String, parameters:[Parameter], uriTemplate:String? = nil, relation:String? = nil, examples:[TransactionExample]? = nil) {
+    self.name = name
+    self.description = description
+    self.method = method
+    self.parameters = parameters
+    self.uriTemplate = uriTemplate
+    self.relation = relation
+    self.examples = examples ?? []
+  }
+}
+
+/// An HTTP transaction example with expected HTTP message request and response payload
+public struct TransactionExample {
+  /// Name of the Transaction Example
+  public let name:String
+
+  /// Description of the Transaction Example (.raw or .html)
+  public let description:String?
+
+  /// Example transaction request payloads
+  public let requests:[Payload]
+
+  /// Example transaction response payloads
+  public let responses:[Payload]
+
+  public init(name:String, description:String? = nil, requests:[Payload]? = nil, responses:[Payload]? = nil) {
+    self.name = name
+    self.description = description
+    self.requests = requests ?? []
+    self.responses = responses ?? []
+  }
+}
+
+
+/// An API Blueprint payload.
+public struct Payload {
+  public typealias Header = (name:String, value:String)
+
+  /// Name of the payload
+  public let name:String
+
+  /// Description of the Payload (.raw or .html)
+  public let description:String?
+
+  /// HTTP headers that are expected to be transferred with HTTP message represented by this payload
+  public let headers:[Header]
+
+  /// An entity body to be transferred with HTTP message represented by this payload
+  public let body:NSData?
+
+  public init(name:String, description:String? = nil, headers:[Header]? = nil, body:NSData? = nil) {
+    self.name = name
+    self.description = description
+    self.headers = headers ?? []
+    self.body = body
+  }
+}
+
+
+// MARK: AST Parsing
+
+func compactMap<C : CollectionType, T>(source: C, transform: (C.Generator.Element) -> T?) -> [T] {
+  var collection = [T]()
+
+  for element in source {
+    if let item = transform(element) {
+      collection.append(item)
+    }
+  }
+
+  return collection
+}
+
+func parseParameter(source:[[String:AnyObject]]?) -> [Parameter] {
+  if let source = source {
+    return source.map { item in
+      let name = item["name"] as String
+      let description = item["description"] as? String
+      let type = item["type"] as? String
+      let required = item["required"] as? Bool
+      let defaultValue = item["default"] as? String
+      let example = item["example"] as? String
+      let values = item["values"] as? [String]
+      return Parameter(name: name, description: description, type: type, required: required ?? true, defaultValue: defaultValue, example: example, values: values)
+    }
+  }
+
+  return []
+}
+
+func parseActions(source:[[String:AnyObject]]?) -> [Action] {
+  if let source = source {
+    return compactMap(source) { item in
+      let name = item["name"] as? String
+      let description = item["description"] as? String
+      let method = item["method"] as? String
+      let parameters = parseParameter(item["parameters"] as? [[String:AnyObject]])
+      let attributes = item["attributes"] as? [String:String]
+      let uriTemplate = attributes?["uriTemplate"]
+      let relation = attributes?["relation"]
+      let examples = parseExamples(item["examples"] as? [[String:AnyObject]])
+
+      if let name = name {
+        if let method = method {
+          return Action(name: name, description: description, method: method, parameters: parameters, uriTemplate:uriTemplate, relation:relation, examples:examples)
+        }
+      }
+
+      return nil
+    }
+  }
+
+  return []
+}
+
+func parseExamples(source:[[String:AnyObject]]?) -> [TransactionExample] {
+  if let source = source {
+    return compactMap(source) { item in
+      let name = item["name"] as? String
+      let description = item["description"] as? String
+      let requests = parsePayloads(item["requests"] as? [[String:AnyObject]])
+      let responses = parsePayloads(item["responses"] as? [[String:AnyObject]])
+
+      if let name = name {
+        return TransactionExample(name: name, description: description, requests: requests, responses: responses)
+      }
+
+      return nil
+    }
+  }
+
+  return []
+}
+
+func parsePayloads(source:[[String:AnyObject]]?) -> [Payload] {
+  if let source = source {
+    return compactMap(source) { item in
+      let name = item["name"] as? String
+      let description = item["description"] as? String
+      let headers = parseHeaders(item["headers"] as? [[String:String]])
+      let bodyString = item["body"] as? String
+      let body = bodyString?.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: true)
+
+      if let name = name {
+        return Payload(name: name, description: description, headers: headers, body: body)
+      }
+
+      return nil
+    }
+  }
+
+  return []
+}
+
+func parseHeaders(source:[[String:String]]?) -> [Payload.Header] {
+  if let source = source {
+    return compactMap(source) { item in
+      if let name = item["name"] {
+        if let value = item["value"] {
+          return (name, value)
+        }
+      }
+
+      return nil
+    }
+  }
+
+  return []
+}
+
+func parseResources(source:[[String:AnyObject]]?) -> [Resource] {
+  if let source = source {
+    return compactMap(source) { item in
+      let name = item["name"] as? String
+      let description = item["description"] as? String
+      let uriTemplate = item["uriTemplate"] as? String
+      let actions = parseActions(item["actions"] as? [[String:AnyObject]])
+      let parameters = parseParameter(item["parameters"] as? [[String:AnyObject]])
+
+      if let name = name {
+        if let uriTemplate = uriTemplate {
+          return Resource(name: name, description: description, uriTemplate: uriTemplate, parameters: parameters, actions: actions)
+        }
+      }
+
+      return nil
+    }
+  }
+
+  return []
+}
+
+private func parseBlueprintResourceGroups(blueprint:Dictionary<String, AnyObject>) -> [ResourceGroup] {
+  if let resourceGroups = blueprint["resourceGroups"] as? [[String:AnyObject]] {
+    return compactMap(resourceGroups) { dictionary in
+      if let name = dictionary["name"] as String? {
+        let resources = parseResources(dictionary["resources"] as? [[String:AnyObject]])
+        let description = dictionary["description"] as String?
+        return ResourceGroup(name: name, description: description, resources: resources)
+      }
+
+      return nil
+    }
+  }
+
+  return []
+}

data/spec/fixtures/ChoreTask.swift

@@ -0,0 +1,179 @@
+import Foundation
+
+/// The result of a task execution
+public typealias ChoreResult = (result: Int32, stdout: String, stderr: String)
+
+private func string_trim(string: NSString!) -> String {
+    return string.stringByTrimmingCharactersInSet(.whitespaceAndNewlineCharacterSet()) ?? ""
+}
+
+private func chore_task(command: String, _ arguments: [String] = [String](), stdin: String = "") -> ChoreResult {
+    let task = NSTask()
+
+    task.launchPath = command
+    task.arguments = arguments
+
+    if !(task.launchPath as NSString).absolutePath {
+        task.launchPath = (chore_task("/usr/bin/which", [task.launchPath])).stdout
+    }
+
+    var isDirectory: ObjCBool = false
+
+    if !NSFileManager.defaultManager().fileExistsAtPath(task.launchPath, isDirectory: &isDirectory) {
+        return (255, "", String(format: "%@: launch path not accessible", task.launchPath))
+    }
+
+    if (isDirectory) {
+        return (255, "", String(format: "%@: launch path is a directory", task.launchPath))
+    }
+
+    if !NSFileManager.defaultManager().isExecutableFileAtPath(task.launchPath) {
+        return (255, "", String(format: "%@: launch path not executable", task.launchPath))
+    }
+
+    if count(stdin) > 0 {
+        let stdinPipe = NSPipe()
+        task.standardInput = stdinPipe
+        let stdinHandle = stdinPipe.fileHandleForWriting
+
+        if let data = stdin.dataUsingEncoding(NSUTF8StringEncoding) {
+            stdinHandle.writeData(data)
+            stdinHandle.closeFile()
+        }
+    }
+
+    let stderrPipe = NSPipe()
+    task.standardError = stderrPipe
+    let stderrHandle = stderrPipe.fileHandleForReading
+
+    let stdoutPipe = NSPipe()
+    task.standardOutput = stdoutPipe
+    let stdoutHandle = stdoutPipe.fileHandleForReading
+
+    task.launch()
+    task.waitUntilExit()
+
+    let stderr = string_trim(NSString(data: stderrHandle.readDataToEndOfFile(), encoding: NSUTF8StringEncoding)) ?? ""
+    let stdout = string_trim(NSString(data: stdoutHandle.readDataToEndOfFile(), encoding: NSUTF8StringEncoding)) ?? ""
+
+    return (task.terminationStatus, stdout, stderr)
+}
+
+prefix operator > {}
+
+/**
+Executes a command.
+
+:param: command The command to execute.
+:returns: A tuple containing the exit code, stdout and stderr output.
+*/
+public prefix func > (command: String) -> ChoreResult {
+    return chore_task(command)
+}
+
+/**
+Executes a command with arguments.
+
+:param: command The command to execute and its arguments.
+:returns: A tuple containing the exit code, stdout and stderr output.
+*/
+public prefix func > (command: [String]) -> ChoreResult {
+    switch command.count {
+        case 0:
+            return (0, "", "")
+        case 1:
+            return chore_task(command[0])
+        default:
+            break
+    }
+
+    return chore_task(command[0], Array(command[1..<command.count]))
+}
+
+infix operator | {}
+
+/**
+Executes a command with standard input from another command.
+
+:param: left The result of a previous command.
+:param: right The command to execute.
+:returns: A tuple containing the exit code, stdout and stderr output.
+*/
+public func | (left: ChoreResult, right: String) -> ChoreResult {
+    return left|[right]
+}
+
+/**
+Executes a command with standard input from another command.
+
+:param: left The result of a previous command.
+:param: right The command to execute and its arguments.
+:returns: A tuple containing the exit code, stdout and stderr output.
+*/
+public func | (left: ChoreResult, right: [String]) -> ChoreResult {
+    if left.result != 0 {
+        return left
+    }
+
+    let arguments = right.count >= 2 ? Array(right[1..<right.count]) : [String]()
+    return chore_task(right[0], arguments, stdin: left.stdout)
+}
+
+/**
+Executes a closure with input from a previous command.
+
+:param: left The result of a previous command.
+:param: right The closure to execute.
+:returns: A tuple containing the exit code, stdout and stderr output.
+*/
+public func | (left: ChoreResult, right: ((String) -> String)) -> ChoreResult {
+    if left.result != 0 {
+        return left
+    }
+
+    return (0, right(left.stdout), "")
+}
+
+/**
+Executes a command with input from a closure.
+
+:param: left The closure to execute.
+:param: right The command to execute.
+:returns: A tuple containing the exit code, stdout and stderr output.
+*/
+public func | (left: (() -> String), right: String) -> ChoreResult {
+    return (0, left(), "")|right
+}
+
+/**
+Executes a command with input from a closure.
+
+:param: left The closure to execute.
+:param: right The command to execute and its arguments.
+:returns: A tuple containing the exit code, stdout and stderr output.
+*/
+public func | (left: (() -> String), right: [String]) -> ChoreResult {
+    return (0, left(), "")|right
+}
+
+/**
+Executes a command with input from a string.
+
+:param: left The string to use a stdin.
+:param: right The command to execute.
+:returns: A tuple containing the exit code, stdout and stderr output.
+*/
+public func | (left: String, right: String) -> ChoreResult {
+    return (0, left, "")|right
+}
+
+/**
+Executes a command with input from a string.
+
+:param: left The string to use a stdin.
+:param: right The command to execute and its arguments.
+:returns: A tuple containing the exit code, stdout and stderr output.
+*/
+public func | (left: String, right: [String]) -> ChoreResult {
+    return (0, left, "")|right
+}

data/spec/fixtures/Mac-1.1.swift

@@ -0,0 +1,8 @@
+import Foundation
+import AppKit
+
+private func chore_task() {
+    let task = NSTask()
+    let array = [1,2,3]
+    println(countElements(array))
+}

data/spec/fixtures/Stargate.swift

@@ -0,0 +1,149 @@
+//
+//  Stargate.swift
+//  Stargate
+//
+//  Created by Boris Bügling on 28/04/15.
+//  Copyright (c) 2015 Contentful GmbH. All rights reserved.
+//
+
+import MultipeerConnectivity
+import PeerKit
+
+public typealias DebugHandler = (message: String) -> Void
+
+public class Base {
+    private var applicationGroupIdentifier: String = ""
+    var pingIdentifier = "274EAEF1-A178-47FE-81F4-96E87C242456"
+    var pingPayload = "ping"
+    var sanitizedIdentifier: String {
+        return applicationGroupIdentifier.stringByReplacingOccurrencesOfString(".", withString: "", options: NSStringCompareOptions.allZeros, range: nil).substringToIndex(advance(applicationGroupIdentifier.startIndex, 15))
+    }
+
+    public init(applicationGroupIdentifier: String) {
+        self.applicationGroupIdentifier = applicationGroupIdentifier
+    }
+
+    public func listenForMessage(#identifier: String, _ listener: ((AnyObject!) -> Void)) {
+        fatalError("listenForMessage() needs to be overidden in subclasses.")
+    }
+
+    public func passMessage(message: NSCoding, identifier: String) {
+        fatalError("passMessageObject() needs to be overidden in subclasses.")
+    }
+
+    public func sendMultipeerMessage(message: AnyObject, identifier: String) {
+        let allPeers = PeerKit.session?.connectedPeers as? [MCPeerID]
+        PeerKit.sendEvent(identifier, object: message, toPeers: allPeers)
+    }
+
+    public func stopListeningForMessage(#identifier: String) {
+        fatalError("stopListeningForMessage() needs to be overidden in subclasses.")
+    }
+}
+
+#if os(iOS)
+import MMWormhole
+import WatchKit
+import UIKit
+
+/// Stargate endpoint to be used on the phone
+public class Abydos : Base {
+    private var callback: DebugHandler?
+    var wormhole: MMWormhole!
+
+    public override init(applicationGroupIdentifier: String) {
+        super.init(applicationGroupIdentifier: applicationGroupIdentifier)
+
+        PeerKit.transceive(sanitizedIdentifier)
+        sendMultipeerMessage(pingPayload, identifier: pingIdentifier)
+
+        wormhole = MMWormhole(applicationGroupIdentifier: applicationGroupIdentifier, optionalDirectory: "stargate")
+        wormhole.passMessageObject(pingPayload, identifier: pingIdentifier)
+    }
+
+    public func debug(callback: DebugHandler) {
+        PeerKit.onConnect = { (me, you) -> Void in callback(message: "connect: \(me) <=> \(you)") }
+        self.callback = callback
+    }
+
+    public func tunnel() {
+        PeerKit.transceive(sanitizedIdentifier)
+        PeerKit.onEvent = { (peerID, event, object) -> Void in
+            if let object = object as? NSCoding {
+                if let callback = self.callback {
+                    callback(message: "Received message from Mac: \(object) for \(event)")
+                }
+
+                self.wormhole.passMessageObject(object, identifier: event)
+            }
+        }
+
+        //UIApplication.sharedApplication().beginBackgroundTaskWithExpirationHandler() {}
+    }
+
+    public func tunnelReplies(#identifier: String) {
+        wormhole.listenForMessageWithIdentifier(identifier) { (message) -> Void in
+            if let message: AnyObject = message {
+                if let callback = self.callback {
+                    callback(message: "Received message from watch: \(message) for \(identifier)")
+                }
+
+                self.sendMultipeerMessage(message, identifier: identifier)
+            }
+        }
+    }
+}
+
+/// Stargate endpoint to be used on the ᴡᴀᴛᴄʜ
+public class Atlantis : Base {
+    var wormhole: MMWormhole!
+
+    public override init(applicationGroupIdentifier: String) {
+        super.init(applicationGroupIdentifier: applicationGroupIdentifier)
+
+        wormhole = MMWormhole(applicationGroupIdentifier: applicationGroupIdentifier, optionalDirectory: "stargate")
+        passMessage(pingPayload, identifier: pingIdentifier)
+    }
+
+    public override func listenForMessage(#identifier: String, _ listener: ((AnyObject!) -> Void)) {
+        wormhole.listenForMessageWithIdentifier(identifier, listener: listener)
+
+        WKInterfaceController.openParentApplication([NSObject : AnyObject](), reply: nil)
+    }
+
+    public override func passMessage(message: NSCoding, identifier: String) {
+        wormhole.passMessageObject(message, identifier: identifier)
+
+        WKInterfaceController.openParentApplication([NSObject : AnyObject](), reply: nil)
+    }
+
+    public override func stopListeningForMessage(#identifier: String) {
+        wormhole.stopListeningForMessageWithIdentifier(identifier)
+    }
+}
+
+#endif
+
+/// Stargate endpoint to be used on the Mac
+public class Earth : Base {
+    public override init(applicationGroupIdentifier: String) {
+        super.init(applicationGroupIdentifier: applicationGroupIdentifier)
+
+        PeerKit.transceive(sanitizedIdentifier)
+        passMessage(pingPayload, identifier: pingIdentifier)
+    }
+
+    public override func listenForMessage(#identifier: String, _ listener: ((AnyObject!) -> Void)) {
+        PeerKit.eventBlocks[identifier] = { (peerID, object) -> Void in
+            listener(object)
+        }
+    }
+
+    public override func passMessage(message: NSCoding, identifier: String) {
+        sendMultipeerMessage(message, identifier: identifier)
+    }
+
+    public override func stopListeningForMessage(#identifier: String) {
+        PeerKit.stopTransceiving()
+    }
+}

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'pathname'
+ROOT = Pathname.new(File.expand_path('../../', __FILE__))
+$LOAD_PATH.unshift((ROOT + 'lib').to_s)
+$LOAD_PATH.unshift((ROOT + 'spec').to_s)
+
+require 'bundler/setup'
+require 'bacon'
+require 'mocha-on-bacon'
+require 'pretty_bacon'
+
+require 'grenouille'

data/spec/swift_update_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Grenouille
+  describe SwiftUpdate do
+    it 'reports Swift 1.2 code correctly' do
+      detected_version = SwiftUpdate.new.determine_version('spec/fixtures/Stargate.swift')
+
+      detected_version.should == Gem::Version.new('1.2')
+    end
+
+    it 'reports Swift 1.1 code correctly' do
+      detected_version = SwiftUpdate.new.determine_version('spec/fixtures/Blueprint.swift')
+
+      detected_version.should == Gem::Version.new('1.1')
+    end
+
+    it 'can handle Swift 1.2 on iOS' do
+      result = SwiftUpdate.new.update_to_latest_swift('spec/fixtures/Stargate.swift')
+
+      result[:report].should == []
+      result[:output].start_with?('spec/fixtures/Stargate.swift:10:8: error: no such module \'PeerKit\'').should == true
+    end
+
+    it 'can handle Swift 1.1 on iOS' do
+      result = SwiftUpdate.new.update_to_latest_swift('spec/fixtures/Blueprint.swift')
+
+      result[:report].count.should == 3
+      result[:output].should == ''
+    end
+
+    it 'can handle Swift 1.2 on OS X' do
+      result = SwiftUpdate.new.update_to_latest_swift('spec/fixtures/ChoreTask.swift')
+
+      result[:report].should == []
+      result[:output].should == ''
+    end
+
+    it 'can handle Swift 1.1 on OS X' do
+      result = SwiftUpdate.new.update_to_latest_swift('spec/fixtures/Mac-1.1.swift')
+
+      result[:report].count.should == 1
+      result[:output].should == ''
+    end
+
+    it 'supports file globbing' do
+      detected_version = SwiftUpdate.new.determine_version('spec/fixtures/*.swift')
+
+      detected_version.should == Gem::Version.new('1.1')
+    end
+
+    it 'accepts a list of files' do
+      detected_version = SwiftUpdate.new.determine_version(['spec/fixtures/ChoresTask.swift', 'spec/fixtures/Mac-1.1.swift'])
+
+      detected_version.should == Gem::Version.new('1.1')
+    end
+
+    it 'throws when non Swift files are provided as arguments' do
+      should.raise(StandardError) { SwiftUpdate.new.determine_version('spec/*.rb') }
+    end
+  end
+end

data/spec/xcode_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+module Grenouille
+  describe Xcode do
+    it 'can retrieve the version number of the currently selected Swift' do
+      Xcode.any_instance.stubs(:`).returns("Apple Swift version 1.3 (swiftlang-602.0.49.6 clang-602.0.49)\nTarget: x86_64-apple-darwin14.4.0")
+
+      Xcode.new.current_swift_version.should == Gem::Version.new('1.3')
+    end
+
+    it 'can retrieve the version of Swift 1.1' do
+      Xcode.any_instance.stubs(:`).returns('Swift version 1.1 (swift-600.0.57.4)')
+
+      Xcode.new.current_swift_version.should == Gem::Version.new('1.1')
+    end
+
+    it 'can retrieve the version number of the currently selected Xcode' do
+      Xcode.any_instance.stubs(:`).returns("Xcode 3.2.1\nBuild version 6D1002")
+
+      Xcode.new.current_version.should == Gem::Version.new('3.2.1')
+    end
+
+    it 'is resilient against xcodebuild not producing any output' do
+      Xcode.any_instance.stubs(:`).returns('')
+
+      Xcode.new.current_version.should.be.nil
+    end
+
+    it 'is resilient against xcodebuild not producing the desired output' do
+      Xcode.any_instance.stubs(:`).returns(File.read(__FILE__))
+
+      Xcode.new.current_version.should.be.nil
+    end
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: grenouille
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Boris Bügling
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- boris@buegling.com
+executables:
+- grenouille
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rubocop.yml
+- .swift-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/grenouille
+- circle.yml
+- grenouille.gemspec
+- lib/grenouille.rb
+- lib/grenouille/swift_update.rb
+- lib/grenouille/version.rb
+- lib/grenouille/xcode.rb
+- perfume.gif
+- spec/fixtures/Blueprint.swift
+- spec/fixtures/ChoreTask.swift
+- spec/fixtures/Mac-1.1.swift
+- spec/fixtures/Stargate.swift
+- spec/spec_helper.rb
+- spec/swift_update_spec.rb
+- spec/xcode_spec.rb
+homepage: https://github.com/neonichu/grenouille
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.14
+signing_key: 
+specification_version: 4
+summary: Automatically detect Swift versions from source code.
+test_files:
+- spec/fixtures/Blueprint.swift
+- spec/fixtures/ChoreTask.swift
+- spec/fixtures/Mac-1.1.swift
+- spec/fixtures/Stargate.swift
+- spec/spec_helper.rb
+- spec/swift_update_spec.rb
+- spec/xcode_spec.rb
+has_rdoc: