ferrum 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5cb7e946aa6600d6ee5beb78a3d00d77d4a4ebc58cf7b72951327dede08d4803
-  data.tar.gz: 3e5755f718fb2faede6e8fb675fa69d5c1ea2d7934205d0a56bb445c8b9d0a42
+  metadata.gz: 858608216b6e3a287e7d47621bf9c44415ea2e5411cdc53e34c2e18c3fbd8153
+  data.tar.gz: 74d290a312092c690b77ef6afac4ae65839417559749188da22e34b655789dc5
 SHA512:
-  metadata.gz: 4a2536b9335c8784c2d4f315262e38735e3567560912f9cbedd725619e65417f90b84a0b00e0b8391f4afae225ff04d09159e8062c07d3622200839abadd499a
-  data.tar.gz: 9ca06d5a73e1bd4bfa11e8cbca9def9b800e0740ce5cf8037b49907b845a88fddbb5c30296fccd3f5aba5c12d8c31e85559c1e1bd839ad74c6e6c8cd0cbc7e6f
+  metadata.gz: fe68b7a02885080677a38cc347f7bf79ed094ed09dcd7f111aee613b345e3a6bfdaf1b744b266e3b1de11770bcc37f4cb5408a499b1ad4640e370e3cd0887f49
+  data.tar.gz: 721e01402142f201cf21aa3e91d9ac21e698a277dc276b32a72c93e044abe9c81c7707e4606ec82780b89214e4108bbd0730d4d47a9509510186aa4b856e8ebf

data/README.md

@@ -1,4 +1,4 @@
-# Ferrum - fearless Ruby Chrome/Chromium driver.
+# Ferrum - fearless Ruby Chrome/Chromium driver
 
 As simple as Puppeteer, though even simpler. It is Ruby clean and high-level API
 to Chrome/Chromium through the DevTools Protocol. Runs headless by default,
@@ -19,8 +19,7 @@ Interact with a page:
 browser = Ferrum::Browser.new
 browser.goto("https://google.com")
 input = browser.at_css("input[title='Search']")
