playwright-ruby-client 0.0.4 → 0.0.5

data/lib/playwright/connection.rb

@@ -192,12 +192,6 @@ module Playwright
       end
       initializer = replace_guids_with_channels(initializer)
 
-      params = [
-        parent,
-        type,
-        guid,
-        initializer,
-      ]
       class_name = case type
       when 'Browser'
         case initializer['name']
@@ -215,7 +209,6 @@ module Playwright
         if browser_name == 'chromium'
           'ChromiumBrowserContext'
         else
-          params << browser_name
           'BrowserContext'
         end
       else
@@ -224,7 +217,12 @@ module Playwright
 
       result =
         begin
-          ChannelOwners.const_get(class_name).new(*params)
+          ChannelOwners.const_get(class_name).new(
+            parent,
+            type,
+            guid,
+            initializer,
+          )
         rescue NameError
           raise "Missing type #{type}"
         end

data/lib/playwright/event_emitter.rb

@@ -17,6 +17,19 @@ module Playwright
     end
   end
 
+  module EventListenerInterface
+    def on(event, callback)
+      raise NotImplementedError.new('NOT IMPLEMENTED')
+    end
+
+    def off(event, callback)
+      raise NotImplementedError.new('NOT IMPLEMENTED')
+    end
+
+    def once(event, callback)
+      raise NotImplementedError.new('NOT IMPLEMENTED')
+    end
+  end
 
   # A subset of Events/EventEmitter in Node.js
   module EventEmitter

data/lib/playwright/javascript.rb

@@ -0,0 +1,13 @@
+require_relative './javascript/expression'
+require_relative './javascript/function'
+require_relative './javascript/value_parser'
+require_relative './javascript/value_serializer'
+
+module Playwright
+  module JavaScript
+    # Detect if str is likely to be a function
+    module_function def function?(str)
+      ['async', 'function'].any? { |key| str.strip.start_with?(key) } || str.include?('=>')
+    end
+  end
+end

data/lib/playwright/javascript/expression.rb

