capybarista 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5d190cddc7761afa7b8b64d03980227c46051ddc
+  data.tar.gz: 58e660f9a37c9254f24dce17eb91aab10f0cd79e
+SHA512:
+  metadata.gz: 21e7f7a7399b56dbef611917f9e7d0b16fc3d0df53cbf357ac166353c4cd157282bf8c5ee839efcfd7bdb4283b83be6c12fc637b8b90db1c6a82d120a57c3ae4
+  data.tar.gz: a50372ff46a47aeb66f3e73ddfe84e6c79b2e350429eec58baa0e94ace4320c2042a7af9ded6ac3d2960544b5d57cd13f9fe6d8b849fc4a02381308976cc9ee1

data/lib/capybarista.rb

@@ -0,0 +1,111 @@
+
+require 'capybarista/extensions'
+
+module Capybarista
+
+  module Finders
+
+    def all(*args)
+      basis.all(*args).map{|f| Capybarista::Element.for(f) }
+    end
+
+    def find(*args)
+      Capybarista::Element.for basis.find(*args)
+    end
+
+    def find_button(*args)
+      Capybarista::Element.for basis.find_button(*args)
+    end
+
+    def find_by_id(*args)
+      Capybarista::Element.for basis.find_by_id(*args)
+    end
+
+    def find_field(*args)
+      Capybarista::Element.for basis.find_field(*args)
+    end
+
+    def find_link(*args)
+      Capybarista::Element.for basis.find_link(*args)
+    end
+
+    def first(*args)
+      Capybarista::Element.for basis.first(*args)
+    end
+
+  end
+
+
+
+  class Session
+    include Capybarista::Finders
+    include Capybarista::Extensions::Session
+
+    attr_reader :basis
+
+    def initialize(capybara_session)
+      @basis = capybara_session
+    end
+
+    def self.for(input)
+      if input.is_a? Capybarista::Session
+        return input
+      else
+        return Capybarista::Session.new input
+      end
+    end
+
+
+    def within(input, *args, &block)
+      input = Capybarista::Element.unwrap(input)
+      @basis.within(input, *args, &block)
+    end
+
+
+
+    def method_missing(name, *args, &block)
+      @basis.public_send(name, *args, &block)
+    end
+
+  end
+
+
+
+  class Element
+    include Capybarista::Finders
+    include Capybarista::Extensions::Element
+
+    attr_reader :basis, :session
+
+    def initialize(element, session)
+      @basis   = element
+      @session = session
+    end
+
+    def self.for(input, session = nil)
+      if input.is_a? Capybarista::Element
+        return input
+      else
+        session ||= Capybarista::Session.new(input.session)
+        return Capybarista::Element.new input
+      end
+    end
+
+
+    def self.unwrap(input)
+      while input.is_a? Capybarista::Element
+        input = input.basis
+      end
+      input
+    end
+
+
+
+    def method_missing(name, *args, &block)
+      @basis.public_send(name, *args, &block)
+    end
+
+  end
+
+
+end

data/lib/capybarista/extensions.rb

