lebowski 0.1.1 → 0.2.0

data/lib/lebowski/foundation/object_array.rb

@@ -61,21 +61,41 @@ module Lebowski
         return @prefilter.clone
       end
       
+      #
+      # Used to create a new filtered object array from this array based on this given filter. The new object
+      # array will only reference those items that match the given filter
+      #
       def filter(filter)
         merged_filter = merge_filter_with_prefilter(filter)
         return create_filtered_object_array(@parent, @array_rel_path, @array_length_property_name, merged_filter)
       end
       
+      #
+      # Returns an enumerable object of indexes for those items in the array that match the given filter
+      #
+      # This method gives you a chance to perform any processing on the given filter by overriding the
+      # find_indexes_process_filter method. Once indexes are found you can also process the index before
+      # a final result is returned by overriding the find_indexes_process_indexes method.
+      #
+      # @see #find_indexes_process_filter
+      # @see #find_indexes_process_indexes
+      #
       def find_indexes(filter=nil)
         raise ArgumentError.new "No filter was supplied" if (filter.nil? and @prefilter.empty?)
         
+        # Do some initial processing of the given filter
         if filter.nil?
+          # Filter is nil, so make it an empty hash object
           filter = {}
         elsif filter.kind_of? String
+          # Filter is just a string, therefore assume the string is an SproutCore type
           filter = { :sc_type => filter }
         elsif filter.kind_of?(Class) and filter.ancestors.member?(SCObject)
+          # Filter is an SCObject, therefore get the SC type as a string
           filter = { :sc_type => filter.represented_sc_class }
         elsif filter.kind_of?(Hash)
+          # Filter is a hash object. Just need to check if the hash contains the special
+          # key :sc_type. If so then do necessary conversions. 
           if filter.has_key? :sc_type
             type = filter[:sc_type]
             if type.kind_of?(Class) and type.ancestors.member?(SCObject)
@@ -86,30 +106,38 @@ module Lebowski
           raise ArgumentInvalidTypeError.new "filter", filter, 'class < SCObject', String, Hash
         end
         
+        # Merge the given filter with this object's prefilter
         filter = merge_filter_with_prefilter(filter)
         
+        # Give a chance for the filter to be processed before finding matching indexes
         processed_filter = find_indexes_process_filter(filter)
         raise StandardError.new "process filter can not be nil" if processed_filter.nil?
         
         if not processed_filter.empty?
+          # Filter is not empty therefore actually determine what indexes matches the filter
           sc_path = @parent.abs_path_with(@array_rel_path)
           indexes = @driver.get_sc_object_array_index_lookup(sc_path, processed_filter)
           return indexes if indexes.empty?
         else
+          # Filter is empty, so just return a range of indexes for this array
           val = unfiltered_count
           return [] if val <= 0 
           indexes = (0..(val - 1))
         end
         
+        # Now give a chance for the matching indexes to be processed before returning the
+        # final result
         processed_indexes = find_indexes_process_indexes(indexes)
         raise StandardError.new "process indexes can not be nil" if processed_indexes.nil?
         
+        # We're done. Return the final result
         return processed_indexes  
         
       end
       
       #
-      # Returns the number of child views this view has
+      # Returns the number of items in the array. If a filter is provided then the count
+      # will be for those items in the array that match the filter
       #
       def count(filter=nil, &block)
         if @prefilter.empty? and filter.nil? and (not block_given?)
@@ -126,6 +154,9 @@ module Lebowski
         return counter
       end
 
+      #
+      # Returns an item at the given index of the array
+      #
       def [](index, expected_type=nil)
         error = ArgumentError.new "index is out of bounds: #{index}" 
         
@@ -143,14 +174,24 @@ module Lebowski
         end
       end
       
+      #
+      # Returns the first item in the array
+      #
       def first(expected_type=nil)
         return self[0, expected_type]
       end
       
+      #
+      # Returns the last item in the array
+      #
       def last(expected_type=nil)
         return self[count - 1, expected_type]
       end
 
