playwright-ruby-client 0.0.3 → 0.0.8

data/lib/playwright/channel_owners/webkit_browser.rb

@@ -2,7 +2,7 @@ require_relative './browser'
 
 module Playwright
   module ChannelOwners
-    class WebkitBrowser < Browser
+    class WebKitBrowser < Browser
     end
   end
 end

data/lib/playwright/connection.rb

@@ -55,10 +55,13 @@ module Playwright
           method: method,
           params: replace_channels_with_guids(params),
         }
-        @transport.send_message(message)
-      rescue Transport::AlreadyDisconnectedError => err
-        @callbacks.delete(id)
-        callback.reject(err)
+        begin
+          @transport.send_message(message)
+        rescue => err
+          @callbacks.delete(id)
+          callback.reject(err)
+          raise unless err.is_a?(Transport::AlreadyDisconnectedError)
+        end
       end
 
       callback
@@ -132,7 +135,7 @@ module Playwright
         unless object
           raise "Cannot find object to dispose: #{guid}"
         end
-        object.dispose
+        object.send(:dispose!)
         return
       end
 
@@ -153,7 +156,7 @@ module Playwright
       end
 
       if payload.is_a?(Channel)
-        { guid: payload.guid }
+        return { guid: payload.guid }
       end
 
       if payload.is_a?(Hash)
@@ -192,12 +195,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 +212,6 @@ module Playwright
         if browser_name == 'chromium'
           'ChromiumBrowserContext'
         else
-          params << browser_name
           'BrowserContext'
         end
       else
@@ -224,7 +220,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/errors.rb

@@ -3,7 +3,7 @@ module Playwright
     # ref: https://github.com/microsoft/playwright-python/blob/0b4a980fed366c4c1dee9bfcdd72662d629fdc8d/playwright/_impl/_helper.py#L155
     def self.parse(error_payload)
       if error_payload['name'] == 'TimeoutError'
-        Playwright::TimeoutError.new(
+        TimeoutError.new(
           message: error_payload['message'],
           stack: error_payload['stack'].split("\n"),
         )

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/input_files.rb

@@ -0,0 +1,42 @@
+require 'base64'
+require 'mime/types'
+
+module Playwright
+  class InputFiles
+    def initialize(files)
+      @params = convert(files)
+    end
+
+    def as_params
+      @params
+    end
+
+    private def convert(files)
+      return convert([files]) unless files.is_a?(Array)
+
+      files.map do |file|
+        case file
+        when String
+          {
+            name: File.basename(file),
+            mimeType: mime_type_for(file),
+            buffer: Base64.strict_encode64(File.read(file)),
+          }
+        when File
+          {
+            name: File.basename(file.path),
+            mimeType: mime_type_for(file.path),
+            buffer: Base64.strict_encode64(file.read),
+          }
+        else
+          raise ArgumentError.new('file must be a String or File.')
+        end
+      end
+    end
+
+    private def mime_type_for(filepath)
+      mime_types = MIME::Types.type_for(filepath)
+      mime_types.first || 'application/octet-stream'
+    end
+  end
+end

data/lib/playwright/input_type.rb

@@ -0,0 +1,19 @@
+module Playwright
+  class InputType
+    def initialize(channel)
+      @channel = channel
+    end
+  end
+
+  # namespace declaration
+  module InputTypes ; end
+
+  def self.define_input_type(class_name, &block)
+    klass = Class.new(InputType)
+    klass.class_eval(&block) if block
+    InputTypes.const_set(class_name, klass)
+  end
+end
+
+# load subclasses
+Dir[File.join(__dir__, 'input_types', '*.rb')].each { |f| require f }

data/lib/playwright/input_types/android_input.rb

@@ -0,0 +1,19 @@
+module Playwright
+  define_input_type :AndroidInput do
+    def type(text)
+      @channel.send_message_to_server('inputType', text: text)
+    end
+
+    def press(key)
+      @channel.send_message_to_server('inputPress', key: key)
+    end
+
+    def tap_point(point)
+      @channel.send_message_to_server('inputTap', point: point)
+    end
+
+    def drag(from, to, steps)
+      @channel.send_message_to_server('inputDrag', from: from, to: to, steps: steps)
+    end
+  end
+end

data/lib/playwright/input_types/keyboard.rb

@@ -0,0 +1,32 @@
+module Playwright
+  define_input_type :Keyboard do
+    def down(key)
+      @channel.send_message_to_server('keyboardDown', key: key)
+      nil
+    end
+
+    def up(key)
+      @channel.send_message_to_server('keyboardDown', key: key)
+    end
+
+    def insert_text(text)
+      @channel.send_message_to_server('keyboardInsertText', text: text)
+    end
+
+    def type(text, delay: nil)
+      params = {
+        text: text,
+        delay: delay,
+      }.compact
+      @channel.send_message_to_server('keyboardType', params)
+    end
+
+    def press(key, delay: nil)
+      params = {
+        key: key,
+        delay: delay,
+      }.compact
+      @channel.send_message_to_server('keyboardPress', params)
+    end
+  end
+end

data/lib/playwright/input_types/mouse.rb

@@ -0,0 +1,4 @@
+module Playwright
+  define_input_type :Mouse do
+  end
+end

data/lib/playwright/input_types/touchscreen.rb

@@ -0,0 +1,4 @@
+module Playwright
+  define_input_type :Touchscreen do
+  end
+end

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,67 @@
+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
+
+      def eval_on_selector(channel, selector)
+        value = channel.send_message_to_server(
+          'evalOnSelector',
+          selector: selector,
+          expression: @expression,
+          isFunction: false,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
+
+      def eval_on_selector_all(channel, selector)
+        value = channel.send_message_to_server(
+          'evalOnSelectorAll',
+          selector: selector,
+          expression: @expression,
+          isFunction: false,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
+
+      def wait_for_function(channel, polling:, timeout:)
+        params = {
+          expression: @expression,
+          isFunction: false,
+          arg: @serialized_arg,
+          polling: polling,
+          timeout: timeout,
+        }.compact
+        if polling.is_a?(Numeric)
+          params[:pollingInterval] = polling
+        end
+        resp = channel.send_message_to_server('waitForFunction', params)
+        ChannelOwners::JSHandle.from(resp)
+      end
+    end
+  end
+end

data/lib/playwright/javascript/function.rb

@@ -0,0 +1,67 @@
+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
+
+      def eval_on_selector(channel, selector)
+        value = channel.send_message_to_server(
+          'evalOnSelector',
+          selector: selector,
+          expression: @definition,
+          isFunction: true,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
+
+      def eval_on_selector_all(channel, selector)
+        value = channel.send_message_to_server(
+          'evalOnSelectorAll',
+          selector: selector,
+          expression: @definition,
+          isFunction: true,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
+
+      def wait_for_function(channel, polling:, timeout:)
+        params = {
+          expression: @definition,
+          isFunction: true,
+          arg: @serialized_arg,
+          polling: polling,
+          timeout: timeout,
+        }.compact
+        if polling.is_a?(Numeric)
+          params[:pollingInterval] = polling
+        end
+        resp = channel.send_message_to_server('waitForFunction', params)
+        ChannelOwners::JSHandle.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 { |obj| [obj['k'], parse_hash(obj['v'])] }.to_h
+        end
+
+        if hash.key?('h')
+          return @handles[hash['h']]
+        end
+
+        raise ArgumentError.new("Unexpected value: #{hash}")
+      end
+    end
+  end
+end