guard-ocunit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cba6bfe95a4f901658a14c7111990bcac70fbd1a
+  data.tar.gz: 6d15615d67f17e36627c0d9dd665cc84903f6225
+SHA512:
+  metadata.gz: c3f934c4046491b03dacb5bcfc32097f05930f052754187228b92d8f416d1a753d11de70c7a182fadae1527224d3c4800adbf223cd1454d9687ded0c9731909c
+  data.tar.gz: e9302369a697fe5e5deb2c440eb4c111f5d736330aa2eba715333da8a702925db89dc728fdb6a930c17856035c09070740cdf3dd6030b67a3f485b4cf352812f

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Arthur Evstifeev
+
+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,83 @@
+# Guard::OCUnit [![Build Status](https://secure.travis-ci.org/ap4y/guard-ocunit.png?branch=master)](http://travis-ci.org/ap4y/guard-ocunit)
+
+OCUnit guard allows to automatically launch tests when files are modified.
+
+* Compatible with XCode 4.x
+* Tested with XCode 4.5.
+
+## Install
+
+Please be sure to have [Guard](https://github.com/guard/guard) and [ios-sim](https://github.com/phonegap/ios-sim) installed before continue. `guard-ocunit` uses `ios-sim` for running `application` tests from command line, for more info refer to the [SO](http://stackoverflow.com/questions/12557935/xcode-4-5-command-line-unit-testing) question.
+
+Install the gem:
+
+```
+$ gem install guard-ocunit
+```
+
+Add guard definition to your Guardfile by running this command:
+
+```
+$ guard init ocunit
+```
+
+## Usage
+
+Please read [Guard usage doc](https://github.com/guard/guard#readme)
+
+## Guardfile
+
+OCUnit guard can be adapted to your projects.
+
+### Standard Cocoapods project
+
+``` ruby
+guard :ocunit,
+      :derived_data  => '/tmp/tests',
+      :workspace     => 'SampleApp.xcworkspace',
+      :scheme        => 'SampleApp',
+      :test_bundle   => 'SampleAppTests' do
+
+  watch(%r{^SampleAppTests/.+Tests\.m})
+  watch(%r{^SampleApp/Models/(.+)\.[m,h]$}) { |m| "SampleAppTests/#{m[1]}Tests.m" }
+end
+```
+
+Please read [Guard doc](https://github.com/guard/guard#readme) for more information about the Guardfile DSL.
+
+## Options
+
+By default, Guard::OCUnit will only look for test files within `Tests` in your project root. You can configure Guard::OCUnit to look in additional paths by using the `:test_paths` option:
+
+``` ruby
+guard 'ocunit', :test_paths => ["Tests", "/Models/Tests"],:test_bundle => 'SampleAppTests' do
+  # ...
+end
+```
+
+### List of available options:
+
+``` ruby
+:test_bundle  => '',            # test ocunit bundle with provided name, mandatory parameter
+:derived_data => ''/tmp/tests/, # build into provided path, default: current folder
+:workspace    => nil,           # build provided workspace, default: nil, use with :scheme
+:scheme       => nil,           # build provided scheme, default: nil, use with :workspace
+:project      => nil,           # path to the project to test, defaults to current folder
+:sdk          => '',            # link and test against provided device sdk, default: 'iphonesimulator'
+:verbose      => false          # dump all tests information in console
+:notification => false          # display notification after the tests are done running, default: true
+:all_after_pass => false        # run all tests after changed tests pass, default: true
+:all_on_start => false          # run all tests at startup, default: true
+:keep_failed  => false          # keep failed tests until they pass, default: true
+:tests_paths  => ["Tests"]      # specify an array of paths that contain test files
+:focus_on_failed => false       # focus on the first 10 failed tests first, rerun till they pass
+:clean        => false          # defines all builds as clean. By default run all command doing clean build
+:build_variables => ''          # passes provided parameters to the xcodebuild
+:ios_sim_opts => ''             # passes provided options to the ios-sim
+```
+
+## Credits
+
+* [guard-rspec](https://github.com/guard/guard-rspec) by [Thibaud Guillaume-Gentil](https://github.com/thibaudgg)
+* [https://gist.github.com/alloy/3011214](https://gist.github.com/alloy/3011214) by
+[Eloy Durán](https://github.com/alloy)

data/lib/guard/ocunit/formatter.rb

@@ -0,0 +1,75 @@
+require 'guard/ocunit'
+require 'colored'
+
+if RUBY_VERSION =~ /1.9/ #bug with output parsing
+  Encoding.default_external = Encoding::UTF_8
+  Encoding.default_internal = Encoding::UTF_8
+end
+
+class Guard::OCUnit::Formatter < Array
+  attr_reader :passed, :failed, :start_time
+
+  def initialize(io, verbose)
+    @io, @verbose     = io, verbose
+    @failed, @passed  = 0, 0
+    @start_time       = Time.now
+  end
+
+  def <<(line)
+    super
+    @io << case line
+    when /passed/
+      @passed += 1
+      @verbose ? line.green : ''
+    when /failed/
+      @failed += 1
+      line.red
+    when /(error|otest)/
+      line.red
+    else
+      @verbose ? line : ''
+    end
+    self
+  end
+
+  def dump_summary(with_notification=true)
+    end_time = Time.now
+    duration = end_time - @start_time
+    message = guard_message(@passed + @failed, @failed, 0, duration)
+    image   = guard_image(@failed, 0)
+    Guard::UI.info(message.gsub("\n", ' '), :reset => true)
+    notify(message, image) if with_notification
+  end
+
+  def guard_message(example_count, failure_count, pending_count, duration)
+    message = "#{example_count} examples, #{failure_count} failures"
+    if pending_count > 0
+      message << " (#{pending_count} pending)"
+    end
+    message << "\nin #{duration.round(4)} seconds"
+    message
+  end
+
+  # failed | pending | success
+  def guard_image(failure_count, pending_count)
+    if failure_count > 0
+      :failed
+    elsif pending_count > 0
+      :pending
+    else
+      :success
+    end
+  end
+
+  def priority(image)
+    { :failed => 2,
+      :pending => -1,
+      :success => -2
+    }[image]
+  end
+
+  def notify(message, image)
+    Guard::Notifier.notify(message, :title => "OCUnit results", :image => image,
+      :priority => priority(image))
+  end
+end

data/lib/guard/ocunit/inspector.rb

@@ -0,0 +1,64 @@
+module Guard
+  class OCUnit
+    class Inspector
+
+      def initialize(options = {})
+        self.excluded   = options[:exclude]
+        self.test_paths = options[:test_paths]
+      end
+
+      def excluded
+        @excluded || []
+      end
+
+      def excluded=(pattern)
+        @excluded = Dir[pattern.to_s]
+      end
+
+      def test_paths
+        @test_paths || []
+      end
+
+      def test_paths=(paths)
+        @test_paths = Array(paths)
+      end
+
+      def clean(paths)
+        paths.uniq!
+        paths.compact!
+        clear_test_files_list_after do
+          paths = paths.select { |path| should_run_test_file?(path) }
+        end
+        paths.reject { |p| included_in_other_path?(p, paths) }
+      end
+
+    private
+
+      def should_run_test_file?(path)
+        (test_file?(path) || test_folder?(path)) && !excluded.include?(path)
+      end
+
+      def test_file?(path)
+        test_files.include?(path)
+      end
+
+      def test_folder?(path)
+        path.match(%r{^(#{test_paths.join("|")})[^\.]*$})
+      end
+
+      def test_files
+        @test_files ||= test_paths.collect { |path| Dir[File.join(path, "**{,/*/**}", "*.m")] }.flatten
+      end
+
+      def clear_test_files_list_after
+        yield
+        @test_files = nil
+      end
+
+      def included_in_other_path?(path, paths)
+        (paths - [path]).any? { |p| path.include?(p) && path.sub(p, '').include?('/') }
+      end
+
+    end
+  end
+end

data/lib/guard/ocunit/runner.rb

@@ -0,0 +1,133 @@
+require 'xcodebuild'
+require 'open4'
+require 'guard/ocunit/formatter'
+
+module Guard
+  class OCUnit
+    class Runner
+
+      SUCCESS_BUILD_CODE = 0
+      #octool returns 0 if wasn't able to run
+      #also 0 if passed and 1 if tests failed
+      SUCCESS_EXIT_CODE  = 0
+      MISC_ERROR_EXIT_CODE  = 1
+
+      attr_accessor :options
+
+      def initialize(options = {})
+        @options = {
+          :test_bundle      => nil,
+          :derived_data     => '/tmp/tests/',
+          :workspace        => nil,
+          :scheme           => nil,
+          :project          => nil,
+          :sdk              => 'iphonesimulator',
+          :verbose          => false,
+          :notification     => true,
+          :clean            => false,
+          :build_variables  => nil,
+          :ios_sim_opts     => nil
+        }.merge(options)
+      end
+
+      def run(paths, options = {})
+        return false if paths.empty?
+
+        message = options[:message] || "Running: #{paths.join(' ')}"
+        UI.info(message, :reset => true)
+
+        options = @options.merge(options)
+        run_via_shell(paths, options)
+      end
+
+      def xcodebuild(options = {})
+        options = @options.merge(options)
+        path_variables(options)
+
+        # REVIEW: currently not all error messages are going to the output via
+        #   formatter, decided to disable it
+
+        # formatter     = XcodeBuild::Formatters::ProgressFormatter.new
+        # reporter      = XcodeBuild::Reporter.new(formatter)
+        # output_buffer = XcodeBuild::OutputTranslator.new(reporter)
+
+        arguments = []
+        arguments << "-workspace #{options[:workspace]}" unless options[:workspace].to_s.empty?
+        arguments << "-scheme #{options[:scheme]}" unless options[:scheme].to_s.empty?
+        arguments << "-project #{options[:project]}" unless options[:project].to_s.empty?
+        arguments << "-sdk #{options[:sdk].downcase}"
+        arguments << "-configuration Debug"
+        arguments << "-alltargets" if options[:workspace].to_s.empty?
+        arguments << "clean" if options[:clean]
+        arguments << "build"
+        arguments << "CONFIGURATION_BUILD_DIR=#{@built_products_dir}"
+        arguments << options[:build_variables] unless options[:build_variables].to_s.empty?
+
+        XcodeBuild.run(arguments.compact.join(' '), STDOUT)
+      end
+
+    private
+
+      def path_variables(options)
+        project_folder      = options[:project] && File.dirname(options[:project])
+        @derived_data       = project_folder || options[:derived_data]
+        @built_products_dir = File.join(@derived_data, 'build/')
+
+        scheme_name         = options[:scheme]
+        @test_bundle_path   = File.join(@built_products_dir, "#{options[:test_bundle]}.octest")
+        @test_host          = File.join(@built_products_dir, "#{scheme_name}.app", "#{scheme_name}")
+      end
+
+      def run_via_shell(paths, options)
+        build_status = xcodebuild(options)
+
+        status = run_otest(paths, options) if build_status == SUCCESS_BUILD_CODE
+
+        if options[:notification] &&
+          ( !( (0..1) === status ) || build_status != SUCCESS_BUILD_CODE )
+          Notifier.notify("Failed", :title => "OCUnit results",
+                                    :image => :failed,
+                                    :priority => 2)
+        end
+
+        build_status == SUCCESS_BUILD_CODE && (0..1) === status
+      end
+
+      def run_otest(paths, options)
+        test_suites = paths.uniq.join(',')
+
+        stderr  = OCUnit::Formatter.new(STDERR, options[:verbose])
+        command = otest_command(test_suites)
+
+        status = Open4.spawn(command, :stderr => stderr, :status => true)
+        stderr.dump_summary(options[:notification])
+        status.exitstatus
+      end
+
+      def otest_environment_variables()
+        environment_variables = {
+          'DYLD_INSERT_LIBRARIES' => "/../../Library/PrivateFrameworks/IDEBundleInjection.framework/IDEBundleInjection",
+          'XCInjectBundle'        => @test_bundle_path,
+          'XCInjectBundleInto'    => @test_host
+        }
+
+        mapped = environment_variables.map do |key, value|
+          "--setenv #{key}=\"#{value}\""
+        end
+        mapped.join(' ')
+      end
+
+      def otest_command(test_suites)
+        command = []
+        command << 'ios-sim launch'
+        command << "\"#{File.dirname(@test_host)}\""
+        command << "#{otest_environment_variables()}"
+        command << options[:ios_sim_opts] unless options[:ios_sim_opts].to_s.empty?
+        command << '--args'
+        command << "-SenTest #{File.basename(test_suites, '.m')}"
+        command << "#@test_bundle_path"
+        command.compact.join(' ')
+      end
+    end
+  end
+end

data/lib/guard/ocunit/templates/Guardfile

@@ -0,0 +1,14 @@
+guard :ocunit,
+      :test_paths    => ['SampleAppTests'],
+      :workspace     => 'SampleApp.xcworkspace',
+      :scheme        => 'SampleApp',
+      :test_bundle   => 'SampleAppTests' do
+
+  watch(%r{^SampleAppTests/Models/.+Tests\.m})
+  watch(%r{^SampleAppTests/Helpers/.+Tests\.m})
+  watch(%r{^SampleAppTests/ViewControllers/.+Tests\.m})
+
+  watch(%r{^SampleApp/Models/(.+)\.[m,h]$})           { |m| "SampleAppTests/Models/#{m[1]}Tests.m" }
+  watch(%r{^SampleApp/Helpers/(.+)\.[m,h]$})          { |m| "SampleAppTests/Helpers/#{m[1]}Tests.m" }
+  watch(%r{^SampleApp/ViewControllers/(.+)\.[m,h]$})  { |m| "SampleAppTests/ViewControllers/#{m[1]}Tests.m" }
+end

data/lib/guard/ocunit/version.rb

@@ -0,0 +1,5 @@
+module Guard
+  module OCUnitVersion
+    VERSION = "0.1.0"
+  end
+end

data/lib/guard/ocunit.rb

@@ -0,0 +1,129 @@
+require 'guard'
+require 'guard/guard'
+
+module Guard
+  class OCUnit < Guard
+    autoload :Runner,    'guard/ocunit/runner'
+    autoload :Inspector, 'guard/ocunit/inspector'
+
+    attr_accessor :last_failed, :failed_paths, :runner, :inspector
+
+    def initialize(watchers = [], options = {})
+      super
+      @options = {
+        :focus_on_failed  => false,
+        :all_after_pass   => true,
+        :all_on_start     => true,
+        :keep_failed      => true,
+        :test_paths       => ["Tests"],
+        :run_all          => {}
+      }.merge(options)
+      @last_failed  = false
+      @failed_paths = []
+
+      @inspector = Inspector.new(@options)
+      @runner    = Runner.new(@options)
+    end
+
+    # Call once when guard starts
+    def start
+      UI.info "Guard::OCUnit is running"
+      run_all if @options[:all_on_start]
+    end
+
+    def run_all
+      options = @options[:run_all].merge(:message => 'Running all tests',
+                                         :clean   => true)
+      passed = @runner.run(['All'], options)
+
+      unless @last_failed = !passed
+        @failed_paths = []
+      else
+        throw :task_has_failed
+      end
+    end
+
+    def reload
+      @failed_paths = []
+    end
+
+    def run_on_changes(paths)
+      original_paths = paths.dup
+
+      focused = false
+      if last_failed && @options[:focus_on_failed]
+        path = './tmp/ocunit_guard_result'
+        if File.exist?(path)
+          single_test = paths && paths.length == 1 ? paths[0] : nil#&& paths[0].include?("_test")
+          failed_tests = File.open(path) { |file| file.read.split("\n") }
+
+          File.delete(path)
+
+          if single_test && @inspector.clean([single_test]).length == 1
+            failed_tests = failed_tests.select{|p| p.include? single_test}
+          end
+
+          if failed_tests.any?
+            # some sane limit, stuff will explode if all tests fail
+            #   ... cap at 10
+
+            paths = failed_tests[0..10]
+            focused = true
+          end
+
+          # switch focus to the single spec
+          if single_test and failed_tests.length > 0
+            focused = true
+          end
+        end
+      end
+
+      if focused
+        add_failed(original_paths)
+        add_failed(paths.map{|p| p.split(":")[0]})
+      else
+        paths += failed_paths if @options[:keep_failed]
+        paths  = @inspector.clean(paths).uniq
+      end
+
+      if passed = @runner.run(paths)
+        unless focused
+          remove_failed(paths)
+        end
+
+        if last_failed && focused
+          run_on_changes(failed_paths)
+        # run all the tests if the run before this one failed
+        elsif last_failed && @options[:all_after_pass]
+          @last_failed = false
+          run_all
+        end
+      else
+        @last_failed = true
+        unless focused
+          add_failed(paths)
+        end
+
+        throw :task_has_failed
+      end
+    end
+
+  private
+
+    def run(paths)
+    end
+
+    def remove_failed(paths)
+      @failed_paths -= paths if @options[:keep_failed]
+    end
+
+    def add_failed(paths)
+      if @options[:keep_failed]
+        @failed_paths += paths
+        @failed_paths.uniq!
+      end
+    end
+
+  end
+end
+

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: guard-ocunit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Arthur Evstifeev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: open4
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: xcodebuild-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: colored
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Guard::OCUnit automatically runs your tests.
+email:
+- lod@pisem.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/guard/ocunit/formatter.rb
+- lib/guard/ocunit/inspector.rb
+- lib/guard/ocunit/runner.rb
+- lib/guard/ocunit/templates/Guardfile
+- lib/guard/ocunit/version.rb
+- lib/guard/ocunit.rb
+- LICENSE
+- README.md
+homepage: https://github.com/ap4y/guard-ocunit
+licenses: []
+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: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Guard gem for OCUnit
+test_files: []