+      #
+      # Used to iterative through each item in the array. Can filter what items
+      # are iterated over by supply a filter object
+      #
       def each(filter=nil, &block)
         raise ArgumentError.new "block is required" if (not block_given?)
 
@@ -175,6 +216,13 @@ module Lebowski
       
       alias_method :each_with_index, :each
 
+      #
+      # Returns all the items matching a given filter. If the filter is nil
+      # then all the items are returns. If no mathing items are found then
+      # an empty array is returned.
+      #
+      # @return {Array} basic array containing the matching found items
+      #
       def find_all(filter=nil, &block)
         if filter.nil? and (not block_given?)
           raise ArugmentError.new "Must provide at least a filter or a block"
@@ -192,6 +240,10 @@ module Lebowski
         return collected
       end
       
+      #
+      # Returns the first item matching the given filter. If no items match 
+      # then nil is returned
+      #
       def find_first(filter, expected_type=nil)
         if filter.nil?
           raise ArgumentError.new "filter can not be nil"
@@ -202,6 +254,10 @@ module Lebowski
         return create_object(indexes[0], expected_type)
       end
       
+      #
+      # Returns the last item matching a given filter. If no items match then
+      # nil is returned.
+      #
       def find_last(filter, expected_type=nil)
         if filter.nil?
           raise ArgumentError.new "filter can not be nil"
@@ -212,34 +268,55 @@ module Lebowski
         return create_object(indexes[indexes.length - 1], expected_type)
       end
       
+      #
+      # Returns the index of the given object
+      #
       def index_of(obj)
         return -1 if (not obj.kind_of? ProxyObject)
         indexes = find_indexes({ :sc_guid => obj.sc_guid })
         return indexes.empty? ? -1 : indexes[0]
       end
       
+      #
+      # Used to determine if an object is part of this array
+      #
       def member?(obj)
         return (index_of(obj) >= 0)
       end
 
+      #
+      # Used to check if all items in the array match the given filter
+      #
       def all?(filter=nil, &block)
         return (count(filter, &block) == count)
       end
 
+      #
+      # Used to check if any items in the array match the given filter
+      #
       def any?(filter=nil, &block)
         return (count(filter, &block) > 0)
       end
       
       alias_method :some?, :any?
 
+      #
+      # Used to check if no items in the array match the given filter
+      #
       def none?(filter=nil, &block)
         return (count(filter, &block) == 0)
       end
 
+      #
+      # Used to check if only one item in the array matches the given filter
+      #
       def one?(filter=nil, &block)
         return (count(filter, &block) == 1)
       end
       
+      #
+      # Used to check if the array is empty
+      #
       def empty?()
         return (count == 0)
       end
@@ -262,10 +339,28 @@ module Lebowski
         end
       end
       
+      #
+      # Called by the find_indexes method. Used to do any processing of a given filter before
+      # it is used to find matching indexes. By default, the method just returns the given array
+      # without any processing done.
+      #
+      # @return {Hash} a filter object that has been processed.
+      #
+      # @see #find_indexes
+      #
       def find_indexes_process_filter(filter)
         return filter
       end
       
+      #
+      # Called by the find_indexes method. Used to do any processing of a given enumerable object of
+      # indexes before the final result is returned. By default, the method just returns the given
+      # indexes without any processing done.
+      #
+      # @return {Enumerable} an enumerable object of indexes 
+      #
+      # @see #find_indexes
+      #
       def find_indexes_process_indexes(indexes)
         return indexes
       end

data/lib/lebowski/foundation/proxy_factory.rb

@@ -72,6 +72,8 @@ module Lebowski
     ProxyFactory.proxy CollectionView
     ProxyFactory.proxy ListView
     ProxyFactory.proxy ListItemView
+    ProxyFactory.proxy WebView
+    ProxyFactory.proxy SelectButtonView
     
     ProxyFactory.proxy Pane
     ProxyFactory.proxy MainPane

data/lib/lebowski/foundation/proxy_object.rb

@@ -18,6 +18,7 @@ module Lebowski
       
       include Lebowski::Foundation
       include Lebowski::Foundation::Mixins::WaitActions
