ae_page_objects 0.0.1.beta.0

data/lib/ae_page_objects.rb

@@ -0,0 +1,57 @@
+require 'capybara'
+require 'capybara/dsl'
+require 'active_support'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/class'
+require 'active_support/dependencies'
+
+require 'ae_page_objects/version'
+
+module AePageObjects
+  autoload :ConstantResolver,     'ae_page_objects/core/constant_resolver'
+  autoload :DependenciesHook,     'ae_page_objects/core/dependencies_hook'
+  autoload :Installable,          'ae_page_objects/core/installable'
+  autoload :Configuration,        'ae_page_objects/core/configuration'
+  autoload :Configurable,         'ae_page_objects/core/configurable'
+  autoload :Application,          'ae_page_objects/core/application'
+  autoload :ApplicationRouter,    'ae_page_objects/core/application_router'
+  autoload :RakeRouter,           'ae_page_objects/core/rake_router'
+  autoload :InternalHelpers,      'ae_page_objects/core/internal_helpers'
+  
+  module Dsl
+    autoload :Element,            'ae_page_objects/core/dsl/element'
+    autoload :NestedElement,      'ae_page_objects/core/dsl/nested_element'
+    autoload :Collection,         'ae_page_objects/core/dsl/collection'
+    autoload :FormFor,            'ae_page_objects/core/dsl/form_for'
+  end
+  
+  module Concerns
+    autoload :LoadEnsuring,     'ae_page_objects/concerns/load_ensuring'
+    autoload :Staleable,        'ae_page_objects/concerns/staleable'
+    autoload :Visitable,        'ae_page_objects/concerns/visitable'
+  end
+  
+  autoload :Node,              'ae_page_objects/node'
+  autoload :Document,          'ae_page_objects/document'
+  autoload :Element,           'ae_page_objects/element'
+  autoload :ElementProxy,      'ae_page_objects/element_proxy'
+  
+  autoload :HasOne,            'ae_page_objects/elements/has_one'
+  autoload :Collection,        'ae_page_objects/elements/collection'
+  autoload :Form,              'ae_page_objects/elements/form'
+  autoload :Select,            'ae_page_objects/elements/select'
+  autoload :Checkbox,          'ae_page_objects/elements/checkbox'  
+end
+
+ActiveSupport::Dependencies.extend AePageObjects::DependenciesHook
+
+
+
+
+
+
+
+
+

data/lib/ae_page_objects/concerns/load_ensuring.rb

@@ -0,0 +1,30 @@
+module AePageObjects
+  class LoadingFailed < StandardError
+  end
+  
+  module Concerns
+    module LoadEnsuring
+      extend ActiveSupport::Concern
+    
+      def initialize(*args)
+        super
+        ensure_loaded!
+      end
+  
+    private
+
+      def loaded_locator
+      end
+    
+      def ensure_loaded!
+        if locator = loaded_locator
+          find(*eval_locator(locator)) 
+        end
+      
+        self
+      rescue Capybara::ElementNotFound => e
+        raise LoadingFailed, e.message 
+      end
+    end
+  end
+end

data/lib/ae_page_objects/concerns/staleable.rb

@@ -0,0 +1,29 @@
+module AePageObjects
+  class StalePageObject < StandardError
+  end
+
+  module Concerns  
+    module Staleable
+      extend ActiveSupport::Concern
+  
+      def stale?
+        @stale
+      end
+
+      def node
+        if stale?
+          raise StalePageObject, "Can't access stale page object '#{self}'"
+        end
+
+        super
+      end
+      
+      private
+  
+      def stale!
+        @stale = true
+      end
+  
+    end
+  end
+end

data/lib/ae_page_objects/concerns/visitable.rb

