iCuke 0.5.5 → 0.6.0

data/lib/icuke/cucumber.rb

@@ -1,12 +1,14 @@
 require 'nokogiri'
 
+require 'icuke/sdk'
 require 'icuke/simulator'
 require 'icuke/simulate'
+require 'icuke/screen'
 
 class ICukeWorld
   include ICuke::Simulate::Gestures
   
-  attr_reader :response
+  attr_reader :response, :simulator
   
   def initialize
     @simulator = ICuke::Simulator.new
@@ -20,8 +22,8 @@ class ICukeWorld
     @simulator.quit
   end
   
-  def page
-    @xml ||= Nokogiri::XML::Document.parse(response).root
+  def screen
+    @screen ||= Screen.new(response)
   end
   
   def response
@@ -32,39 +34,13 @@ class ICukeWorld
     @simulator.record
   end
   
-  def can_see?(text, scope = '')
-    page.xpath(%Q{#{scope}//*[contains(., "#{text}") or contains(@label, "#{text}") or contains(@value, "#{text}")]}).any?
-  end
-  
-  def onscreen?(x, y)
-    return x >= 0 && y >= 0 && x < 320 && y < 480
-  end
-  
   def tap(label, options = {}, &block)
     options = {
       :pause => true
     }.merge(options)
     
-    element =
-      page.xpath(
-        %Q{//*[#{trait(:button, :updates_frequently, :keyboard_key)} and @label="#{label}" and frame]},
-        %Q{//*[#{trait(:link)} and @value="#{label}" and frame]},
-        %Q{//*[@label="#{label}" and frame]}
-      ).first
-    
-    raise %Q{No element labelled "#{label}" found in: #{page}} unless element
-    
-    # This seems brittle, revist how to fetch the frame without relying on it being the only child
-    frame = element.child
-    
-    x = frame['x'].to_f
-    y = frame['y'].to_f
-    
-    # Hit the element in the middle
-    x += (frame['width'].to_f / 2)
-    y += (frame['height'].to_f / 2)
-    
-    raise %Q{Element "#{label}" is off screen in: #{page}} unless onscreen?(x, y)
+    element = screen.first_tappable_element(label)
+    x, y = screen.element_center(element)
     
     @simulator.fire_event(Tap.new(x, y, options))
     
@@ -76,27 +52,47 @@ class ICukeWorld
   end
   
   def swipe(direction, options = {})
-    modifier = [:up, :left].include?(direction) ? -1 : 1
+    x, y, x2, y2 = screen.swipe_coordinates(direction)
+    @simulator.fire_event(Swipe.new(x, y, x2, y2, 0.015, options))
+    sleep(1)
+    refresh
+  end
+
+  def drag(source_x, source_y, dest_x, dest_y, options = {})
+    @simulator.fire_event(Drag.new(source_x, source_y, dest_x, dest_y, 0.15, options))
+    sleep(1)
+    refresh
+  end
+
+  def drag_with_source(source, destination)
+    sources = source.split(',').collect {|val| val.strip.to_i}
+    destinations = destination.split(',').collect {|val| val.strip.to_i}
+    drag(sources[0], sources[1], destinations[0], destinations[1])
+  end
+  
+  def drag_slider_to(label, direction, distance)
+    element = screen.first_slider_element(label)
+    x, y = screen.find_slider_button(element)
     
-    # Just swipe from the middle of an iPhone-dimensioned screen for now
-    x = 320 / 2
-    y = 480 / 2
-    x2 = x
-    y2 = y
+    dest_x, dest_y = x, y
+    modifier = direction_modifier(direction)
     
     if [:up, :down].include?(direction)
-      y2 = y + (y * modifier)
+      dest_y += modifier * distance
     else
-      x2 = x + (x * modifier)
+      dest_x += modifier * distance
     end
     
-    @simulator.fire_event(Swipe.new(x, y, x2, y2, options))
-    
-    sleep(1)
-    
-    refresh
+    drag(x, y, dest_x, dest_y)
   end
-  
+
+  def drag_slider_to_percentage(label, percentage)
+    element = screen.first_slider_element(label)
+    x, y = screen.find_slider_button(element)
+    dest_x, dest_y = screen.find_slider_percentage_location(element, percentage)
+    drag(x, y, dest_x, dest_y)
+  end
+
   def type(textfield, text, options = {})
     tap(textfield, :hold_for => 0.75) do |field|
       if field['value']
@@ -146,16 +142,17 @@ class ICukeWorld
   end
   
   def scroll_to(text, options = {})
+    x, y, x2, y2 = screen.swipe_coordinates(swipe_direction(options[:direction]))
     previous_response = response.dup
-    while page.xpath(%Q{//*[contains(., "#{text}") or contains(@label, "#{text}") or contains(@value, "#{text}")]}).empty? do
-      scroll(options[:direction])
-      raise %Q{Content "#{text}" not found in: #{page}} if response == previous_response
+    until screen.visible?(text) do
+      @simulator.fire_event(Swipe.new(x, y, x2, y2, 0.15, options))
+      refresh
+      raise %Q{Content "#{text}" not found in: #{screen}} if response == previous_response
     end
   end
   
   def scroll(direction)
-    swipe_directions = { :up => :down, :down => :up, :left => :right, :right => :left }
-    swipe(swipe_directions[direction])
+    swipe(swipe_direction(direction))
   end
   
   def set_application_defaults(defaults)
@@ -164,38 +161,58 @@ class ICukeWorld
   
   private
   
-  def trait(*traits)
-    "(#{traits.map { |t| %Q{contains(@traits, "#{t}")} }.join(' or ')})"
-  end
-  
   def refresh
     @response = nil
-    @xml = nil
+    @screen = nil
   end
+
+  def swipe_direction(direction)
+    swipe_directions = { :up => :down, :down => :up, :left => :right, :right => :left }
+    swipe_directions[direction]
+  end
+
+  def direction_modifier(direction)
+    [:up, :left].include?(direction) ? -1 : 1
+  end
+
 end
 
 World do
   ICukeWorld.new
 end
 
-After do
-  quit
+After do |scenario|
+  quit unless scenario.failed?
 end
 
-LIBICUKE = File.expand_path(File.dirname(__FILE__) + '/../../ext/iCuke/libicuke.dylib')
-
-Given /^(?:"([^\"]*)" from )?"([^\"]*)" is loaded in the simulator(?: using sdk (.*))?$/ do |target, project, sdk|
+Given /^(?:"([^\"]*)" from )?"([^\"]*)" is loaded in the (?:(iphone|ipad) )?simulator(?: with SDK ([0-9.]+))?$/ do |target, project, platform, sdk_version|
+  if sdk_version
+    ICuke::SDK.use(sdk_version)
+  elsif platform
+    ICuke::SDK.use_latest(platform.downcase.to_sym)
+  else
+    ICuke::SDK.use_latest
+  end
+  
   launch File.expand_path(project),
          :target => target,
-         :env => { 'DYLD_INSERT_LIBRARIES' => LIBICUKE }
+         :platform => platform,
+         :env => {
+           'DYLD_INSERT_LIBRARIES' => ICuke::SDK.dylib_fullpath
+         }
+end
+
+Given /^the module "([^\"]*)" is loaded in the simulator$/ do |path|
+  path.sub!(/#{File.basename(path)}$/, ICuke::SDK.dylib(File.basename(path)))
+  simulator.load_module(File.expand_path(path))
 end
 
 Then /^I should see "([^\"]*)"(?: within "([^\"]*)")?$/ do |text, scope|
-  raise %Q{Content "#{text}" not found in: #{page}} unless can_see?(text, scope)
+  raise %Q{Content "#{text}" not found in: #{screen.xml}} unless screen.visible?(text, scope)
 end
 
 Then /^I should not see "([^\"]*)"(?: within "([^\"]*)")?$/ do |text, scope|
-  raise %Q{Content "#{text}" was found but was not expected in: #{page}} if can_see?(text, scope)
+  raise %Q{Content "#{text}" was found but was not expected in: #{screen.xml}} if screen.visible?(text, scope)
 end
 
 When /^I tap "([^\"]*)"$/ do |label|
@@ -206,6 +223,18 @@ When /^I type "([^\"]*)" in "([^\"]*)"$/ do |text, textfield|
   type(textfield, text)
 end
 
+When /^I drag from (.*) to (.*)$/ do |source, destination|
+  drag_with_source(source, destination)
+end
+
+When /^I select the "(.*)" slider and drag (.*) pixels (down|up|left|right)$/ do |label, distance, direction|
+  drag_slider_to(label, direction.to_sym, distance.to_i)
+end
+
+When /^I move the "([^\"]*)" slider to (.*) percent$/ do |label, percent|
+  drag_slider_to_percentage(label, percent.to_i)
+end
+
 When /^I scroll (down|up|left|right)(?: to "([^\"]*)")?$/ do |direction, text|
   if text
     scroll_to(text, :direction => direction.to_sym)
@@ -219,5 +248,5 @@ Then /^I put the phone into recording mode$/ do
 end
 
 Then /^show me the screen$/ do
-  puts page.to_s
+  puts screen.xml.to_s
 end

data/lib/icuke/screen.rb

@@ -0,0 +1,110 @@
+require 'nokogiri'
+
+class Screen
+  attr_reader :xml, :x, :y, :width, :height
+  
+  def initialize(xml)
+    @xml = Nokogiri::XML::Document.parse(xml).root
+    frame = @xml.at_xpath('/screen/frame')
+    @x, @y = frame['x'].to_f, frame['y'].to_f
+    @width, @height = frame['width'].to_f, frame['height'].to_f
+  end
+  
+  def exists?(text, scope = '')
+    find_element(text, scope).any?
+  end
+  
+  def visible?(text, scope='')
+    find_element(text, scope).each do |element|
+      _x, _y = element_center(element)
+      return true if _x >= self.x && _y >= self.y && _x < self.width && _y < self.height
+    end
+    return false
+  end
+  
+  def element_center(element)
+    frame = element.at_xpath('./frame')
+    
+    x = frame['x'].to_f
+    y = frame['y'].to_f
+    
+    x += (frame['width'].to_f / 2)
+    y += (frame['height'].to_f / 2)
+    
+    return x, y
+  end
+
+  def first_tappable_element(label)
+    element =
+      @xml.xpath(
+        %Q{//*[#{trait(:button, :updates_frequently, :keyboard_key)} and @label="#{label}" and frame]},
+        %Q{//*[#{trait(:link)} and @value="#{label}" and frame]},
+        %Q{//*[@label="#{label}" and frame]}
+      ).first
+    raise %Q{No element labelled "#{label}" found in: #{@xml}} unless element
+    element
+  end
+
+  def first_slider_element(label)
+    element =
+      @xml.xpath(
+        %Q{//UISlider[@label="#{label}" and frame]},
+        %Q{//*[@label="#{label}"]/../UISlider}
+      ).first
+    raise %Q{No element labelled "#{label}" found in: #{@xml}} unless element
+    element
+  end
+
+  def find_slider_button(element)
+    percentage = 0.01 * element['value'].to_f
+    calculate_percentage_with_adjustment(element.child, percentage)
+  end
+
+  def find_slider_percentage_location(element, percentage)
+    percentage = 0.01 * percentage
+    calculate_percentage_with_adjustment(element.child, percentage)
+  end
+  
+  def center_coordinates
+    @center ||= element_center(@xml.at_xpath('/screen'))
+  end
+
+  def swipe_coordinates(direction)
+    modifier = [:up, :left].include?(direction) ? -1 : 1
+    x, y = center_coordinates
+    x2, y2 = x, y
+    if [:up, :down].include?(direction)
+      y2 = y + (y * modifier)
+    else
+      x2 = x + (x * modifier)
+    end
+    return x, y, x2, y2
+  end
+
+  private
+
+  def calculate_percentage_with_adjustment(frame, percentage, adjustment=10)
+    # need to adjust for padding around control - using 10 pixels default
+    x, y = frame['x'].to_f, frame['y'].to_f
+    width, height = frame['width'].to_f, frame['height'].to_f
+    adjustment = (percentage - 0.5) * (2*adjustment)
+    if width < height
+      x += width / 2
+      y += height * percentage - adjustment
+    else
+      x += width * percentage - adjustment
+      y += height / 2
+    end
+    return x, y
+  end
+
+  def trait(*traits)
+    "(#{traits.map { |t| %Q{contains(@traits, "#{t}")} }.join(' or ')})"
+  end
+
+  def find_element(text, scope='')
+    @xml.xpath(
+      %Q{#{scope}//*[contains(., "#{text}") or contains(@label, "#{text}") or contains(@value, "#{text}") and frame]}
+    )
+  end
+end

data/lib/icuke/sdk.rb

@@ -0,0 +1,134 @@
+module ICuke
+  module SDK
+    ICUKE_EXT_DIR = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'ext', 'iCuke'))
+    ICUKE_BIN_DIR = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'ext', 'bin'))
+    CFLAGS = '-arch i386 -pipe -ggdb -std=c99 -DTARGET_OS_IPHONE'
+    
+    def self.all
+      @all ||= begin
+        `xcodebuild -showsdks`.grep(/iphonesimulator/).map do |s|
+          s.sub(/.* iphonesimulator([0-9.]+).*/, '\1').chomp
+        end.sort
+      end
+    end
+    
+    def self.installed?(sdk)
+      all.include?(sdk)
+    end
+    
+    def self.major_versions
+      all.map { |s| s.split('.').first }.uniq
+    end
+    
+    def self.minor_versions
+      all.map { |s| s.split('.')[0 .. 1].join('.') }.uniq
+    end
+    
+    def self.latest(version = nil)
+      @latest ||= version ? all.grep(/^#{version}(?:\.|$)/).last : all.last
+    end
+    
+    def self.use(version)
+      unless installed?(version)
+        raise "The requested SDK version #{version} doesn't appear to be installed"
+      end
+      
+      @sdk = version
+    end
+    
+    def self.use_latest(major_version = nil)
+      case major_version
+      when :iphone
+        major_version = installed?('4.0') ? '4.0' : '3.1'
+      when :ipad
+        major_version = installed?('4.0') ? '4.0' : '3.2'
+      end
+      use latest(major_version)
+    end
+    
+    def self.version
+      require_sdk
+      
+      @sdk
+    end
+    
+    def self.major_version
+      require_sdk
+      
+      version.split('.')[0]
+    end
+    
+    def self.minor_version
+      require_sdk
+      
+      version.split('.')[0 .. 1].join('.')
+    end
+    
+    def self.fullname
+      require_sdk
+      
+      "iphonesimulator#{version}"
+    end
+    
+    def self.root
+      require_sdk
+      
+      "#{`xcode-select -print-path`.chomp}/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator#{version}.sdk"
+    end
+    
+    def self.home
+      require_sdk
+      
+      "#{ENV['HOME']}/Library/Application Support/iPhone Simulator/#{version}"
+    end
+    
+    def self.dylib(name = 'libicuke')
+      require_sdk
+      
+      "#{name}-sdk#{minor_version}.dylib"
+    end
+    
+    def self.dylib_fullpath(name = 'libicuke')
+      require_sdk
+      
+      File.join(ICUKE_EXT_DIR, dylib(name))
+    end
+    
+    def self.ext_dir
+      ICUKE_EXT_DIR
+    end
+    
+    def self.sdk_ext_dir
+      File.join(ext_dir, "sdk#{minor_version}")
+    end
+    
+    def self.cflags
+      "#{CFLAGS} -isysroot #{root} -F/System/Library/PrivateFrameworks -D__IPHONE_OS_VERSION_MIN_REQUIRED=#{major_version == '3.1' ? '30000' : '40000'}"
+    end
+    
+    def self.gcc
+      if major_version == '4'
+        abi_flags = "-fobjc-abi-version=2 -fobjc-legacy-dispatch"
+      end
+      "xcrun -sdk #{fullname} gcc -I. -I#{sdk_ext_dir} -I#{sdk_ext_dir}/json #{cflags} -x objective-c #{abi_flags}"
+    end
+    
+    def self.ld
+      if major_version == '4'
+        abi_flags = "-Xlinker -objc_abi_version -Xlinker 2"
+      end
+      "xcrun -sdk #{fullname} gcc -I. -I#{sdk_ext_dir} -I#{sdk_ext_dir}/json #{cflags} #{abi_flags}"
+    end
+    
+    def self.launch(application, family = :iphone, environment = {})
+      environment_args = environment.map { |k, v| %Q{-e "#{k}=#{v}"} }.join(' ')
+      %Q{#{ICUKE_BIN_DIR}/waxsim -s #{version} -f #{family} #{environment_args} "#{application}"}
+    end
+    
+    private
+    
+    def self.require_sdk
+      raise "No SDK has been selected" unless @sdk
+    end
+  end
+end

data/lib/icuke/simulate.rb

@@ -93,23 +93,24 @@ module ICuke
       end
       
       class Swipe
-        attr_accessor :x, :y, :x2, :y2, :options
+        attr_accessor :x, :y, :x2, :y2, :options, :hold_for
         
-        def initialize(x, y, x2, y2, options)
+        def initialize(x, y, x2, y2, hold_for, options)
           @options = options
           
           @x = x
           @y = y
           @x2 = x2
           @y2 = y2
+          @hold_for = hold_for
         end
         
         def to_json(*a)
-          events = [ICuke::Simulate::Events::Touch.new(:down, [[x, y]], options.merge(:hold_for => 0.015))]
+          events = [ICuke::Simulate::Events::Touch.new(:down, [[x, y]], options.merge(:hold_for => hold_for))]
           each_point([x, y], [x2, y2], 25) do |ix, iy|
-            events << ICuke::Simulate::Events::Touch.new(:moved, [[ix, iy]], :hold_for => 0.015)
+            events << ICuke::Simulate::Events::Touch.new(:moved, [[ix, iy]], :hold_for => hold_for)
           end
-          events << ICuke::Simulate::Events::Touch.new(:up, [[x2, y2]], :hold_for => 0.015)
+          events << ICuke::Simulate::Events::Touch.new(:up, [[x2, y2]], :hold_for => hold_for)
           events.to_json(*a)
         end
         
@@ -127,6 +128,9 @@ module ICuke
           end
         end
       end
+      
+      class Drag < Swipe
+      end
     end
   end
 end

data/lib/icuke/simulator.rb

@@ -1,9 +1,5 @@
 require 'icuke/core_ext'
-if ENV['ICUKE_HEADLESS']
-  require 'icuke/headless'
-else
-  require 'icuke/xcode'
-end
+require 'icuke/waxsim'
 
 require 'httparty'
 
@@ -28,28 +24,31 @@ module ICuke
     end
     
     def save(path)
-      get '/save', :query => URI.escape(path)
+      get '/save', :query => path
     end
     
     def load(path)
-      get '/load', :query => URI.escape(path)
+      get '/load', :query => path
     end
     
     def play
       get '/play'
     end
     
+    def load_module(path)
+      get '/module', :query => path
+    end
+    
     def fire_event(event)
-      get '/event', :query => URI.escape(event.to_json)
+      get '/event', :query => event.to_json
     end
     
     def set_defaults(defaults)
-      get '/defaults', :query => URI.escape(defaults.to_json)
+      get '/defaults', :query => defaults.to_json
     end
     
-    private
-    
     def get(path, options = {})
+      options[:query] = URI.escape(options[:query]) if options.has_key?(:query)
       response = self.class.get(path, options)
       if response.code != 200
         raise Simulator::Error, response.body

data/lib/icuke/waxsim.rb

@@ -0,0 +1,36 @@
+require 'background_process'
+require 'tmpdir'
+
+module ICuke
+  class Simulator
+    include Timeout
+    
+    def launch(project_file, options = {})
+      options = {
+        :configuration => 'Debug',
+        :env => {}
+      }.merge(options)
+      
+      app_name = File.basename(project_file, '.xcodeproj')
+      directory = "#{File.dirname(project_file)}/build/#{options[:configuration]}-iphonesimulator"
+      
+      options[:env]['CFFIXED_USER_HOME'] = Dir.mktmpdir
+      
+      command = ICuke::SDK.launch("#{directory}/#{app_name}.app", options[:platform], options[:env])
+      @simulator = BackgroundProcess.run(command)
+      
+      timeout(30) do
+        begin
+          view
+        rescue Errno::ECONNREFUSED
+          sleep(0.5)
+          retry
+        end
+      end
+    end
+    
+    def quit
+      @simulator.kill('QUIT')
+    end
+  end
+end

data/lib/icuke.rb

@@ -1 +1,2 @@
-require 'icuke/simulator'
+require 'icuke/sdk'
+require 'icuke/simulator'