+      include Lebowski::Foundation::Mixins::DefinePathsSupport
       
       attr_reader :parent,   # The parent object of this object. Must derive from Lebowski::Foundation::ProxyObject
                   :rel_path, # The relative path to the remote object using SC property path notation
@@ -49,7 +50,7 @@ module Lebowski
         @rel_path = rel_path
         @driver = driver
         @guid = nil
-        @defined_paths = {}
+        @cached_proxy_objects = {}
         @defined_proxies = {}
         @name = ""
         
@@ -165,91 +166,6 @@ module Lebowski
         return "#{path}.#{rel_path}"
       end
       
-      def define(key, rel_path, expected_type=nil)
-        if (not key.kind_of?(String)) or key.empty? or (not key.match(/[\. ]/).nil?)
-          raise ArgumentError.raise "key must be a valid string"
-        end
-        
-        if (not rel_path.kind_of?(String)) or rel_path.empty?
-          raise ArgumentError.raise "rel_path must be a valid string"
-        end 
-        
-        if @defined_paths.has_key? key
-          raise ArgumentError.raise "key '#{key}' already defined as path '#{@defined_paths[key]}'"
-        end
-
-        first_path_part = rel_path_first_part(rel_path)
-        sub_path = rel_path_sub_path(rel_path, first_path_part)
-        
-        type = ""
-        err_abs_path = abs_path_with(rel_path)
-        
-        if @defined_paths.has_key? first_path_part
-          obj = @defined_paths[first_path_part]
-          type = obj.sc_type_of(sub_path)
-          err_abs_path = obj.abs_path_with(sub_path)
-        else
-          type = sc_type_of(rel_path)   
-        end
-        
-        if not (type == SC_T_OBJECT or type == SC_T_HASH)
-          err_msg = "Error trying to define key '#{key}'. "
-          err_msg << "Relative path '#{rel_path}' does not point to an object. "
-          err_msg << "Path is refencing: #{type}. Absolute path = #{err_abs_path}"
-          raise ArgumentError.new err_msg
-        end
-        
-        obj = self[rel_path, expected_type]
-        
-        @defined_paths[key] = obj
-        
-        return obj
-      end
-      
-      def defined()
-        return @defined_paths.clone if (not @defined_paths.nil?)
-        return {}
-      end
-      
-      def proxy(klass, rel_path)
-        obj = self[rel_path]
-        if not obj.kind_of?(ProxyObject)
-          raise ArgumentError.new "rel_path does not point to an object that can be proxied: #{obj} (#{obj.class})"
-        end
-        
-        if not (klass.kind_of?(Class) and klass.ancestors.member?(ProxyObject))
-          raise ArgumentInvalidTypeError.new "klass", klass, 'class < ProxyObject'
-        end
-        
-        @defined_proxies[rel_path] = obj.represent_as(klass)
-      end
-      
-      #
-      # Given a relative path, unravel it to access an object. Unraveling means to take
-      # any defined paths in the given relative path and convert the entire path back
-      # into a full relative path without definitions.
-      #
-      def unravel_relative_path(rel_path)
-        if not @defined_proxies[rel_path].nil?
-          return @defined_proxies[rel_path]
-        end
-        
-        first_path_part = rel_path_first_part(rel_path)
-        sub_path = rel_path_sub_path(rel_path, first_path_part)
-        
-        return rel_path if (not @defined_paths.has_key?(first_path_part))
-        
-        obj = @defined_paths[first_path_part]
-        return obj if sub_path.empty?
-        
-        result = obj.unravel_relative_path(sub_path)
-        
-        return "#{obj.rel_path}.#{result}" if result.kind_of?(String)
-        return result if result.kind_of?(Lebowski::Foundation::SCObject)
-        
-        raise StandardError.new "Unexpected result unreeling rel path: #{result}"
-      end
-      
       #
       # Gets the remote SproutCore GUID for this object
       #
@@ -321,6 +237,68 @@ module Lebowski
         return (type == SC_T_OBJECT or type == SC_T_HASH)
       end
       
