ae_page_objects 0.0.1.beta.0

data/lib/ae_page_objects/core/dsl/collection.rb

@@ -0,0 +1,135 @@
+module AePageObjects
+  module Dsl
+    module Collection
+      extend ActiveSupport::Concern
+      include Dsl::Element
+    
+      module ClassMethods
+        include InternalHelpers
+        
+        # Defines a collection of elements. Blocks are evaluated on the item class used by the 
+        # collection. collection() defines a method on the class that returns an instance of a collection
+        # class which contains instances of the collection's item class.
+        #
+        # Supported signatures are described below. 
+        # 
+        # ------------------------------------------------        
+        # Signature: (:is, no :contains, no block)
+        # 
+        #     collection :addresses, :is => AddressList
+        # 
+        #   Collection class: AddressList
+        #   Item class:       AddressList.item_class
+        # 
+        # ------------------------------------------------
+        # Signature: (no :is, :contains, no block)
+        # 
+        #     collection :addresses, :contains => Address
+        # 
+        #   Collection class: one-off subclass of ::AePageObjects::Collection  
+        #   Item class:       Address
+        # 
+        # ------------------------------------------------
+        # Signature: (:is, :contains, no block)
+        # 
+        #     collection :addresses, :is => AddressList, :contains => ExtendedAddress
+        # 
+        #   Collection class: one-off subclass ofAddressList
+        #   Item class:       ExtendedAddress
+        #   
+        # ------------------------------------------------
+        # Signature: (no :is, no :contains, block)
+        # 
+        #     collection :addresses do
+        #       element :city
+        #       element :state
+        #     end
+        #   
+        #   Collection class: one-off subclass of ::AePageObjects::Collection
+        #   Item class:       one-off subclass of ::AePageObjects::Element
+        #   Methods defined on item class:
+        #     city()  # -> instance of ::AePageObjects::Element
+        #     state() # -> instance of ::AePageObjects::Element
+        # 
+        # ------------------------------------------------
+        # Signature: (:is, no :contains, block)
+        # 
+        #   collection :addresses, :is => AddressList do
+        #     element :longitude
+        #     element :latitude
+        #   end
+        # 
+        #   Collection class: one-off subclass of AddressList  
+        #   Item class:       one-off subclass of AddressList.item_class
+        #   Methods defined on item class:
+        #     longitude()  # -> instance of ::AePageObjects::Element
+        #     latitude() # -> instance of ::AePageObjects::Element
+        # 
+        # ------------------------------------------------
+        # Signature: (no :is, :contains, block)
+        # 
+        #   collection :addresses, :contains => Address do
+        #     element :longitude
+        #     element :latitude
+        #   end
+        # 
+        #   Collection class: one-off subclass of ::AePageObjects::Collection  element
+        #   Item class:       one-off subclass of Address
+        #   Methods defined on item class:
+        #     longitude()  # -> instance of ::AePageObjects::Element
+        #     latitude() # -> instance of ::AePageObjects::Element
+        # 
+        # ------------------------------------------------
+        # Signature: (:is, :contains, block)
+        # 
+        #   collection :addresses, :is => AddressList, :contains => Address do
+        #     element :longitude
+        #     element :latitude
+        #   end
+        # 
+        #   Collection class: one-off subclass of AddressList
+        #   Item class:       one-off subclass of Address
+        #   Methods defined on item class:
+        #     longitude()  # -> instance of ::AePageObjects::Element
+        #     latitude() # -> instance of ::AePageObjects::Element
+        # 
+        def collection(name, options = {}, &block)
+          options ||= {}
+          
+          # only a collection class is specified or the item class
+          # specified matches the collection's item class
+          if block.blank? && options[:is] && ( 
+              options[:contains].blank? || options[:is].item_class == options[:contains] 
+            )
+            return element(name, options)
+          end
+          
+          options = options.dup
+          
+          # create/get the collection class
+          if options[:is]
+            ensure_class_for_param!(:is, options[:is], ::AePageObjects::Collection)
+          else
+            options[:is] = ::AePageObjects::Collection
+            
+            raise ArgumentError, "Must specify either a block or a :contains option." if options[:contains].blank? && block.blank?
+          end
+          
+          item_class = options.delete(:contains) || options[:is].item_class
+          if block.present?
+            item_class = item_class.new_subclass(&block).tap do |new_item_class|
+              new_item_class.element_attributes.merge!(item_class.element_attributes)
+            end
+          end
+          
+          # since we are creating a new item class, we need to subclass the collection class
+          # so we can parameterize the collection class with an item class
+          options[:is] = options[:is].new_subclass
+          options[:is].item_class = item_class
+        
+          element(name, options)
+        end
+      end
+    end
+  end
+end

