rubium-ios 1.0.0.pre

data/lib/ui_automation/action_sheet.rb

@@ -0,0 +1,9 @@
+module UIAutomation
+  # A RemoteProxy to UIAActionSheet objects in the Javascript API.
+  #
+  # @see https://developer.apple.com/library/ios/documentation/ToolsLanguages/Reference/UIAActionSheetClassReference/
+  #
+  class ActionSheet < Element
+    include Traits::Cancellable
+  end
+end

data/lib/ui_automation/activity_view.rb

@@ -0,0 +1,9 @@
+module UIAutomation
+  # A RemoteProxy to UIAActivityView objects in the Javascript API.
+  #
+  # @see https://developer.apple.com/library/ios/documentation/ToolsLanguages/Reference/UIActivityViewClassReference/
+  #
+  class ActivityView < Element
+    include Traits::Cancellable
+  end
+end

data/lib/ui_automation/alert.rb

@@ -0,0 +1,16 @@
+module UIAutomation
+  # A RemoteProxy to UIAAlert objects in the Javascript API.
+  #
+  # @see https://developer.apple.com/library/ios/documentation/ToolsLanguages/Reference/UIAAlertSheetClassReference/
+  #
+  class Alert < Element
+    include Traits::Cancellable
+    
+    ### @!group Elements
+
+    # The alert's default button
+    has_element :defaultButton
+      
+    ### @!endgroup
+  end
+end

data/lib/ui_automation/application.rb

@@ -0,0 +1,57 @@
+module UIAutomation
+  # A RemoteProxy to UIAApplication objects in the Javascript API.
+  #
+  # @see https://developer.apple.com/library/ios/documentation/ToolsLanguages/Reference/UIAApplicationClassReference/
+  #
+  class Application < RemoteProxy
+    extend ElementDefinitions
+    
+    ### @!group Elements
+
+    # The application's main window.
+    has_element :mainWindow, type: UIAutomation::Window
+    
+    # The currently active action sheet.
+    has_element :actionSheet, type: UIAutomation::ActionSheet
+    
+    # The system keyboard.
+    has_element :keyboard, type: UIAutomation::Keyboard
+    
+    # The currently displayed alert view
+    has_element :alert, type: UIAutomation::Alert
+    
+    # The currently displayed editing menu
+    has_element :editingMenu
+    
+    # The application's tab bar.
+    #
+    # On an iPhone there will normally only be one tab bar but an iPad may have multiple.
+    has_element :tabBar, type: UIAutomation::TabBar
+    
+    # The application's navigation bar.
+    #
+    # On an iPhone there will normally only be one navigation bar but an iPad may have multiple.
+    has_element :navigationBar, type: UIAutomation::NavigationBar
+    
+    # The application's toolbar.
+    # 
+    # On an iPhone there will normally only be one toolbar but an iPad may have multiple.
+    has_element :toolbar
+    
+    # The application status bar
+    has_element :statusBar
+    
+    ### @!endgroup
+    
+    ### @!group Element Collections
+    
+    # The application's windows.
+    has_element_array :windows, type: UIAutomation::Window
+
+    ### @!endgroup
+    
+    def bundle_id
+      perform :bundleID
+    end    
+  end
+end

data/lib/ui_automation/element.rb