+      # DEPRECATED
+      def proxy(klass, rel_path)
+        puts "DEPRECATED: proxy is deprecated. use define_proxy instead"
+        define_proxy(klass, rel_path)
+      end
+      
+      # DEPRECATED
+      def define(path, rel_path=nil, expected_type=nil)
+        puts "DEPRECATED: define is deprecated. use define_path instead"
+        define_path(path, rel_path, expected_type)
+      end
+      
+      #
+      # Defines a path proxy for a relative path on this proxy object. The path proxy
+      # will be loaded only when actually requested for use.
+      #
+      # @param klass The klass to use as the path proxy
+      # @param rel_path The relative path agaist this proxy object 
+      #
+      def define_proxy(klass, rel_path)
+        if (not rel_path.kind_of?(String)) or rel_path.empty?
+          raise ArgumentError.new "rel_path must be a valid string"
+        end
+        
+        if not (klass.kind_of?(Class) and klass.ancestors.member?(ProxyObject))
+          raise ArgumentInvalidTypeError.new "klass", klass, 'class < ProxyObject'
+        end
+
+        @defined_proxies[rel_path] = klass
+      end
+      
+      #
+      # Given a relative path, unravel it to access an object. Unraveling means to take
+      # any defined path in the given relative path and convert the entire path back
+      # into a full relative path without definitions.
+      #
+      def unravel_relative_path(rel_path)
+        path_parts = rel_path.split '.'
+        
+        full_rel_path = ""
+        defined_path = nil
+        counter = path_parts.length
+        
+        for path_part in path_parts do
+          path = defined_path.nil? ? path_part : "#{defined_path}.#{path_part}"
+          if path_defined? path
+            defined_path = path
+          else
+            break
+          end
+          counter = counter - 1
+        end
+        
+        full_rel_path << self.defined_path(defined_path).full_rel_path if (not defined_path.nil?)
+        if (counter > 0)
+          full_rel_path << "." if (not defined_path.nil?)
+          full_rel_path << path_parts.last(counter).join('.')
+        end
+        
+        return full_rel_path
+      end
+      
       #
       # The primary method used to access a proxied object's properties. Accessing
       # a property is done using a relative property path. The path is a chain of
@@ -401,58 +379,39 @@ module Lebowski
       # will be returned. 
       #
       def [](rel_path, expected_type=nil)
-      
-        result = unravel_relative_path(rel_path)
-        
-        if (not result.kind_of?(String))
-          if (not expected_type.nil?)
-            got_expected_type = (expected_type == :object or result.sc_kind_of?(expected_type)) 
-            if (not got_expected_type)
-              raise UnexpectedTypeError.new(abs_path_with(rel_path), expected_type, "object", result)
-            end
-          end
-          return result 
+        if (not rel_path.kind_of?(String)) or rel_path.empty?
+          raise ArgumentError.new "rel_path must be a valid string"
         end
         
-        rel_path = result
-        type = sc_type_of(rel_path)
-        
-        case type
-        when SC_T_NULL
-          return handle_type_null(rel_path, expected_type)
-        
-        when SC_T_UNDEFINED
-          return handle_type_undefined(rel_path, expected_type)
-        
-        when SC_T_ERROR
-          return handle_type_error(rel_path, expected_type)
-
-        when SC_T_STRING
-          return handle_type_string(rel_path, expected_type)
-        
-        when SC_T_NUMBER
-          return handle_type_number(rel_path, expected_type)
-        
-        when SC_T_BOOL
-          return handle_type_bool(rel_path, expected_type)
-        
-        when SC_T_ARRAY
-          return handle_type_array(rel_path, expected_type)
-        
-        when SC_T_HASH
-          return handle_type_hash(rel_path, expected_type)
+        if @cached_proxy_objects.has_key? rel_path
+          return @cached_proxy_objects[rel_path]
+        end
         
-        when SC_T_OBJECT
-          return handle_type_object(rel_path, expected_type)
+        defined_proxy = @defined_proxies.has_key?(rel_path) ? @defined_proxies[rel_path] : nil
           
