zucchini-ios 0.6.2 → 0.7.0

data/.travis.yml

@@ -1,6 +1,16 @@
 language: ruby
+
+env:
+  - COVERAGE=coveralls
+
 rvm:
   - 1.9.3
-  - 1.9.2
+  - 2.0.0
+  - rbx-19mode
+
+matrix:
+  allow_failures:
+      - rvm: rbx-19mode
+
 before_install:
   - npm install coffee-script

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.7.0 / 2013-08-11
+* Integrate mechanic.js - [@vaskas][], [#29][]
+* Configure simulator with device and orientation - [@phatmann][], [#27][]
+
 ## 0.6.2 / 2013-08-07
 * Implement screen specific masks - [@phatmann][], [#24][]
 * Rearrange source files in a more conventional gem way - [@vaskas][], [#25][]
@@ -53,6 +57,8 @@
 [#24]: https://github.com/zucchini-src/zucchini/issues/24
 [#25]: https://github.com/zucchini-src/zucchini/issues/25
 [#26]: https://github.com/zucchini-src/zucchini/issues/26
+[#27]: https://github.com/zucchini-src/zucchini/issues/27
+[#29]: https://github.com/zucchini-src/zucchini/issues/29
 
 [@Jaco-Pretorius]: https://github.com/Jaco-Pretorius
 [@NathanSudell]: https://github.com/NathanSudell

data/lib/zucchini.rb

@@ -4,6 +4,8 @@ module Zucchini
   require 'zucchini/config'
   require 'zucchini/screenshot'
   require 'zucchini/report'
+  require 'zucchini/compiler'
+  require 'zucchini/device'
   require 'zucchini/feature'
   require 'zucchini/detector'
   require 'zucchini/runner'

data/lib/zucchini/compiler.rb

@@ -0,0 +1,59 @@
+module Zucchini
+  module Compiler
+
+    # Compile the feature Javascript file for UIAutomation
+    #
+    # @param orientation [String] initial device orientation, `portrait` or `landscape`
+    # @return [String] path to a compiled js file
+    def compile_js(orientation)
+      js_path  = "#{run_data_path}/feature.js"
+      lib_path = File.expand_path(File.dirname(__FILE__))
+
+      coffee_src_paths = [
+        "#{lib_path}/uia",
+        "#{path}/../support/screens",
+        "#{path}/../support/lib",
+        feature_coffee("#{path}/feature.zucchini", orientation)
+      ].select { |p| File.exists? p }.join ' '
+
+      "coffee -o #{run_data_path} -j #{js_path} -c #{coffee_src_paths}".tap do |cmd|
+        raise "Error compiling a feature file: #{cmd}" unless system(cmd)
+      end
+
+      concat("#{lib_path}/uia/lib", js_path)
+      js_path
+    end
+
+    private
+
+    # Wrap feature text into a call to Zucchini client side runner
+    #
+    # @param file [String] path to a feature file
+    # @param orientation [String] initial device orientation
+    # @return [String] path to the resulting CoffeeScript file
+    def feature_coffee(file, orientation)
+      cs_path = "#{run_data_path}/feature.coffee"
+
+      File.open(cs_path, "w+") do |f|
+        feature_text = File.read(file).gsub(/\#.+[\z\n]?/,"").gsub(/\n/, "\\n")
+        f.write "Zucchini('#{feature_text}', '#{orientation}')"
+      end
+      cs_path
+    end
+
+    def concat(lib_path, js_path)
+      tmp_file = "/tmp/feature.js"
+
+      js_src = Dir.glob("#{lib_path}/*.js").inject([]) do |libs, f|
+        libs << File.read(f)
+      end.join(";\n")
+
+      File.open(tmp_file, 'w') do |f|
+        f.puts(js_src)
+        f.puts(File.read(js_path))
+      end
+
+      File.rename(tmp_file, js_path)
+    end
+  end
+end

data/lib/zucchini/config.rb

@@ -20,10 +20,11 @@ module Zucchini
     end
 
     def self.app
-      device_name = ENV['ZUCCHINI_DEVICE'] || @@default_device_name
-      app_path    = File.absolute_path(devices[device_name]['app'] || @@config['app'] || ENV['ZUCCHINI_APP'])
+      device_name  = ENV['ZUCCHINI_DEVICE'] || @@default_device_name
+      device       = devices[device_name]
+      app_path     = File.absolute_path(device['app'] || @@config['app'] || ENV['ZUCCHINI_APP'])
 
-      if device_name == 'iOS Simulator' && !File.exists?(app_path)
+      if (device_name == 'iOS Simulator' || device['simulator']) && !File.exists?(app_path)
         raise "Can't find application at path #{app_path}"
       end
       app_path
@@ -44,23 +45,26 @@ module Zucchini
     def self.device(device_name)
       device_name ||= @@default_device_name
       raise "Neither default device nor ZUCCHINI_DEVICE environment variable was set" unless device_name
-      raise "Device not listed in config.yml" unless (device = devices[device_name])
+      raise "Device '#{device_name}' not listed in config.yml" unless (device = devices[device_name])
       {
-        :name   => device_name,
-        :udid   => device['UDID'],
-        :screen => device['screen']
+        :name        => device_name,
+        :udid        => device['UDID'],
+        :screen      => device['screen'],
+        :simulator   => device['simulator'],
+        :orientation => device['orientation'] || 'portrait'
       }
     end
 
-    def self.server(server_name)
-      @@config['servers'][server_name]
-    end
-
-    def self.url(server_name, href="")
-      server_config = server(server_name)
-      port = server_config['port'] ? ":#{server_config['port']}" : ""
+    def self.template
+      locations = [
+        `xcode-select -print-path`.gsub(/\n/, '') + "/Platforms/iPhoneOS.platform/Developer/Library/Instruments",
+         "/Applications/Xcode.app/Contents/Applications/Instruments.app/Contents" # Xcode 4.5
+      ].map do |start_path|
+        "#{start_path}/PlugIns/AutomationInstrument.bundle/Contents/Resources/Automation.tracetemplate"
+      end
 
-      "http://#{server_config['host']}#{port}#{href}"
+      locations.each { |path| return path if File.exists?(path) }
+      raise "Can't find Instruments template (tried #{locations.join(', ')})"
     end
   end
 end

data/lib/zucchini/detector.rb

@@ -1,8 +1,8 @@
 class Zucchini::Detector < Clamp::Command
   attr_reader :features
-    
+
   parameter "PATH", "a path to feature or a directory"
-  
+
   def execute
     raise "Directory #{path} does not exist" unless File.exists?(path)
 
@@ -10,14 +10,12 @@ class Zucchini::Detector < Clamp::Command
     Zucchini::Config.base_path = File.exists?("#{path}/feature.zucchini") ? File.dirname(path) : path
 
     @device = Zucchini::Config.device(ENV['ZUCCHINI_DEVICE'])
-    
-    @template = detect_template
 
     exit run_command
   end
-  
+
   def run_command; end
-  
+
   def features
     @features ||= detect_features(@path)
   end
@@ -45,16 +43,4 @@ class Zucchini::Detector < Clamp::Command
   def detection_error(path)
     "#{path} is not a feature directory"
   end
-
-  def detect_template
-    locations = [
-      `xcode-select -print-path`.gsub(/\n/, '') + "/Platforms/iPhoneOS.platform/Developer/Library/Instruments",
-       "/Applications/Xcode.app/Contents/Applications/Instruments.app/Contents" # Xcode 4.5
-    ].map do |start_path|
-      "#{start_path}/PlugIns/AutomationInstrument.bundle/Contents/Resources/Automation.tracetemplate"
-    end
-
-    locations.each { |path| return path if File.exists?(path) }
-    raise "Can't find Instruments template (tried #{locations.join(', ')})"
-  end
-end
+end

data/lib/zucchini/device.rb

@@ -0,0 +1,32 @@
+# FIXME: This needs to be refactored into a class (@vaskas).
+
+module Zucchini
+  module Device
+
+    private
+
+    def device_params(device)
+      if is_simulator?(device)
+        set_simulator_device(device)
+        ''
+      else
+        "-w #{device[:udid]}"
+      end
+    end
+
+    def set_simulator_device(device)
+      return unless device[:simulator].is_a?(String)
+
+      current_simulated_device = `defaults read com.apple.iphonesimulator "SimulateDevice"`.chomp
+      if current_simulated_device != device[:simulator]
+        simulator_pid = `ps ax|awk '/[i]Phone Simulator.app\\/Contents\\/MacOS\\/iPhone Simulator/{print $1}'`.chomp
+        Process.kill('INT', simulator_pid.to_i) unless simulator_pid.empty?
+        `defaults write com.apple.iphonesimulator "SimulateDevice" '"#{device[:simulator]}"'`
+      end
+    end
+
+    def is_simulator?(device)
+      device[:name] == 'iOS Simulator' || device[:simulator]
+    end
+  end
+end

data/lib/zucchini/feature.rb

@@ -1,7 +1,9 @@
 class Zucchini::Feature
+  include Zucchini::Compiler
+  include Zucchini::Device
+
   attr_accessor :path
   attr_accessor :device
-  attr_accessor :template
   attr_accessor :stats
 
   attr_reader :succeeded
@@ -45,32 +47,15 @@ class Zucchini::Feature
     end
   end
 
-  def compile_js
-    zucchini_base_path = File.expand_path(File.dirname(__FILE__))
-
-    feature_text = File.open("#{@path}/feature.zucchini").read.gsub(/\#.+[\z\n]?/,"").gsub(/\n/, "\\n")
-    File.open("#{run_data_path}/feature.coffee", "w+") { |f| f.write("Zucchini.run('#{feature_text}')") }
-
-    cs_paths  = "#{zucchini_base_path}/uia #{@path}/../support/screens"
-    cs_paths += " #{@path}/../support/lib" if File.exists?("#{@path}/../support/lib")
-    cs_paths += " #{run_data_path}/feature.coffee"
-
-    compile_cmd = "coffee -o #{run_data_path} -j #{run_data_path}/feature.js -c #{cs_paths}"
-    system compile_cmd
-    unless $?.exitstatus == 0
-      raise "Error compiling a feature file: #{compile_cmd}"
-    end
-  end
-
   def collect
     with_setup do
       `rm -rf #{run_data_path}/*`
-      compile_js
-
-      device_params = (@device[:name] == "iOS Simulator") ? "" : "-w #{@device[:udid]}"
 
       begin
-        out = `instruments #{device_params} -t "#{@template}" "#{Zucchini::Config.app}" -e UIASCRIPT "#{run_data_path}/feature.js" -e UIARESULTSPATH "#{run_data_path}" 2>&1`
+        out = `instruments #{device_params(@device)} \
+               -t "#{Zucchini::Config.template}" "#{Zucchini::Config.app}" \
+               -e UIASCRIPT "#{compile_js(@device[:orientation])}" \
+               -e UIARESULTSPATH "#{run_data_path}" 2>&1`
         puts out
         # Hack. Instruments don't issue error return codes when JS exceptions occur
         raise "Instruments run error" if (out.match /JavaScript error/) || (out.match /Instruments\ .{0,5}\ Error\ :/ )

data/lib/zucchini/runner.rb

@@ -11,8 +11,7 @@ class Zucchini::Runner < Zucchini::Detector
     compare_threads = {}
 
     features.each do |f|
-      f.device   = @device
-      f.template = @template
+      f.device = @device
 
       if    collect? then f.collect
       elsif compare? then f.compare

data/lib/zucchini/uia/lib/compat.coffee

@@ -0,0 +1,9 @@
+UIAElement.prototype.$ = (name) ->
+  $.debug "element.$ is deprecated. Zucchini now supports mechanic.js selectors: https://github.com/jaykz52/mechanic"
+  $('#' + name).first()
+
+waitForElement = (element) ->
+  $.debug "waitForElement is deprecated. Please use $.wait(finderFunction)"
+  $.wait(-> element)
+
+extend = $.extend

data/lib/zucchini/uia/lib/mechanic.js

@@ -0,0 +1,556 @@
+/*
+ * mechanic.js UIAutomation Library
+ * http://cozykozy.com/pages/mechanicjs
+ *
+ * version e9320027e6b5250ef72990b314238a62a1c2db0a (master build)
+ *
+ * Copyright (c) 2012 Jason Kozemczak
+ * mechanic.js may be freely distributed under the MIT license.
+ *
+ * Includes parts of Zepto.js
+ * Copyright 2010-2012, Thomas Fuchs
+ * Zepto.js may be freely distributed under the MIT license.
+ */
+
+var mechanic = (function() {
+    // Save a reference to the local target for convenience
+    var target = UIATarget.localTarget();
+
+    // Set the default timeout value to 0 to avoid making walking the object tree incredibly slow.
+    // Developers can adjust this value by calling $.timeout(duration)
+    target.setTimeout(0);
+
+    var app = target.frontMostApp(),
+        window = app.mainWindow(),
+        emptyArray = [],
+        slice = emptyArray.slice
+
+    // Setup a map of UIAElement types to their "shortcut" selectors.
+    var typeShortcuts = {
+        'UIAActionSheet' : ['actionsheet'],
+        'UIAActivityIndicator' : ['activityIndicator'],
+        'UIAAlert' : ['alert'],
+        'UIAButton' : ['button'],
+        'UIACollectionCell' : ['collectionCell'],
+        'UIACollectionView' : ['collection'],
+        'UIAEditingMenu': ['editingMenu'],
+        'UIAElement' : ['\\*'], // TODO: sort of a hack
+        'UIAImage' : ['image'],
+        'UIAKey' : ['key'],
+        'UIAKeyboard' : ['keyboard'],
+        'UIALink' : ['link'],
+        'UIAPageIndicator' : ['pageIndicator'],
+        'UIAPicker' : ['picker'],
+        'UIAPickerWheel' : ['pickerwheel'],
+        'UIAPopover' : ['popover'],
+        'UIAProgressIndicator' : ['progress'],
+        'UIAScrollView' : ['scrollview'],
+        'UIASearchBar' : ['searchbar'],
+        'UIASecureTextField' : ['secure'],
+        'UIASegmentedControl' : ['segmented'],
+        'UIASlider' : ['slider'],
+        'UIAStaticText' : ['text'],
+        'UIAStatusBar' : ['statusbar'],
+        'UIASwitch' : ['switch'],
+        'UIATabBar' : ['tabbar'],
+        'UIATableView' : ['tableview'],
+        'UIATableCell' : ['cell', 'tableCell'],
+        'UIATableGroup' : ['group'],
+        'UIATextField' : ['textfield'],
+        'UIATextView' : ['textview'],
+        'UIAToolbar' : ['toolbar'],
+        'UIAWebView' : ['webview'],
+        'UIAWindow' : ['window'],
+        'UIANavigationBar': ['navigationBar']
+    };
+
+    // Build a RegExp for picking out type selectors.
+    var typeSelectorREString = (function() {
+        var key;
+        var typeSelectorREString = "\\";
+        for (key in typeShortcuts) {
+            typeSelectorREString += key + "|";
+            typeShortcuts[key].forEach(function(shortcut) { typeSelectorREString += shortcut + "|"; });
+        }
+        return typeSelectorREString.substr(1, typeSelectorREString.length - 2);
+    })();
+
+    var patternName = "[^,\\[\\]]+"
+
+    var selectorPatterns = {
+      simple:          (new RegExp("^#("+patternName+")$"))
+     ,byType:          (new RegExp("^("+typeSelectorREString+")$"))
+     ,byAttr:          (new RegExp("^\\[(\\w+)=("+patternName+")\\]$"))
+     ,byTypeAndAttr:   (new RegExp("^("+typeSelectorREString+")\\[(\\w+)=("+patternName+")\\]$"))
+     ,children:        (new RegExp("^(.*) > (.*)$"))
+     ,descendents:     (new RegExp("^(.+) +(.+)$"))
+    }
+
+    var searches = {
+      simple:          function(name)         { return this.getElementsByName(name)          }
+     ,byType:          function(type)         { return this.getElementsByType(type)          }
+     ,byAttr:          function(attr,value)   { return this.getElementsByAttr(attr,value)    }
+     ,byTypeAndAttr:   function(type,a,v)     { return $(type, this).filter('['+a+'='+v+']') }
+     ,children:        function(parent,child) { return $(parent, this).children().filter(child) }
+     ,descendents:     function(parent,child) { return $(child, $(parent, this))             }
+    }
+
+    var filters = {
+       simple:        function(name)      { return this.name() == name                       }
+      ,byType:        function(type)      { return this.isType(type)                         }
+      ,byAttr:        function(attr,value){ return this[attr] && this[attr]() == value       }
+      ,byTypeAndAttr: function(type,a,v ) { return this.isType(type) && this[a]() == v  }
+    }
+
+
+    function Z(dom, selector){
+        dom = dom || emptyArray;
+        dom.__proto__ = Z.prototype;
+        dom.selector = selector || '';
+        if (dom === emptyArray) {
+            UIALogger.logWarning("element " + selector + " have not been found");
+        }
+        return dom;
+    }
+
+    function $(selector, context) {
+        if (!selector) return Z();
+        if (context !== undefined) return $(context).find(selector);
+        else if (selector instanceof Z) return selector;
+        else {
+            var dom;
+            if (isA(selector)) dom = compact(selector);
+            else if (selector instanceof UIAElement) dom = [selector];
+            else dom = $$(app, selector);
+            return Z(dom, selector);
+        }
+    }
+
+    $.qsa = $$ = function(element, selector) {
+        var ret = [],
+            groups = selector.split(/ *, */),
+            matches
+        $.each(groups, function() {
+          for (type in searches) {
+            if (matches = this.match(selectorPatterns[type])) {
+              matches.shift()
+              ret = ret.concat($(searches[type].apply(element, matches)))
+              break
+            }
+          }
+        })
+        return $(ret)
+    };
+
+    // Add functions to UIAElement to make object graph searching easier.
+    UIAElement.prototype.getElementsByName = function(name) {
+        return this.getElementsByAttr('name', name)
+    };
+
+    UIAElement.prototype.getElementsByAttr = function(attr, value) {
+        return $.map(this.elements().toArray(), function(el) {
+            var matches = el.getElementsByAttr(attr, value),
+                val = el[attr]
+            if (typeof val == 'function') val = val.apply(el)
+            if (typeof val != 'undefined' && val == value)
+              matches.push(el)
+            return matches
+        })
+    }
+    UIAElement.prototype.getElementsByType = function(type) {
+        return $.map(this.elements().toArray(), function(el) {
+            var matches = el.getElementsByType(type);
+            if (el.isType(type)) matches.unshift(el);
+            return matches;
+        });
+    };
+    UIAElement.prototype.isType = function(type) {
+        var thisType = this.toString().split(" ")[1];
+        thisType = thisType.substr(0, thisType.length - 1);
+        if (type === thisType) return true;
+        else if (typeShortcuts[thisType] !== undefined && typeShortcuts[thisType].indexOf(type) >= 0) return true;
+        else if (type === '*' || type === 'UIAElement') return true;
+        else return false;
+    };
+
+    function isF(value) { return ({}).toString.call(value) == "[object Function]"; }
+    function isO(value) { return value instanceof Object; }
+    function isA(value) { return value instanceof Array; }
+    function likeArray(obj) { return typeof obj.length == 'number'; }
+
+    function compact(array) { return array.filter(function(item){ return item !== undefined && item !== null; }); }
+    function flatten(array) { return array.length > 0 ? [].concat.apply([], array) : array; }
+
+    function uniq(array) { return array.filter(function(item,index,array){ return array.indexOf(item) == index; }); }
+
+    function filtered(elements, selector) {
+        return selector === undefined ? $(elements) : $(elements).filter(selector);
+    }
+
+    $.extend = function(target){
+        var key;
+        slice.call(arguments, 1).forEach(function(source) {
+            for (key in source) target[key] = source[key];
+        });
+        return target;
+    };
+
+    $.inArray = function(elem, array, i) {
+        return emptyArray.indexOf.call(array, elem, i);
+    };
+
+    $.map = function(elements, callback) {
+        var value, values = [], i, key;
+        if (likeArray(elements)) {
+            for (i = 0; i < elements.length; i++) {
+                value = callback(elements[i], i);
+                if (value != null) values.push(value);
+            }
+        } else {
+            for (key in elements) {
+                value = callback(elements[key], key);
+                if (value != null) values.push(value);
+            }
+        }
+        return flatten(values);
+    };
+
+    $.each = function(elements, callback) {
+        var i, key;
+        if (likeArray(elements)) {
+            for(i = 0; i < elements.length; i++) {
+                if(callback.call(elements[i], i, elements[i]) === false) return elements;
+            }
+        } else {
+            for(key in elements) {
+                if(callback.call(elements[key], key, elements[key]) === false) return elements;
+            }
+        }
+        return elements;
+    };
+
+    $.fn = {
+        forEach: emptyArray.forEach,
+        reduce: emptyArray.reduce,
+        push: emptyArray.push,
+        indexOf: emptyArray.indexOf,
+        concat: emptyArray.concat,
+        map: function(fn){
+            return $.map(this, function(el, i){ return fn.call(el, i, el); });
+        },
+        slice: function(){
+            return $(slice.apply(this, arguments));
+        },
+        get: function(idx){ return idx === undefined ? slice.call(this) : this[idx]; },
+        size: function(){ return this.length; },
+        each: function(callback) {
+            this.forEach(function(el, idx){ callback.call(el, idx, el); });
+            return this;
+        },
+        filter: function(selector) {
+          var matches
+          for (type in filters) {
+            if (matches = selector.match(selectorPatterns[type])) {
+              matches.shift() // remove the original string, we only want the capture groups
+              return $.map(this, function(e) {
+                return filters[type].apply(e, matches) ? e : null
+              })
+            }
+          }
+        },
+        end: function(){
+            return this.prevObject || $();
+        },
+        andSelf:function(){
+            return this.add(this.prevObject || $());
+        },
+        add:function(selector,context){
+            return $(uniq(this.concat($(selector,context))));
+        },
+        is: function(selector){
+            return this.length > 0 && $(this[0]).filter(selector).length > 0;
+        },
+        not: function(selector){
+            var nodes=[];
+            if (isF(selector) && selector.call !== undefined)
+                this.each(function(idx){
+                    if (!selector.call(this,idx)) nodes.push(this);
+                });
+            else {
+                var excludes = typeof selector == 'string' ? this.filter(selector) :
+                        (likeArray(selector) && isF(selector.item)) ? slice.call(selector) : $(selector);
+                this.forEach(function(el){
+                    if (excludes.indexOf(el) < 0) nodes.push(el);
+                });
+            }
+            return $(nodes);
+        },
+        eq: function(idx){
+            return idx === -1 ? this.slice(idx) : this.slice(idx, + idx + 1);
+        },
+        first: function(){ var el = this[0]; return el && !isO(el) ? el : $(el); },
+        last: function(){ var el = this[this.length - 1]; return el && !isO(el) ? el : $(el); },
+        find: function(selector) {
+            var result;
+            if (this.length == 1) result = $$(this[0], selector);
+            else result = this.map(function(){ return $$(this, selector); });
+            return $(result);
+        },
+        predicate: function(predicate) {
+            return this.map(function(el, idx) {
+                if (typeof predicate == 'string') return el.withPredicate(predicate);
+                else return null;
+            });
+        },
+        valueForKey: function(key, value) {
+            var result = this.map(function(idx, el) {
+                if (key in el && el[key]() == value) {
+                    return el;
+                }
+                return null;
+            });
+            return $(result);
+        },
+        valueInKey: function(key, val) {
+            var result = this.map(function(idx, el) {
+                if (key in el) {
+                    var elKey = el[key]();
+                    if (elKey === null) {
+                        return null;
+                    }
+                    // make this a case insensitive search
+                    elKey = elKey.toString().toLowerCase();
+                    val = val.toString().toLowerCase();
+
+                    if (elKey.indexOf(val) !== -1) {
+                        return el;
+                    }
+                }
+                return null;
+            });
+            return $(result);
+        },
+        closest: function(selector, context) {
+            var el = this[0], candidates = $$(context || app, selector);
+            if (!candidates.length) el = null;
+            while (el && candidates.indexOf(el) < 0)
+                el = el !== context && el !== app && el.parent();
+            return $(el);
+        },
+        ancestry: function(selector) {
+            var ancestors = [], elements = this;
+            while (elements.length > 0)
+                elements = $.map(elements, function(node){
+                    if ((node = node.parent()) && !node.isType('UIAApplication') && ancestors.indexOf(node) < 0) {
+                        ancestors.push(node);
+                        return node;
+                    }
+                });
+            return filtered(ancestors, selector);
+        },
+        parent: function(selector) {
+            return filtered(uniq(this.map(function() { return this.parent(); })), selector);
+        },
+        children: function(selector) {
+            return filtered(this.map(function(){ return slice.call(this.elements()); }), selector);
+        },
+        siblings: function(selector) {
+            return filtered(this.map(function(i, el) {
+                return slice.call(el.parent().elements()).filter(function(child){ return child!==el; });
+            }), selector);
+        },
+        next: function(selector) {
+            return filtered(this.map(function() {
+                var els = this.parent().elements().toArray();
+                return els[els.indexOf(this) + 1];
+            }), selector);
+        },
+        prev: function(selector) {
+            return filtered(this.map(function() {
+                var els = this.parent().elements().toArray();
+                return els[els.indexOf(this) - 1];
+            }), selector);
+        },
+        index: function(element) {
+            return element ? this.indexOf($(element)[0]) : this.parent().elements().toArray().indexOf(this[0]);
+        },
+        pluck: function(property) {
+            return this.map(function() {
+                if (typeof this[property] == 'function') return this[property]();
+                else return this[property];
+            });
+        }
+    };
+
+    'filter,add,not,eq,first,last,find,closest,parents,parent,children,siblings'.split(',').forEach(function(property) {
+        var fn = $.fn[property];
+        $.fn[property] = function() {
+            var ret = fn.apply(this, arguments);
+            ret.prevObject = this;
+            return ret;
+        };
+    });
+
+    Z.prototype = $.fn;
+    return $;
+})();
+
+var $ = $ || mechanic;  // expose $ shortcut
+//     mechanic.js
+//     Copyright (c) 2012 Jason Kozemczak
+//     mechanic.js may be freely distributed under the MIT license.
+
+(function($) {
+    $.extend($, {
+        log: function(s, level) {
+            level = level || 'message';
+            if (level === 'error') $.error(s);
+            else if (level === 'warn') $.warn(s);
+            else if (level === 'debug') $.debug(s);
+            else $.message(s);
+        },
+        error: function(s) { UIALogger.logError(s); },
+        warn: function(s) { UIALogger.logWarning(s); },
+        debug: function(s) { UIALogger.logDebug(s); },
+        message: function(s) { UIALogger.logMessage(s); },
+        capture: function(imageName, rect) {
+			var target = UIATarget.localTarget();
+            imageName = imageName || new Date().toString();
+            if (rect) target.captureRectWithName(rect, imageName);
+            else target.captureScreenWithName(imageName);
+        }
+    });
+
+    $.extend($.fn, {
+        log: function() { return this.each(function() { this.logElement(); }); },
+        logTree: function () { return this.each(function() { this.logElementTree(); }); },
+        capture: function(imageName) {
+            imageName = imageName || new Date().toString();
+            return this.each(function() { $.capture(imageName + '-' + this.name(), this.rect()); });
+        }
+    });
+})(mechanic);
+//     mechanic.js
+//     Copyright (c) 2012 Jason Kozemczak
+//     mechanic.js may be freely distributed under the MIT license.
+
+(function($) {
+    var app = UIATarget.localTarget().frontMostApp();
+    $.extend($.fn, {
+        name: function() { return (this.length > 0) ? this[0].name() : null; },
+        label: function() { return (this.length > 0) ? this[0].label() : null; },
+        value: function() { return (this.length > 0) ? this[0].value() : null; },
+        isFocused: function() { return (this.length > 0) ? this[0].hasKeyboardFocus() : false; },
+        isEnabled: function() { return (this.length > 0) ? this[0].isEnabled() : false; },
+        isVisible: function() { return (this.length > 0) ? this[0].isVisible() : false; },
+        isValid: function(certain) {
+            if (this.length != 1) return false;
+            else if (certain) return this[0].checkIsValid();
+            else return this[0].isValid();
+        }
+    });
+
+    $.extend($, {
+        version: function() {
+            return app.version();
+        },
+        bundleID: function()  {
+            return app.bundleID();
+        },
+        prefs: function(prefsOrKey) {
+            // TODO: should we handle no-arg version that returns all prefs???
+            if (typeof prefsOrKey == 'string') return app.preferencesValueForKey(prefsOrKey);
+            else {
+                $.each(prefsOrKey, function(key, val) {
+                    app.setPreferencesValueForKey(val, key);
+                });
+            }
+        }
+    });
+
+})(mechanic);
+//     mechanic.js
+//     Copyright (c) 2012 Jason Kozemczak
+//     mechanic.js may be freely distributed under the MIT license.
+
+(function($) {
+    var target = UIATarget.localTarget();
+    $.extend($, {
+        timeout: function(duration) { target.setTimeout(duration); },
+        delay: function(seconds) { target.delay(seconds); },
+        cmd: function(path, args, timeout) { target.host().performTaskWithPathArgumentsTimeout(path, args, timeout); },
+        orientation: function(orientation) {
+            if (orientation === undefined || orientation === null) return target.deviceOrientation();
+            else target.setDeviceOrientation(orientation);
+        },
+        location: function(coordinates, options) {
+            options = options || {};
+            target.setLocationWithOptions(coordinates, options);
+        },
+        shake: function() { target.shake(); },
+        rotate: function(options) { target.rotateWithOptions(options); },
+        pinchScreen: function(options) {
+            if (!options.style) options.style = 'open';
+            if (options.style === 'close') target.pinchCloseFromToForDuration(options.from, options.to, options.duration);
+            else target.pinchOpenFromToForDuration(options.from, options.to, options.duration);
+        },
+        drag: function(options) { target.dragFromToForDuration(options.from, options.to, options.duration); },
+        flick: function(options) { target.flickFromTo(options.from, options.to); },
+        lock: function(duration) { target.lockForDuration(duration); },
+        backgroundApp: function(duration) { target.deactivateAppForDuration(duration); },
+        volume: function(direction, duration) {
+            if (direction === 'up') {
+                if (duration) target.holdVolumeUp(duration);
+                else target.clickVolumeUp();
+            } else {
+                if (duration) target.holdVolumeDown(duration);
+                else target.clickVolumeDown();
+            }
+        },
+        input: function(s) {
+            target.frontMostApp().keyboard().typeString(s);
+        }
+    });
+
+    $.extend($.fn, {
+        tap: function(options) {
+            options = options || {};
+            return this.each(function() {
+                // TODO: tapWithOptions supports most of the behavior of doubleTap/twoFingerTap looking at the API, do we need to support these methods??
+                if (options.style === 'double') this.doubleTap();
+                else if (options.style === 'twoFinger') this.twoFingerTap();
+                else this.tapWithOptions(options);
+            });
+        },
+        touch: function(duration) {
+            return this.each(function() { this.touchAndHold(duration); });
+        },
+        dragInside: function(options) {
+            return this.each(function() { this.dragInsideWithOptions(options); });
+        },
+        flick: function(options) {
+            return this.each(function() { this.flickInsideWithOptions(options); });
+        },
+        rotate: function(options) {
+            return this.each(function() { this.rotateWithOptions(options); });
+        },
+        scrollToVisible: function() {
+            if (this.length > 0) this[0].scrollToVisible();
+            return this;
+        },
+        input: function(s) {
+            if (this.length > 0) {
+                this[0].tap();
+                $.input(s);
+            }
+        }
+    });
+
+    'delay,cmd,orientation,location,shake,pinchScreen,drag,lock,backgroundApp,volume'.split(',').forEach(function(property) {
+        var fn = $[property];
+        $.fn[property] = function() {
+            fn.apply($, arguments);
+            return this;
+        };
+    });
+})(mechanic);