@@ -0,0 +1,255 @@
+module UIAutomation
+  # Represents objects of type UIAElement in the Javascript API.
+  #
+  # UIAutomation::Element acts as the base class for all element types.
+  #
+  # @see https://developer.apple.com/library/ios/documentation/ToolsLanguages/Reference/UIAElementClassReference/
+  class Element < RemoteProxy
+    extend UIAutomation::ElementDefinitions
+
+    # The proxy for the parent element
+    # @note This returns the existing proxy that created this one; it does not use the UIAElement.parent() method
+    # @return [UIAutomation::Element]
+    attr_reader :parent
+
+    # The window that contains this element
+    # @return [UIAutomation::Window]
+    attr_reader :window
+    
+    ### @!group Elements
+    
+    # The popover object associated with the current element
+    has_element :popover, type: UIAutomation::Popover
+    
+    # The activity view associated with this element
+    has_element :activityView, type: UIAutomation::ActivityView
+    
+    # The main tab bar.
+    #
+    # On an iPhone there will normally only be one tab bar but an iPad may have multiple.
+    has_element :tabBar, type: UIAutomation::TabBar
+    
+    # The main navigation bar.
+    #
+    # On an iPhone there will normally only be one navigation bar but an iPad may have multiple.
+    has_element :navigationBar, type: UIAutomation::NavigationBar
+    
+    # The main toolbar.
+    # 
+    # On an iPhone there will normally only be one toolbar but an iPad may have multiple.
+    has_element :toolbar
+    
+    # @!endgroup
+
+    ### @!group Element Collections
+
+    # The element's parents
+    has_element_array :ancestry
+
+    # The element's children
+    has_element_array :elements
+
+    # All scroll views contained by this element
+    has_element_array :scrollViews
+
+    # All web views contained by this element
+    has_element_array :webViews
+
+    # All table views contained by this element
+    has_element_array :tableViews, type: UIAutomation::TableView
+
+    # All buttons contained by this element
+    has_element_array :buttons
+
+    # All static text elements contained by this element
+    has_element_array :staticTexts
+
+    # All text fields contained by this element
+    has_element_array :textFields, type: UIAutomation::TextField
+
+    # All secure text fields contained by this element
+    has_element_array :secureTextFields, type: UIAutomation::TextField
+
+    # All search bars contained by this element
+    has_element_array :searchBars, type: UIAutomation::TextField
+
+    # All segmented controls contained by this element
+    has_element_array :segmentedControls
+
+    # All switches contained by this element
+    has_element_array :switches
+    
+    # All images contained by this element
+    has_element_array :images
+    
+    # All links contained by this element
+    has_element_array :links
+    
+    # All page indicators contained by this element
+    has_element_array :pageIndicators
+    
+    # All pickers contained by this element
+    has_element_array :pickers, type: UIAutomation::Picker
+    
+    # All progress indicators contained by this element
+    has_element_array :progressIndicators
+    
+    # All sliders contained by this element
+    has_element_array :sliders
+    
+    # All text views contained by this element
+    has_element_array :textViews, type: UIAutomation::TextView
+    
+    # All collection views contained by this element
+    has_element_array :collectionViews
+    
+    # All actvity indicators associated with this element
+    has_element_array :activityIndicators
+    
+    # The window's tab bars
+    has_element_array :tabBars, type: UIAutomation::TabBar
+    
+    # The window's navigation bars
+    has_element_array :navigationBars, type: UIAutomation::NavigationBar
+    
+    # The window's toolbars
+    has_element_array :toolbars
+
+    ### @!endgroup
+
+    # Initializes a new element.
+    # As well as the parameters of its super-class, it also takes a parent element and window proxy.
+    # @api private
+    #
+    def initialize(driver, remote_object, parent_element, window = nil)
+      super driver, remote_object
+      @parent = parent_element
+      @window = window
+    end
+
+    ### @!group Checking Element State
+
+    # Returns true if the element is valid.
+    # This uses the UIAElement method checkIsValid() to ensure that the most up-to-date status is returned.
+    # @return [Boolean]
+    #
+    def valid?
+      perform :checkIsValid
+    end
+
+    # Indicates if the element is currently visible.
+    # @return [Boolean]
+    # @see UIAElement.isVisible()
+    def visible?
+      perform(:isVisible) == 1
+    end
+
+    # Indicates if the element is currently enabled.
+    # @return [Boolean]
+    # @see UIAElement.isEnabled()
+    #
+    def enabled?
+      perform(:isEnabled) == 1
+    end
+
+    # Indicates if the element is currently selected.
+    # @return [Boolean]
+    # @see UIAElement.isSelected()
+    #
+    def selected?
+      perform(:isSelected)
+    end
+
+    # Indicates if the element has keyboard focus.
+    # @return [Boolean]
+    # @see UIAElement.hasKeyboardFocus()
+    #
+    def has_keyboard_focus?
+      perform(:hasKeyboardFocus) == 1
+    end
+    
+    # Calls the given block when the element becomes valid. If the element is already valid
+    # the block is called immediately.
+    # @yieldparam [self] element
+    #
+    def when_valid(&block)
+      when_element_is(:valid?, &block)
+    end
+
+    # Calls the given block when the element passes one ore more predicates.
+    #
+    # Each predicate method specified will be called and if they all return true, the given block will be called,
+    # otherwise it will wait for all predicates to return true.
+    #
+    # @param [List<Symbol>] predicates One or more symbols representing boolean methods defined on the current class.
+    # @yieldparam [self] element
+    # @raise [Rubium::Driver::TimeoutError] if all predicates do not return true within the default timeout.
+    #
+    # @example Tap the element once it is selected and has keyboard focus
+    #     element.when_element(:selected?, :has_keyboard_focus?) { |el| el.tap }
+    #
+    def when_element(*predicates, &block)
+      driver.wait_until do
+        predicates.all? { |p| __send__(p) }
+      end
+
+      yield self if block_given?
+
+    rescue Wrong::Assert::AssertionFailedError => e
+      raise Wrong::Assert::AssertionFailedError.new("Expect #{self} #{predicates.join(", ")}")
+    end
+    alias :when_element_is :when_element
+
+    # Repeatedly calls the given block until the element passes one ore more predicates.
+    #
+    # Each predicate method specified will be called and if they all return true, the given block will never be called,
+    # otherwise, the block will be called continuously with a small delay between each call until they do. 
+    #
+    # The predicates will be checked before each block call.
+    #
+    # @param [List<Symbol>] predicates One or more symbols representing boolean methods defined on the current class.
+    # @yieldparam [self] element
+    # @raise [Rubium::Driver::TimeoutError] if all predicates do not return true within the default timeout.
+    #
+    # @example Scroll the table view until a specific cell is visible
+    #     expected_cell = table_view.cells['Some Name']
+    #     expected_cell.until_element(:visible?) { table_view.scroll_down }
+    #
+    def until_element(*predicates, &block)
+      driver.wait_until do
+        if predicates.all? { |p| __send__(p) }
+          true
+        else
+          yield self if block_given?
+        end
+      end
+    end
+    
+    ### @!endgroup
+    
+    ### @!group Gestures and Actions
+
+    # Perform a single tap on the element.
+    # This method waits for the element to become valid and visible before performing the tap.
+    # To perform a tap immediately without waiting, use #tap!
+    # @see #tap!
+    #
+    def tap # define this explicitly due to conflict with Object#tap
+      when_element_is(:valid?, :visible?) { tap! }
+    end
+
+    # Performs a single tap on the element without waiting.
+    # Use this method when you are certain that an element is both valid and visible - calling this
+    # may result in an error if the element is not tappable.
+    #
+    def tap!
+      perform(:tap)
+    end
+
+    ### @!endgroup
+
+    def application
+      window.parent
+    end
+  end
+end