data/lib/ae_page_objects/core/dsl/element.rb

@@ -0,0 +1,45 @@
+module AePageObjects
+  module Dsl
+    module Element
+      extend ActiveSupport::Concern
+    
+      module ClassMethods
+        
+        def inherited(subclass)
+          subclass.class_eval do
+            class << self
+              def element_attributes
+                @element_attributes ||= {}
+              end
+            end
+          end
+        end
+        
+        def element(name, options = {})
+          options = options.dup
+          klass   = field_klass(options)
+          
+          self.element_attributes[name.to_sym] = klass
+        
+          define_method name do |&block|
+            ElementProxy.new(klass, self, name, options, &block)
+          end
+          
+          klass
+        end
+      
+      private
+      
+        def field_klass(options)
+          field_type = options.delete(:is)
+        
+          if field_type.is_a? Class
+            field_type
+          else
+            ::AePageObjects::Element
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ae_page_objects/core/dsl/form_for.rb

@@ -0,0 +1,30 @@
+module AePageObjects
+  module Dsl
+    module FormFor
+      extend ActiveSupport::Concern
+      include Dsl::Element
+    
+      module ClassMethods
+    
+        def form_for(form_name, options = {}, &block)
+          options ||= {}
+        
+          raise ArgumentError, ":is option not supported" if options[:is]
+          raise ArgumentError, "Block required." unless block.present?
+        
+          klass = ::AePageObjects::Form.new_subclass(&block)
+        
+          options      = options.dup
+          options[:is] = klass
+      
+          element(form_name, options)
+        
+          klass.element_attributes.each do |node_name, node_klazz|
+            delegate node_name, :to => form_name
+            self.element_attributes[node_name] = node_klazz
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ae_page_objects/core/dsl/nested_element.rb

@@ -0,0 +1,24 @@
+module AePageObjects
+  module Dsl
+    module NestedElement
+      extend ActiveSupport::Concern
+      include Dsl::Element
+    
+      module ClassMethods
+        
+        def element(name, options = {}, &block)
+          raise ArgumentError, ":is option and block not supported together" if options[:is].present? && block_given?
+          
+          if block_given?
+            klass = ::AePageObjects::HasOne.new_subclass(&block)
+            
+            options = options.dup
+            options[:is] = klass
+          end
+          
+          super(name, options)
+        end
+      end
+    end
+  end
+end

data/lib/ae_page_objects/core/internal_helpers.rb

@@ -0,0 +1,9 @@
+module AePageObjects
+  module InternalHelpers
+    def ensure_class_for_param!(param_name, klass, ancestor_class)
+      if klass && ! (klass < ancestor_class)
+        raise "#{param_name} <#{klass}> must extend #{ancestor_class}, ->#{klass.ancestors.inspect}"
+      end
+    end
+  end
+end

data/lib/ae_page_objects/core/rake_router.rb