-        when SC_T_CLASS
-          return handle_type_class(rel_path, expected_type)
+        path_defined = path_defined? rel_path
         
-        else
-          raise StandardError.new "Unrecognized returned type '#{type}' for path #{abs_path_with(rel_path)}"
+        if path_defined
+          path = defined_path rel_path
+          expected_type = path.expected_type if (path.has_expected_type? and expected_type.nil?)
         end
+      
+        unraveled_rel_path = unravel_relative_path rel_path
+        value = fetch_rel_path_value unraveled_rel_path, expected_type
+        
+        if value.kind_of? ProxyObject
+          value = value.represent_as(defined_proxy) if (not defined_proxy.nil?)
+          @cached_proxy_objects[rel_path] = value if (path_defined or not defined_proxy.nil?) 
+        end
+        
+        return value
       end
       
+      #
+      # Retain a reference to the original eql? method so we can still use it
+      #
+      alias_method :__eql?, :eql?
+      
       #
       # Override the == operator so that a proxy object can be compared to another
       # proxy object via their SproutCore GUIDs
@@ -509,6 +468,45 @@ module Lebowski
         return sub_path
       end
       
+      def fetch_rel_path_value(rel_path, expected_type)
+        type = sc_type_of(rel_path)
+        
+        case type
+        when SC_T_NULL
+          return handle_type_null(rel_path, expected_type)
+        
+        when SC_T_UNDEFINED
+          return handle_type_undefined(rel_path, expected_type)
+        
+        when SC_T_ERROR
+          return handle_type_error(rel_path, expected_type)
+
+        when SC_T_STRING
+          return handle_type_string(rel_path, expected_type)
+        
+        when SC_T_NUMBER
+          return handle_type_number(rel_path, expected_type)
+        
+        when SC_T_BOOL
+          return handle_type_bool(rel_path, expected_type)
+        
+        when SC_T_ARRAY
+          return handle_type_array(rel_path, expected_type)
+        
+        when SC_T_HASH
+          return handle_type_hash(rel_path, expected_type)
+        
+        when SC_T_OBJECT
+          return handle_type_object(rel_path, expected_type)
+          
+        when SC_T_CLASS
+          return handle_type_class(rel_path, expected_type)
+        
+        else
+          raise StandardError.new "Unrecognized returned type '#{type}' for path #{abs_path_with(rel_path)}"
+        end
+      end
+      
       def handle_type_null(rel_path, expected_type)
         if (not expected_type.nil?) and not (expected_type == :null)
           raise UnexpectedTypeError.new(abs_path_with(rel_path), expected_type, SC_T_NULL, :null)

data/lib/lebowski/foundation/views/select_button.rb