-input.send_keys("Ruby headless driver for Capybara")
-input.send_keys(:Enter)
+input.send_keys("Ruby headless driver for Capybara", :Enter)
 browser.at_css("a > h3").text # => "machinio/cuprite: Headless Chrome driver for Capybara - GitHub"
 browser.quit
 ```

data/lib/ferrum/node.rb

@@ -2,15 +2,15 @@
 
 module Ferrum
   class Node
-    attr_reader :page, :target_id, :node_id, :desc
+    attr_reader :page, :target_id, :node_id, :description
 
-    def initialize(page, target_id, node_id, desc)
-      @page, @target_id, @node_id, @desc =
-        page, target_id, node_id, desc
+    def initialize(page, target_id, node_id, description)
+      @page, @target_id, @node_id, @description =
+        page, target_id, node_id, description
     end
 
     def node?
-      desc["nodeType"] == 1 # nodeType: 3, nodeName: "#text" e.g.
+      description["nodeType"] == 1 # nodeType: 3, nodeName: "#text" e.g.
     end
 
     def page_send(name, *args)
@@ -101,7 +101,7 @@ module Ferrum
     end
 
     def tag_name
-      @tag_name ||= desc["nodeName"].downcase
+      @tag_name ||= description["nodeName"].downcase
     end
 
     def visible?
@@ -156,7 +156,7 @@ module Ferrum
       # We compare backendNodeId because once nodeId is sent to frontend backend
       # never returns same nodeId sending 0. In other words frontend is
       # responsible for keeping track of node ids.
-      target_id == other.target_id && desc["backendNodeId"] == other.desc["backendNodeId"]
+      target_id == other.target_id && description["backendNodeId"] == other.description["backendNodeId"]
     end
 
     def send_keys(*keys)
@@ -169,7 +169,7 @@ module Ferrum
     end
 
     def inspect
-      %(#<#{self.class} @target_id=#{@target_id.inspect} @node_id=#{@node_id} @desc=#{@desc.inspect}>)
+      %(#<#{self.class} @target_id=#{@target_id.inspect} @node_id=#{@node_id} @description=#{@description.inspect}>)
     end
   end
 end

data/lib/ferrum/page.rb

@@ -53,7 +53,8 @@ module Ferrum
       begin
         @session_id = @browser.command("Target.attachToTarget", targetId: @target_id)["sessionId"]
       rescue BrowserError => e
-        if e.message == "No target with given id found"
+        case e.message
+        when "No target with given id found"
           raise NoSuchWindowError
         else
           raise

data/lib/ferrum/page/dom.rb

@@ -4,11 +4,11 @@ module Ferrum
   class Page
     module DOM
       def current_url
-        evaluate_in(execution_context_id, "window.top.location.href")
+        evaluate("window.top.location.href")
       end
 
       def title
-        evaluate_in(execution_context_id, "window.top.document.title")
+        evaluate("window.top.document.title")
       end
 
       def body
@@ -37,7 +37,7 @@ module Ferrum
         ids = command("DOM.querySelectorAll",
                       nodeId: node_id,
                       selector: selector)["nodeIds"]
-        ids.map { |id| _build_node(id) }.compact
+        ids.map { |id| build_node(id) }.compact
       end
 
       def at_css(selector, within: nil)
@@ -46,12 +46,12 @@ module Ferrum
         id = command("DOM.querySelector",
                      nodeId: node_id,
                      selector: selector)["nodeId"]
-        _build_node(id)
+        build_node(id)
       end
 
       private
 
-      def _build_node(node_id)
+      def build_node(node_id)
         description = command("DOM.describeNode", nodeId: node_id)
         Node.new(self, target_id, node_id, description["node"])
       rescue BrowserError => e

data/lib/ferrum/page/runtime.rb

@@ -29,65 +29,51 @@ module Ferrum
       }.freeze
 
       def evaluate(expression, *args)
-        response = call(expression, nil, nil, *args)
-        handle(response)
-      end
-
-      def evaluate_in(context_id, expression)
-        response = call(expression, nil, { executionContextId: context_id })
-        handle(response)
-      end
-
-      def evaluate_on(node:, expression:, by_value: true, timeout: 0)
-        object_id = command("DOM.resolveNode", nodeId: node.node_id).dig("object", "objectId")
-        options = DEFAULT_OPTIONS.merge(objectId: object_id)
-        options[:functionDeclaration] = options[:functionDeclaration] % expression
-        options.merge!(returnByValue: by_value)
-
-        response = command("Runtime.callFunctionOn", timeout: timeout, **options)
-          .dig("result").tap { |r| handle_error(r) }
-
-        by_value ? response.dig("value") : handle(response)
+        call(*args, expression: expression)
       end
 
       def evaluate_async(expression, wait_time, *args)
-        response = call(expression, wait_time * 1000, EVALUATE_ASYNC_OPTIONS, *args)
-        handle(response)
+        call(*args, expression: expression, wait_time: wait_time * 1000, **EVALUATE_ASYNC_OPTIONS)
       end
 
       def execute(expression, *args)
-        call(expression, nil, EXECUTE_OPTIONS, *args)
+        call(*args, expression: expression, handle: false, **EXECUTE_OPTIONS)
         true
       end
 
+      def evaluate_on(node:, expression:, by_value: true, timeout: 0)
+        rescue_intermittent_error do
+          response = command("DOM.resolveNode", nodeId: node.node_id)
+          object_id = response.dig("object", "objectId")
+          options = DEFAULT_OPTIONS.merge(objectId: object_id)
+          options[:functionDeclaration] = options[:functionDeclaration] % expression
+          options.merge!(returnByValue: by_value)
+
+          response = command("Runtime.callFunctionOn",
+                             timeout: timeout,
+                             **options)["result"].tap { |r| handle_error(r) }
+
+          by_value ? response.dig("value") : handle_response(response)
+        end
+      end
+
       private
 
-      def call(expression, wait_time, options = nil, *args)
-        options ||= {}
-        args = prepare_args(args)
+      def call(*args, expression:, wait_time: nil, handle: true, **options)
+        rescue_intermittent_error do
+          arguments = prepare_args(args)
+          params = DEFAULT_OPTIONS.merge(options)
+          expression = [wait_time, expression] if wait_time
+          params[:functionDeclaration] = params[:functionDeclaration] % expression
+          params = params.merge(arguments: arguments)
+          unless params[:executionContextId]
+            params = params.merge(executionContextId: execution_context_id)
+          end
 
-        options = DEFAULT_OPTIONS.merge(options)
-        expression = [wait_time, expression] if wait_time
-        options[:functionDeclaration] = options[:functionDeclaration] % expression
-        options = options.merge(arguments: args)
-        unless options[:executionContextId]
-          options = options.merge(executionContextId: execution_context_id)
-        end
+          response = command("Runtime.callFunctionOn",
+                             **params)["result"].tap { |r| handle_error(r) }
 
-        begin
-          attempts ||= 1
-          response = command("Runtime.callFunctionOn", **options)
-          response.dig("result").tap { |r| handle_error(r) }
-        rescue BrowserError => e
-          case e.message
-          when "No node with given id found",
-               "Could not find node with given id",
-               "Cannot find context with specified id"
-            sleep 0.1
-            attempts += 1
-            options = options.merge(executionContextId: execution_context_id)
-            retry if attempts <= 3
-          end
+          handle ? handle_response(response) : response
         end
       end
 
@@ -103,20 +89,7 @@ module Ferrum
         end
       end
 
-      def prepare_args(args)
-        args.map do |arg|
-          if arg.is_a?(Node)
-            resolved = command("DOM.resolveNode", nodeId: arg.node_id)
-            { objectId: resolved["object"]["objectId"] }
-          elsif arg.is_a?(Hash) && arg["objectId"]
-            { objectId: arg["objectId"] }
-          else
-            { value: arg }
-          end
-        end
-      end
-
-      def handle(response)
+      def handle_response(response)
         case response["type"]
         when "boolean", "number", "string"
           response["value"]
@@ -129,18 +102,17 @@ module Ferrum
 
           case response["subtype"]
           when "node"
-            begin
+              # We cannot store object_id in the node because page can be reloaded
+              # and node destroyed so we need to retrieve it each time for given id.
+              # Though we can try to subscribe to `DOM.childNodeRemoved` and
+              # `DOM.childNodeInserted` in the future.
               node_id = command("DOM.requestNode", objectId: object_id)["nodeId"]
-              desc = command("DOM.describeNode", nodeId: node_id)["node"]
-              Node.new(self, target_id, node_id, desc)
-            rescue BrowserError => e
-              # Node has disappeared while we were trying to get it
-              raise if e.message != "Could not find node with given id"
-            end
+              description = command("DOM.describeNode", nodeId: node_id)["node"]
+              Node.new(self, target_id, node_id, description)
           when "array"
             reduce_props(object_id, []) do |memo, key, value|
               next(memo) unless (Integer(key) rescue nil)
-              value = value["objectId"] ? handle(value) : value["value"]
+              value = value["objectId"] ? handle_response(value) : value["value"]
               memo.insert(key.to_i, value)
             end.compact
           when "date"
@@ -149,13 +121,26 @@ module Ferrum
             nil
           else
             reduce_props(object_id, {}) do |memo, key, value|
-              value = value["objectId"] ? handle(value) : value["value"]
+              value = value["objectId"] ? handle_response(value) : value["value"]
               memo.merge(key => value)
             end
           end
         end
       end
 
+      def prepare_args(args)
+        args.map do |arg|
+          if arg.is_a?(Node)
+            resolved = command("DOM.resolveNode", nodeId: arg.node_id)
+            { objectId: resolved["object"]["objectId"] }
+          elsif arg.is_a?(Hash) && arg["objectId"]
+            { objectId: arg["objectId"] }
+          else
+            { value: arg }
+          end
+        end
+      end
+
       def reduce_props(object_id, to)
         if cyclic?(object_id).dig("result", "value")
           return "(cyclic structure)"
@@ -189,6 +174,20 @@ module Ferrum
                 JS
                )
       end
+
+      def rescue_intermittent_error(max = 6)
+        attempts ||= 0
+        yield
+      rescue BrowserError => e
+        case e.message
+        when "No node with given id found",          # Node has disappeared while we were trying to get it
+             "Could not find node with given id",
+             "Cannot find context with specified id" # Context is lost, page is reloading
+          sleep 0.1
+          attempts += 1
+          attempts < max ? retry : raise
+        end
+      end
     end
   end
 end

data/lib/ferrum/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ferrum
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ferrum
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Dmitry Vorotilin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-26 00:00:00.000000000 Z
+date: 2019-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket-driver