data/lib/ui_automation/element_array.rb

@@ -0,0 +1,226 @@
+module UIAutomation
+  # Represents objects of type UIAElementArray in the Javascript API.
+  #
+  # An ElementArray represents a collection of elements of a specific type within the view hierarchy.
+  #
+  # This class implements #each and includes the Enumerable mixin, enabling you to use it like any other
+  # native Ruby collection class.
+  #
+  # All methods in thie class that return a UIAutomation::Element may return a specific sub-class of 
+  # UIAutomation::Element, as determined by the #element_klass attribute.
+  #
+  # @see https://developer.apple.com/library/ios/documentation/ToolsLanguages/Reference/UIAElementArrayClassReference/
+  class ElementArray < RemoteProxy
+    include Enumerable
+
+    # The proxy for the parent element
+    # @note This returns the existing proxy that created this one; it does not use the UIAElement.parent() method
+    # @return [UIAutomation::Element]
+    attr_reader :parent
+
+    # The window that contains this element
+    # @return [UIAutomation::Window]
+    attr_reader :window
+    
+    # The element proxy class used for each element in the array.
+    # @api private
+    attr_reader :element_klass
+
+    # @api private
+    def initialize(driver, remote_object, element_klass = UIAutomation::Element, parent_element = nil, window = nil)
+      super driver, remote_object
+      @element_klass = element_klass
+      @parent = parent_element
+      @window = window
+    end
+
+    def inspect
+      "<RemoteProxy(#{self.class.name}) type:#{element_proxy_for}: #{to_javascript}>"
+    end
+    
+    ### @!group Accessing Elements    
+
+    # Returns a proxy to the element at the given index.
+    # 
+    # @param [Integer] index
+    # @return [UIAutomation::Element] the element proxy
+    #
+    def at_index(index)
+      build_proxy element_klass, remote_object.object_for_subscript(index), [parent, window]
+    end
+
+    # Returns a new ElementArray containing all elements with the given name.
+    # 
+    # @param [String] name
+    # @return [UIAutomation::ElementArray] a sub-set of the current element array
+    # @see UIAElementArray.withName()
+    #
+    def with_name(name)
+      element_array_proxy_for :withName, name
+    end
+
+    # Returns a proxy to the first element with the given name.
+    # 
+    # @param [String] name
+    # @return [UIAutomation::Element] the element proxy
+    # @see UIAElementArray.firstWithName()
+    #
+    def first_with_name(name)
+      element_proxy_for :firstWithName, name
+    end
+
+    # Returns a new ElementArray containing all elements matching the given predicate.
+    #
+    # Predicates use the Apple NSPredicate syntax.
+    #
+    # To avoid dealing with escaping and quoting of string values, you can use template substitution
+    # in your predicate string and pass in the values as a hash.
+    #
+    # @example Using predicate template substitution
+    #     array.with_predicate("name beginswith :value", :value => 'test')
+    # 
+    # @param [String] template a predicate template using NSPredicate syntax
+    # @param [Hash] substitutions an optional hash of template substitutions
+    # @return [UIAutomation::ElementArray] a sub-set of the current element array
+    # @see UIAElementArray.withPredicate()
+    # @see https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/Predicates/Articles/pSyntax.html
+    #
+    def with_predicate(template, substitutions = {})
+      element_array_proxy_for :withPredicate, UIAutomation::PredicateString.new(template, substitutions).to_s
+    end
+
+    # Returns a proxy to the first element matching the specified predicate.
+    #
+    # Predicates use the Apple NSPredicate syntax (see #with_predicate for more information).
+    #
+    # @param [String] template a predicate template using NSPredicate syntax
+    # @param [Hash] substitutions an optional hash of template substitutions
+    # @return [UIAutomation::Element] the element proxy
+    # @see #with_predicate
+    # @see UIAElementArray.firstWithPredicate()
+    #
+    def first_with_predicate(template, substitutions = {})
+      element_proxy_for :firstWithPredicate, UIAutomation::PredicateString.new(template, substitutions).to_s
+    end
+
+    # Returns a new ElementArray containing all elements with the given key/value pair.
+    # 
+    # @param [String] key 
+    # @param [Object] value
+    # @return [UIAutomation::ElementArray] a sub-set of the current element array
+    # @see UIAElementArray.withValueForKey()
+    #
+    def with_value_for_key(key, value)
+      element_array_proxy_for :withValueForKey, value, key
+    end
+
+    # Returns a new ElementArray containing all elements with the given value.
+    # 
+    # @param [Object] value
+    # @return [UIAutomation::ElementArray] a sub-set of the current element array
+    #
+    def with_value(value)
+      with_value_for_key(:value, value)
+    end
+
+    # Returns a proxy to the first element with the given value.
+    # 
+    # @param [Object] value the element value
+    # @return [UIAutomation::Element] the element proxy or nil if no elements found
+    # @see UIAElementArray.firstWithName()
+    #
+    def first_with_value(value)
+      collection = with_value(value)
+      collection.any? ? collection.first : nil
+    end
+    
+    # Returns a remote proxy to a specific element within the collection by index or name.
+    #
+    # You can use square-bracked syntax with either an Integer or String key to perform lookup
+    # by index or name respectively.
+    #
+    # Calling with an Integer is equivalent to calling #at_index. Calling with a String is
+    # equivalent to calling #first_with_name.
+    # 
+    # @param [String or Integer] index_or_name the index or name of the attribute
+    # @return [UIAutomation::Element] the matching element
+    # @see UIAElementArray.withName()
+    #
+    def [](index_or_name)
+      if index_or_name.is_a?(Integer)
+        at_index(index_or_name)
+      else
+        first_with_name(index_or_name)
+      end
+    end
+    
+    ### @!endgroup
+
+    # Returns the number of items in the array
+    # @return [Integer]
+    #
+    def length
+      fetch(:length)
+    end
+    alias :count :length
+
+    # Yields a proxy to each element in the ElementArray if a block is given.
+    #
+    # If no block is given, this method will return an Enumerator.
+    #
+    # @yieldparam [UIAutomation::Element] element if block given
+    # @return [Enumerator] if no block is given
+    #
+    def each(&block)
+      if block_given?
+        (0...length).each do |index|
+          yield self[index]
+        end
+      else
+        to_enum(:each)
+      end
+    end
+
+    private
+
+    def element_proxy_for(function_name, *function_args)
+      proxy_for(function_name,
+        function_args: function_args,
+        proxy_klass: @element_klass,
+        proxy_args: [parent, window]
+      )
+    end
+
+    def element_array_proxy_for(function_name, *function_args)
+      proxy_for(function_name,
+        function_args: function_args,
+        proxy_klass: UIAutomation::ElementArray,
+        proxy_args: [element_klass, parent, window]
+      )
+    end
+  end
+
+  # @private
+  class PredicateString
+    def initialize(template, substitutions = {})
+      @template = template
+      @substitutions = substitutions
+    end
+
+    def to_s
+      @substitutions.reduce(@template) do |string, (key, value)|
+        string.gsub(/:#{key}/, escaped(value))
+      end
+    end
+
+    private
+
+    def escaped(value)
+      if value.is_a?(String)
+        "\"#{value}\""
+      else
+        value.to_s
+      end
+    end
+  end
+end