@@ -0,0 +1,197 @@
+
+require 'capybara'
+
+require 'capybarista/queries'
+require 'capybarista/unique_xpath'
+require 'capybarista/javascript'
+
+require 'logbert'
+
+module Capybarista
+
+  module Extensions
+    LOG = Logbert[self]
+
+    J = Capybarista::Javascript
+
+    def self.applied?
+      @applied
+    end
+
+    def self.apply!
+
+      if applied?
+        LOG.debug "Capybarista extensions have already been applied"
+      else
+        Capybara::Session.class_eval do
+          include Capybarista::Extensions::Session
+        end
+
+        Capybara::Node::Element.class_eval do
+          include Capybarista::Extensions::Element
+        end
+
+        @applied = true
+        LOG.warning "Capybara::Session and Capybara::Node::Element have been monkey-patched w/ the Capybarista extensions"
+      end
+
+    end
+
+
+    module Base
+
+      # Returns the list of fields that require user input.
+      def all_fields(options = {})
+        all(:xpath, Capybarista::Queries::XPath.all_fields, options)
+      end
+
+    end
+
+
+    module Session
+      include Base
+
+      #this method returns a list of labels that are sorted from bottom up, right to left
+      def new_label_list
+        fields = all_fields(visible:true).map{|f| {f: f, pos: f.top_left}  }
+        list_of_lists = fields.map{ |i| i[:pos] }
+        sorted_list = list_of_lists.sort {|item1, item2| item2[1]<=>item1[1]}
+        labels_list = Array.new
+        sorted_list.each do |item|
+          label = fields.find { |h| h[:pos] == item }[:f]
+          labels_list.push(label)    
+        end
+        labels_list
+      end
+    end
+
+
+    module Element
+      include Base
+
+      # Syntactic sugar.  Yum!
+      def scoped
+        s = session
+        s.within(self){ yield s }
+      end
+
+      # Returns a map containing only the specified attributes.
+      # If the element does not contain an attribute, then its
+      # key/value pairing will be omitted.
+      #
+      # FIXME: This methods filters attributes that are equal
+      #        to the empty string :-(
+      def filtered_attributes(*keys)
+        retval = {}
+
+        keys.each do |k|
+          value = self[k]
+          if value and not value.empty?
+            retval[k] = value
+          end
+        end
+
+        return retval
+      end
+
+      # Returns 0 or more labels for the current element
+      def labels
+        ids = filtered_attributes(:id, :name).values
+
+        if ids.any?
+          query = Capybarista::Queries::XPath.labels_for(*ids)
+          return session.all(:xpath, query)
+        else
+          return []
+        end
+      end
+
+
+      # Attempts to find the label for the current element.
+      # If no label exists, then raise Capybara::ElementNotFound
+      def label!
+        ids = filtered_attributes(:id, :name).values
+
+        if ids.any?
+          query = Capybarista::Queries::XPath.labels_for(*ids)
+          return session.find(:xpath, query)
+        else
+          raise Capybara::ElementNotFound, "The element has no labels"
+        end
+      end
+
+
+      # Attempts to find the label for the current element.
+      # If no label exists, then return nil.
+      def label
+        ids = filtered_attributes(:id, :name).values
+        if ids.any?
+          query = Capybarista::Queries::XPath.labels_for(*ids)
+          return session.first(:xpath, query)
+        else
+          return nil
+        end
+      end
+
+      def top_left
+        long_function = %Q{
+          (
+            function(){
+              var obj = document.evaluate("#{unique_xpath}", document, null, XPathResult.ANY_TYPE, null ).iterateNext(); 
+                if(obj) { 
+                
+                  var curleft = 0; var curtop = 0;
+                  if (obj && obj.offsetParent) {
+                    do {
+                        curleft += obj.offsetLeft;
+                        curtop += obj.offsetTop;
+                    } while (obj = obj.offsetParent);
+                  }
+                  return [curleft,curtop];
+                };
+            }()
+          );
+       }
+        long_string = long_function.delete("\n")
+        session.evaluate_script(long_string)
+      end
+
+
+
+      def unique_xpath
+        Capybarista::UniqueXPath.for(self)
+      end
+
+      def inner_html
+        session.evaluate_script %Q{(function(){ var result = #{ J.find_xpath(unique_xpath) }; if(result) { return result.innerHTML; } }()); }
+      end
+
+
+      def outer_html
+        session.evaluate_script %Q{(function(){ var result = #{ J.find_xpath(unique_xpath) }; if(result) { return result.outerHTML; } }()); }
+      end
+
+
+      def highlight
+        session.execute_script %Q{(function(){ var result = #{ J.find_xpath(unique_xpath) }; if(result) { var old_color = result.style.backgroundColor; result.style.backgroundColor = "yellow"; setTimeout(function(){ result.style.backgroundColor = old_color; }, 1000); } }()); }
+      end
+
+
+      def blur
+        script = %Q{ (function() { var target = #{ J.find_xpath(unique_xpath) }; if(target) { var evt = document.createEvent("MouseEvents"); evt.initMouseEvent("blur", true, true,window, 1, 1, 1, 1, 1, false, false, false, false, 0, target); target.dispatchEvent(evt); } })(); }
+        session.execute_script(script)
+      end
+
+
+      def focus
+        script = %Q{ (function() { var target = #{ J.find_xpath(unique_xpath) }; if(target) { var evt = document.createEvent("MouseEvents"); evt.initMouseEvent("focus", true, true,window, 1, 1, 1, 1, 1, false, false, false, false, 0, target); target.dispatchEvent(evt); } })(); }
+        session.execute_script(script)
+      end
+
+
+    end
+
+
+  end
+
+end

data/lib/capybarista/javascript.rb

@@ -0,0 +1,19 @@
+
+
+module Capybarista
+  module Javascript
+
+    # Generates a fragment of Javascript that will evaluate the
+    # specified XPath query.
+    def find_xpath(query)
+      %Q{document.evaluate("#{query}", document, null, XPathResult.ANY_TYPE, null ).iterateNext()}
+    end
+
+    module_function :find_xpath
+
+
+
+
+  end
+end
+

data/lib/capybarista/queries.rb

@@ -0,0 +1,35 @@
+
+require 'xpath'
+
+module Capybarista
+
+  # This module contains a number of functions
+  # for generating XPath and CSS queries
+  module Queries
+
+    module XPath
+
+
+      def self.string(value)
+        # The underlying API changes betw/ versions
+        # 0.1.4 and 2.0.0 .  So, let's wrap the method.
+        ::XPath::Expression::StringLiteral.new(value.to_s).to_xpath
+      end
+
+
+      # Queries returns all fields that accept user input
+      def self.all_fields
+        ".//*[self::input | self::textarea | self::select][not(./@type = 'submit' or ./@type = 'image' or ./@type = 'hidden' or ./@type='button')]"
+      end
+
+      def self.labels_for(*ids)
+        condition = ids.map{|id| "@for=#{string(id)}" }.join(" or ")
+        "//label[#{condition}]"
+      end
+
+    end
+
+  end
+
+end
+

data/lib/capybarista/unique_xpath.rb

@@ -0,0 +1,46 @@
+
+module Capybarista
+
+  module UniqueXPath
+
+    class UniquenessError < StandardError
+    end
+
+    def self.for(element)
+      session   = element.session
+
+      fragments = []
+      loop do
+        fragments.unshift fragment(element)
+
+        query = "//" + fragments.join("/")
+
+        occurrences = session.all(:xpath, query).count
+        if occurrences == 1
+          return query
+        elsif occurrences == 0
+          raise UniquenessError, "Failed to produce a unique xpath for the element"
+        end
+
+        element = element.find(:xpath, "..")
+      end
+    end
+
+
+    def self.fragment(element)
+      tag = element.tag_name
+      id  = element[:id]
+
+      if id.nil? or id.empty?
+        index = element.all(:xpath, "preceding-sibling::#{ tag }").count + 1
+        "#{tag}[#{index}]"
+      else
+        "#{tag}[@id='#{id}']"
+      end
+    end
+
+
+  end
+
+end
+

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: capybarista
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Brian Lauber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: xpath
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+- !ruby/object:Gem::Dependency
+  name: logbert
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+description: Useful extensions for Capybara
+email: blauber@jibe.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/capybarista/extensions.rb
+- lib/capybarista/javascript.rb
+- lib/capybarista/queries.rb
+- lib/capybarista/unique_xpath.rb
+- lib/capybarista.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Useful extensions for Capybara
+test_files: []