@@ -0,0 +1,30 @@
+module Playwright
+  module JavaScript
+    class Expression
+      def initialize(expression)
+        @expression = expression
+        @serialized_arg = ValueSerializer.new(nil).serialize
+      end
+
+      def evaluate(channel)
+        value = channel.send_message_to_server(
+          'evaluateExpression',
+          expression: @expression,
+          isFunction: false,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
+
+      def evaluate_handle(channel)
+        resp = channel.send_message_to_server(
+          'evaluateExpressionHandle',
+          expression: @expression,
+          isFunction: false,
+          arg: @serialized_arg,
+        )
+        ::Playwright::ChannelOwner.from(resp)
+      end
+    end
+  end
+end

data/lib/playwright/javascript/function.rb

@@ -0,0 +1,30 @@
+module Playwright
+  module JavaScript
+    class Function
+      def initialize(definition, arg)
+        @definition = definition
+        @serialized_arg = ValueSerializer.new(arg).serialize
+      end
+
+      def evaluate(channel)
+        value = channel.send_message_to_server(
+          'evaluateExpression',
+          expression: @definition,
+          isFunction: true,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
+
+      def evaluate_handle(channel)
+        resp = channel.send_message_to_server(
+          'evaluateExpressionHandle',
+          expression: @definition,
+          isFunction: true,
+          arg: @serialized_arg,
+        )
+        ::Playwright::ChannelOwner.from(resp)
+      end
+    end
+  end
+end

data/lib/playwright/javascript/value_parser.rb

@@ -0,0 +1,75 @@
+require 'date'
+
+module Playwright
+  module JavaScript
+    class ValueParser
+      def initialize(hash)
+        @hash = hash
+      end
+
+      # @return [Hash]
+      def parse
+        if @hash.nil?
+          nil
+        else
+          parse_hash(@hash)
+        end
+      end
+
+      # ref: https://github.com/microsoft/playwright/blob/b45905ae3f1a066a8ecb358035ce745ddd21cf3a/src/protocol/serializers.ts#L42
+      # ref: https://github.com/microsoft/playwright-python/blob/25a99d53e00e35365cf5113b9525272628c0e65f/playwright/_impl/_js_handle.py#L140
+      private def parse_hash(hash)
+        %w(n s b).each do |key|
+          return hash[key] if hash.key?(key)
+        end
+
+        if hash.key?('v')
+          return
+            case hash['v']
+            when 'undefined'
+              nil
+            when 'null'
+              nil
+            when 'NaN'
+              Float::NAN
+            when 'Infinity'
+              Float::INFINITY
+            when '-Infinity'
+              -Float::INFINITY
+            when '-0'
+              -0
+            end
+        end
+
+        if hash.key?('d')
+          return DateTime.parse(hash['d'])
+        end
+
+        if hash.key?('r')
+          # @see https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/RegExp
+          # @see https://docs.ruby-lang.org/ja/latest/class/Regexp.html
+          js_regex_flag = hash['r']['f']
+          flags = []
+          flags << Regexp::IGNORECASE if js_regex_flag.include?('i')
+          flags << Regexp::MULTILINE if js_regex_flag.include?('m') || js_regex_flag.include?('s')
+
+          return Regexp.compile(hash['r']['p'], flags.inject(:|))
+        end
+
+        if hash.key?('a')
+          return hash['a'].map { |value| parse_hash(value) }
+        end
+
+        if hash.key?('o')
+          return hash['o'].map { |key, value| [key, parse_hash(value)].to_h }
+        end
+
+        if hash.key?('h')
+          return @handles[hash['h']]
+        end
+
+        raise ArgumentError.new("Unexpected value: #{hash}")
+      end
+    end
+  end
+end

data/lib/playwright/javascript/value_serializer.rb

@@ -0,0 +1,54 @@
+module Playwright
+  module JavaScript
+    class ValueSerializer
+      def initialize(ruby_value)
+        @value = ruby_value
+      end
+
+      # @return [Hash]
+      def serialize
+        @handles = []
+        { value: serialize_value(@value), handles: @handles }
+      end
+
+      # ref: https://github.com/microsoft/playwright/blob/b45905ae3f1a066a8ecb358035ce745ddd21cf3a/src/protocol/serializers.ts#L84
+      # ref: https://github.com/microsoft/playwright-python/blob/25a99d53e00e35365cf5113b9525272628c0e65f/playwright/_impl/_js_handle.py#L99
+      private def serialize_value(value)
+        case value
+        when JSHandle
+          index = @handles.count
+          @handles << v
+          { h: index }
+        when nil
+          { v: 'undefined' }
+        when Float::NAN
+          { v: 'NaN'}
+        when Float::INFINITY
+          { v: 'Infinity' }
+        when -Float::INFINITY
+          { v: '-Infinity' }
+        when true, false
+          { b: v }
+        when Numeric
+          { n: v }
+        when String
+          { s: v }
+        when Time
+          require 'time'
+          { d: v.utc.iso8601 }
+        when Regexp
+          flags = []
+          flags << 'ms' if (v.options & Regexp::MULTILINE) != 0
+          flags << 'i' if (v.options & Regexp::IGNORECASE) != 0
+          { r: { p: v.source, f: flags.join('') } }
+        when Array
+          { a: v.map { |value| serialize_value(value) } }
+        when Hash
+          { o: v.map { |key, value| [key, serialize_value(value)] }.to_h }
+        else
+          raise ArgumentError.new("Unexpected value: #{value}")
+        end
+      end
+    end
+  end
+end

data/lib/playwright/playwright_api.rb

@@ -10,8 +10,6 @@ module Playwright
       Factory.new(channel_owner).create
     end
 
-    private
-
     class Factory
       def initialize(channel_owner)
         channel_owner_class_name = channel_owner.class.name
@@ -54,15 +52,21 @@ module Playwright
       @channel_owner = channel_owner
     end
 
+    def ==(other)
+      @channel_owner.to_s == other.instance_variable_get(:'@channel_owner').to_s
+    end
+
     # @param block [Proc]
-    def wrap_block_call(block)
+    private def wrap_block_call(block)
+      return nil unless block.is_a?(Proc)
+
       -> (*args) {
         wrapped_args = args.map { |arg| wrap_channel_owner(arg) }
         block.call(*wrapped_args)
       }
     end
 
-    def wrap_channel_owner(object)
+    private def wrap_channel_owner(object)
       if object.is_a?(ChannelOwner)
         PlaywrightApi.from_channel_owner(object)
       elsif object.is_a?(Array)

data/lib/playwright/timeout_settings.rb

@@ -0,0 +1,19 @@
+module Playwright
+  class TimeoutSettings
+    DEFAULT_TIMEOUT = 30000
+
+    def initialize(parent = nil)
+      @parent = parent
+    end
+
+    attr_writer :default_timeout, :default_navigation_timeout
+
+    def navigation_timeout
+      @default_navigation_timeout || @default_timeout || @parent&.navigation_timeout || EFAULT_TIMEOUT
+    end
+
+    def timeout
+      @default_timeout || @parent&.navigation_timeout || DEFAULT_TIMEOUT
+    end
+  end
+end

data/lib/playwright/utils.rb

@@ -0,0 +1,19 @@
+module Playwright
+  module Utils
+    module Errors
+      module SafeCloseError
+        # @param err [Exception]
+        private def safe_close_error?(err)
+          return true if err.is_a?(Transport::AlreadyDisconnectedError)
+
+          [
+            'Browser has been closed',
+            'Target page, context or browser has been closed',
+          ].any? do |closed_message|
+            err.message.end_with?(closed_message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/playwright/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/lib/playwright/wait_helper.rb

@@ -0,0 +1,73 @@
+module Playwright
+  # ref: https://github.com/microsoft/playwright-python/blob/30946ae3099d51f9b7f355f9ae7e8c04d748ce36/playwright/_impl/_wait_helper.py
+  # ref: https://github.com/microsoft/playwright/blob/01fb3a6045cbdb4b5bcba0809faed85bd917ab87/src/client/waiter.ts#L21
+  class WaitHelper
+    def initialize
+      @promise = Concurrent::Promises.resolvable_future
+      @registered_listeners = Set.new
+    end
+
+    def reject_on_event(emitter, event, error, predicate: nil)
+      listener = -> (*args) {
+        if !predicate || predicate.call(*args)
+          reject(error)
+        end
+      }
+      emitter.on(event, listener)
+      @registered_listeners << [emitter, event, listener]
+
+      self
+    end
+
+    def reject_on_timeout(timeout_ms, message)
+      return if timeout_ms <= 0
+
+      Concurrent::Promises.schedule(timeout_ms / 1000.0) {
+        reject(TimeoutError.new(message))
+      }
+
+      self
+    end
+
+    # @param [Playwright::EventEmitter]
+    # @param
+    def wait_for_event(emitter, event, predicate: nil)
+      listener = -> (*args) {
+        begin
+          if !predicate || predicate.call(*args)
+            fulfill(*args)
+          end
+        rescue => err
+          reject(err)
+        end
+      }
+      emitter.on(event, listener)
+      @registered_listeners << [emitter, event, listener]
+
+      self
+    end
+
+    attr_reader :promise
+
+    private def cleanup
+      @registered_listeners.each do |emitter, event, listener|
+        emitter.off(event, listener)
+      end
+      @registered_listeners.clear
+    end
+
+    private def fulfill(*args)
+      cleanup
+      unless @promise.resolved?
+        @promise.fulfill(args.first)
+      end
+    end
+
+    private def reject(error)
+      cleanup
+      unless @promise.resolved?
+        @promise.reject(error)
+      end
+    end
+  end
+end

data/lib/playwright_api/binding_call.rb

@@ -1,5 +1,23 @@
 module Playwright
   # @nodoc
   class BindingCall < PlaywrightApi
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      wrap_channel_owner(@channel_owner.off(event, callback))
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      wrap_channel_owner(@channel_owner.once(event, callback))
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      wrap_channel_owner(@channel_owner.on(event, callback))
+    end
   end
 end

data/lib/playwright_api/browser.rb

@@ -132,5 +132,23 @@ module Playwright
     def after_initialize
       wrap_channel_owner(@channel_owner.after_initialize)
     end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      wrap_channel_owner(@channel_owner.off(event, callback))
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      wrap_channel_owner(@channel_owner.once(event, callback))
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      wrap_channel_owner(@channel_owner.on(event, callback))
+    end
   end
 end