@@ -0,0 +1,61 @@
+module AePageObjects
+  class PathNotResolvable < StandardError
+  end
+  
+  module Concerns
+    module Visitable
+      extend ActiveSupport::Concern
+    
+    private
+    
+      def ensure_loaded!
+        unless self.class.can_load_from_current_url?
+          raise LoadingFailed, "#{self.class.name} cannot be loaded with url '#{current_url_without_params}'"
+        end
+      
+        super
+      end
+    
+      module VisitMethod
+        def visit(*args)
+          raise ArgumentError, "Cannot pass block to visit()" if block_given?
+
+          full_path = application.generate_path(paths.first, *args)
+          raise PathNotResolvable, "#{self.name} not visitable via #{paths.first}(#{args.inspect})" unless full_path
+
+          Capybara.current_session.visit(full_path)
+          new
+        end
+      end
+    
+      module ClassMethods
+      
+        def can_load_from_current_url?
+          return true if paths.empty?
+        
+          Capybara.current_session.wait_until do
+            url = current_url_without_params
+        
+            paths.any? do |path|
+              application.path_recognizes_url?(path, url)
+            end
+          end
+        end
+      
+      private
+          
+        def paths
+          @paths ||= []
+        end
+      
+        def path(path_method)
+          raise ArgumentError, "path must be a symbol or string" if ! path_method.is_a?(Symbol) && ! path_method.is_a?(String)
+
+          paths << path_method
+        
+          extend VisitMethod
+        end
+      end
+    end
+  end
+end

data/lib/ae_page_objects/core/application.rb

@@ -0,0 +1,85 @@
+require "active_support/dependencies"
+
+module AePageObjects
+  class Application
+    include Configurable
+      
+    class << self
+      attr_accessor :called_from
+      private :new
+
+      def inherited(base)
+        super
+        
+        base.called_from = begin
+          call_stack = caller.map { |p| p.sub(/:\d+.*/, '') }
+          File.dirname(call_stack.detect { |p| p !~ %r[railties[\w.-]*/lib/rails|rack[\w.-]*/lib/rack] })
+        end
+        
+        base.parent.send(:include, ConstantResolver)
+      end
+      
+      def initialize!
+        instance.initialize!
+      end
+    end
+    
+    def initialize
+      set_autoload_paths
+    end
+
+    def config
+      @config ||= Configuration.new(self, find_root_with_flag("config.ru", Dir.pwd))
+    end
+
+    def initialize!
+      eager_load!
+    end
+    
+    delegate :path_recognizes_url?, :to => :router
+    delegate :generate_path, :to => :router
+    
+    def all_autoload_paths
+      @all_autoload_paths ||= (config.autoload_paths + config.eager_load_paths).uniq
+    end
+    
+  private
+  
+    def router
+      @router ||= config.router
+    end
+    
+    def set_autoload_paths
+      ActiveSupport::Dependencies.autoload_paths.unshift(*all_autoload_paths)
+
+      # Freeze so future modifications will fail rather than do nothing mysteriously
+      config.autoload_paths.freeze
+      config.eager_load_paths.freeze
+    end
+
+    def eager_load!
+      config.eager_load_paths.each do |load_path|
+        matcher = /\A#{Regexp.escape(load_path)}\/(.*)\.rb\Z/
+
+        Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
+          dependency_name = file.sub(matcher, '\1')
+          require_dependency dependency_name
+        end
+      end
+    end
+
+    def find_root_with_flag(flag, default=nil)
+      root_path = self.class.called_from
+
+      while root_path && File.directory?(root_path) && !File.exist?("#{root_path}/#{flag}")
+        parent = File.dirname(root_path)
+        root_path = parent != root_path && parent
+      end
+
+      root = File.exist?("#{root_path}/#{flag}") ? root_path : default
+      raise "Could not find root path for #{self}" unless root
+      
+      Pathname.new(root).realpath
+    end
+  end
+end

data/lib/ae_page_objects/core/application_router.rb