@@ -0,0 +1,148 @@
+module AePageObjects
+  class RakeRouter
+    
+    attr_reader :routes
+    
+    def initialize(rake_routes, mounted_prefix = '')
+      @mounted_prefix = mounted_prefix || ""
+      @routes = ActiveSupport::OrderedHash.new
+      route_line_regex = /(\w+)(?:\s[A-Z]+)?\s+(\/.*)\(.:format\).*$/
+      
+      rake_routes.split("\n").each do |line|
+        line = line.strip
+        matches = route_line_regex.match(line)
+        if matches
+          @routes[matches[1].to_sym] = Route.new(matches[2], @mounted_prefix)
+        end
+      end
+    end
+    
+    def path_recognizes_url?(path, url)
+      if path.is_a?(String)
+        path.sub(/\/$/, '') == url.sub(/\/$/, '')
+      elsif path.is_a?(Symbol)
+        route = @routes[path]
+        route && route.matches?(url)
+      end
+    end
+
+    def generate_path(named_route, *args)
+      if named_route.is_a?(String)
+        return Path.new(@mounted_prefix + named_route)
+      end
+      
+      if route = @routes[named_route]
+        options = args.extract_options!
+        route.generate_path(options)
+      end
+    end
+    
+  private
+  
+    class Path < String
+      attr_reader :params, :regex
+      
+      def initialize(value)
+        super(value.gsub(/(\/)+/, '/').sub(/\(\.\:format\)$/, ''))
+        
+        @params = parse_params
+        @regex  = generate_regex
+      end
+      
+      def generate(param_values)
+        param_values = param_values.symbolize_keys
+        @params.values.inject(self) do |path, param|
+          param.substitute(path, param_values)
+        end
+      end
+
+    private
+      def parse_params
+        # overwrite the required status with the optional
+        {}.merge(required_params).merge(optional_params)
+      end
+      
+      def find_params(using_regex)
+        scan(using_regex).flatten.map(&:to_sym)
+      end
+      
+      def optional_params
+        {}.tap do |optional_params|
+          find_params(/\(\/\:(\w+)\)/).each do |param_name|
+            optional_params[param_name] = Param.new(param_name, true)
+          end
+        end
+      end
+      
+      def required_params
+        {}.tap do |required_params|
+          find_params(/\:(\w+)/).each do |param_name|
+            required_params[param_name] = Param.new(param_name, false)
+          end
+        end
+      end
+
+      def generate_regex
+        regex_spec = @params.values.inject(self) do |regex_spec, param|
+          param.replace_param_in_url(regex_spec)
+        end 
+        Regexp.new regex_spec
+      end
+    end
+    
+    class Param < Struct.new(:name, :optional)
+      include Comparable
+      
+      alias :optional? :optional
+      
+      def <=>(other)
+        name.to_s <=> other.name.to_s
+      end
+      
+      def eql?(other)
+        name == other.name
+      end
+      
+      def hash
+        name.hash
+      end
+      
+      def replace_param_in_url(url)
+        if optional?
+          url.gsub("(/:#{name})", '(\/.+)?')
+        else
+          url.gsub(":#{name}", '(.+)')
+        end
+      end
+      
+      def substitute(url, values)
+        if optional?
+          if values[name]
+            url.sub("(/:#{name})", "/#{values[name]}")
+          else
+            url.sub("(/:#{name})", '')
+          end
+        else
+          raise ArgumentError, "Missing required parameter '#{name}' for '#{url}' in #{values.inspect}" unless values.key? name
+          url.sub(":#{name}", values[name])
+        end
+      end
+    end
+  
+    class Route
+      def initialize(spec, mounted_prefix)
+        @path = Path.new(mounted_prefix + spec)
+        @path.freeze
+      end
+    
+      def matches?(url)
+        url =~ @path.regex
+      end
+
+      def generate_path(options)
+        options = options.symbolize_keys
+        @path.generate(options)
+      end
+    end
+  end
+end

data/lib/ae_page_objects/document.rb

@@ -0,0 +1,19 @@
+module AePageObjects
+  class Document < Node
+    include Concerns::Visitable
+    
+    def document
+      self
+    end
+    
+    class << self
+      private
+      def application
+        @application ||= begin
+          universe = AePageObjects::DependenciesHook.containing_page_object_universe(self)
+          "#{universe.name}::Application".constantize.instance
+        end
+      end
+    end
+  end
+end

data/lib/ae_page_objects/element.rb

@@ -0,0 +1,86 @@
+module AePageObjects
+  class Element < Node
+    attr_reader :parent, :default_name
+    
+    def initialize(parent, name, options_or_locator = {})
+      @parent       = parent
+      @default_name = name.to_s
+      @locator      = nil
+      @name         = nil
+      
+      configure(parse_options(options_or_locator))
+      
+      @locator ||= default_locator
+      
+      super(scoped_node)
+    end
+    
+    def document
+      @document ||= begin
+        node = self.parent
+        
+        until node.is_a?(::AePageObjects::Document)
+          node = node.parent
+        end
+        
+        node
+      end
+    end
+    
+    def __full_name__
+      if parent.respond_to?(:__full_name__)
+        "#{parent.__full_name__}_#{__name__}"
+      else
+        __name__
+      end
+    end
+    
+    alias_method :full_name, :__full_name__
+    
+    def __name__
+      @name || default_name
+    end
+    
+    alias_method :name, :__name__
+    
+    def to_s
+      super.tap do |str|
+        str << "#name:<#{__name__}>"
+      end
+    end
+    
+    def using_default_locator?
+      @locator == default_locator
+    end
+    
+  private
+  
+    def configure(options)
+      @locator = options.delete(:locator)
+      @name    = options.delete(:name).try(:to_s)
+    end
+  
+    def parse_options(options_or_locator)
+      if options_or_locator.is_a?( Hash )
+        options_or_locator.symbolize_keys
+      else
+        {:locator => options_or_locator}
+      end
+    end
+    
+    def default_locator
+      @default_locator ||= Proc.new { "##{__full_name__}" }
+    end
+    
+    def scoped_node
+      if @locator
+        locator = eval_locator(@locator)
+        if locator.present?
+          return parent.find(*locator)
+        end
+      end
+      
+      parent.node
+    end
+  end
+end