@@ -0,0 +1,69 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+module Lebowski
+  module Foundation
+    module Views
+      
+      #
+      # Represents a proxy to a SproutCore select button (SC.SelectButtonView)
+      #
+      class SelectButtonView < Lebowski::Foundation::Views::View
+        include Lebowski::Foundation::Util
+        
+        representing_sc_class 'SC.SelectButtonView'
+        
+        def display_menu
+          self.mouse_down if !menu_displayed?
+        end
+        
+        def hide_menu
+          menu.click_off if menu_displayed?
+        end
+
+        def menu_displayed?
+          return (not menu.nil?)
+        end
+
+        def menu
+          @menu = get_root_application_object.responding_panes.find_first(MenuPane)
+          if not @menu.nil?
+            @menu = @menu.represent_as(SelectButtonMenu) 
+            @menu.select_button = self
+          end
+          return @menu
+        end
+
+        def select_item(title)
+          display_menu
+          menu.menu_items.click title
+        end
+
+        def checkbox_enabled?
+          @checkbox_enabled = self['checkboxEnabled'] if @checkbox_enabled.nil?
+          return @checkbox_enabled
+        end
+      end
+
+      class SelectButtonMenu < Lebowski::Foundation::Panes::MenuPane
+        attr_writer :select_button
+
+        def item_checked?(title)
+          raise "The checkbox option is not enabled for this select button." if not @select_button.checkbox_enabled?
+          menu_item = nil
+          if title.kind_of? String
+            menu_item = menu_items.find_first({ :title => /^#{title}$/i })
+          elsif title.kind_of? Regexp
+            menu_item = menu_items.find_first({ :title => title })
+          else
+            raise ArgumentInvalidTypeError.new "title", title, String, Regexp
+          end
+          return menu_item['content.checkbox']
+        end
+      end
+
+    end
+  end
+end

data/lib/lebowski/foundation/views/view.rb

@@ -66,6 +66,16 @@ module Lebowski
           return @driver.get_sc_element_window_position(action_target, *action_locator_args)
         end
         
+        # @override Lebowski::Foundation::Mixins::PositionedElement#width
+        def width()
+          return frame.width
+        end
+        
+        # @override Lebowski::Foundation::Mixins::PositionedElement#height
+        def height()
+          return frame.height
+        end
+        
         # @override Lebowski::Foundation::Mixins::PositionedElement#scroll_to_visible
         def scroll_to_visible()
           @driver.sc_view_scroll_to_visible(abs_path)

data/lib/lebowski/foundation/views/web.rb

@@ -0,0 +1,26 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+module Lebowski
+  module Foundation
+    module Views
+      
+      #
+      # Represents a proxy to a SproutCore web view (SC.WebView)
+      #
+      class WebView < Lebowski::Foundation::Views::View
+        include Lebowski::Foundation::Mixins::FrameApplicationContextSupport
+        
+        representing_sc_class 'SC.WebView'
+        
+        def frame_app_context_locator()
+          return "css=##{layer_id} iframe"
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/lebowski/foundation.rb

@@ -1,3 +1,8 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
 require File.expand_path(File.dirname(__FILE__) + '/foundation/core')
 
 require File.expand_path(File.dirname(__FILE__) + '/foundation/errors/unexpected_type')
@@ -13,6 +18,8 @@ require File.expand_path(File.dirname(__FILE__) + '/foundation/mixins/inline_tex
 require File.expand_path(File.dirname(__FILE__) + '/foundation/mixins/delegate_support')
 require File.expand_path(File.dirname(__FILE__) + '/foundation/mixins/collection_item_view_support')
 require File.expand_path(File.dirname(__FILE__) + '/foundation/mixins/list_item_view_support')
+require File.expand_path(File.dirname(__FILE__) + '/foundation/mixins/frame_application_context_support')
+require File.expand_path(File.dirname(__FILE__) + '/foundation/mixins/define_paths_support')
 
 require File.expand_path(File.dirname(__FILE__) + '/foundation/proxy_object')
 require File.expand_path(File.dirname(__FILE__) + '/foundation/sc_object')
@@ -37,6 +44,7 @@ require File.expand_path(File.dirname(__FILE__) + '/foundation/views/collection'
 require File.expand_path(File.dirname(__FILE__) + '/foundation/views/list')
 require File.expand_path(File.dirname(__FILE__) + '/foundation/views/list_item')
 require File.expand_path(File.dirname(__FILE__) + '/foundation/views/grid')
+require File.expand_path(File.dirname(__FILE__) + '/foundation/views/web')
 
 require File.expand_path(File.dirname(__FILE__) + '/foundation/panes/pane')
 require File.expand_path(File.dirname(__FILE__) + '/foundation/panes/main')
@@ -48,5 +56,7 @@ require File.expand_path(File.dirname(__FILE__) + '/foundation/panes/picker')
 require File.expand_path(File.dirname(__FILE__) + '/foundation/panes/sheet')
 require File.expand_path(File.dirname(__FILE__) + '/foundation/panes/menu')
 
+require File.expand_path(File.dirname(__FILE__) + '/foundation/views/select_button')
+
 require File.expand_path(File.dirname(__FILE__) + '/foundation/application')
 require File.expand_path(File.dirname(__FILE__) + '/foundation/proxy_factory')