@@ -0,0 +1,60 @@
+module AePageObjects
+  class ApplicationRouter
+    def path_recognizes_url?(path, url)
+      if path.is_a?(String)
+        path.sub(/\/$/, '') == url.sub(/\/$/, '')
+      elsif path.is_a?(Symbol)
+        url, router = url_and_router(url)
+
+        ["GET", "PUT", "POST", "DELETE", "PATCH"].each do |method|
+          router.recognize(request_for(url, method)) do |route, matches, params|
+            return true if route.name.to_s == path.to_s
+          end
+        end
+      end
+    end
+
+    def generate_path(named_route, *args)
+      return named_route if named_route.is_a?(String)
+
+      if routes.respond_to?("#{named_route}_path")
+        routes.send("#{named_route}_path", *args)
+      end
+    end
+
+  private
+  
+    def request_for(url, method)
+      Rails.application.routes.request_class.new(env_for(url, method))
+    end
+  
+    def env_for(url, method)
+      begin
+        Rack::MockRequest.env_for(url, {:method => method})
+      rescue URI::InvalidURIError => e
+        raise ActionController::RoutingError, e.message
+      end
+    end
+  
+    def url_and_router(url)
+      if Rails.version =~ /^3.[01]/ 
+        url = Rack::Mount::Utils.normalize_path(url) unless url =~ %r{://}
+        router = Rails.application.routes.set
+      else
+        url = Journey::Router::Utils.normalize_path(url) unless url =~ %r{://}
+        router = Rails.application.routes.router
+      end
+      
+      [url, router]
+    end
+
+    def routes
+      @routes ||= begin
+        routes_class = Class.new do
+          include Rails.application.routes.url_helpers
+        end
+        routes_class.new
+      end
+    end
+  end
+end

data/lib/ae_page_objects/core/configurable.rb

@@ -0,0 +1,27 @@
+module AePageObjects
+  module Configurable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      delegate :config, :to => :instance
+
+      def instance
+        @instance ||= new
+      end
+      
+      def respond_to?(*args)
+        super || instance.respond_to?(*args)
+      end
+
+      def configure(&block)
+        class_eval(&block)
+      end
+
+    protected
+
+      def method_missing(*args, &block)
+        instance.send(*args, &block)
+      end
+    end
+  end
+end

data/lib/ae_page_objects/core/configuration.rb

@@ -0,0 +1,33 @@
+require 'rails/paths'
+
+module AePageObjects
+  class Configuration
+    attr_writer :router
+    
+    def initialize(application, root)
+      @application = application
+      @root        = root
+    end
+
+    def paths
+      @paths ||= begin
+        paths = Rails::Paths::Root.new(@root)
+        paths.add "test/page_objects", :eager_load => true
+        paths
+      end
+    end
+    
+    def eager_load_paths
+      @eager_load_paths ||= paths.eager_load
+    end
+    
+    def autoload_paths
+      @autoload_paths ||= paths.autoload_paths
+    end
+    
+    def router
+      @router ||= ApplicationRouter.new
+    end
+  end
+end
+

data/lib/ae_page_objects/core/constant_resolver.rb

@@ -0,0 +1,33 @@
+module AePageObjects
+  module ConstantResolver
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      def const_name_for(from_mod, const_name)
+        name_within_universe = ""
+        if self != from_mod
+          name_within_universe = from_mod.name.split("#{self.name}::")[1]
+        end
+
+        name_within_universe += "::#{const_name}"
+      end
+      
+      def load_missing_constant(from_mod, const_name)
+        path_for_constant = self.const_name_for(from_mod, const_name).underscore
+
+        application = "#{self.name}::Application".constantize
+        application.all_autoload_paths.each do |autoload_path|
+          file_path = File.join(autoload_path, "#{path_for_constant}.rb").sub(/(\.rb)?$/, ".rb")
+          
+          if File.file?(file_path) && ! ActiveSupport::Dependencies.loaded.include?(File.expand_path(file_path))
+            ActiveSupport::Dependencies.require_or_load file_path
+            raise LoadError, "Expected #{file_path} to define #{qualified_name}" unless ActiveSupport::Dependencies.local_const_defined?(from_mod, const_name)
+            return from_mod.const_get(const_name)
+          end
+        end
+        
+        nil
+      end
+    end
+  end
+end

data/lib/ae_page_objects/core/dependencies_hook.rb

@@ -0,0 +1,21 @@
+module AePageObjects
+  module DependenciesHook
+    
+    def self.containing_page_object_universe(from_mod)
+      until from_mod == Object
+        if from_mod < AePageObjects::ConstantResolver
+          return from_mod
+        end
+        
+        from_mod = from_mod.parent
+      end
+      
+      nil
+    end
+
+    def load_missing_constant(from_mod, const_name)
+      page_objects = DependenciesHook.containing_page_object_universe(from_mod)
+      page_objects && page_objects.load_missing_constant(from_mod, const_name) || super
+    end
+  end
+end