puppeteer-ruby 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a500508a5a1d88ed4694c5614c7c70bdae06d4d5cb10f81c1237ebd25a6623f
-  data.tar.gz: 338b902e3c64d9f96e7b7822353a7b664ab112cd3993e7a7ec06cda41752521e
+  metadata.gz: 9bff69308f1dc62011bd6278beb2883c5f16b42dfae0d138c8a442c0ed78cd93
+  data.tar.gz: f336776cfc903db13391c11110650d8103e0eb291fa9a9d79366c9b0f9544b9e
 SHA512:
-  metadata.gz: 51ea52a62c04917d5ec62c4224ffe91cacf3ccd3cfc796d94d975c309971dc0e789fdec7f4fabcc37f51619d833f070e7d6136f18cdb7113721382392456dd88
-  data.tar.gz: ef643098e96d3d1794470f38befb55039916c13b35d7d133596acf42d7217c302d1de4865c62c178e758aa619063ee9469bbbfcda1665c3e19fcca26aaee12ce
+  metadata.gz: fe90923f1c31681ec8bc0c092a9ca59976d18f682a99491de57f764f76b35ce27482f47b08348adc84f0b09e215c8cfe788730cb53d776b4922d1e397509ab23
+  data.tar.gz: ea4cb7f51c4944d082592c2a6fad51c69e8c3e6f356d6c5e6867cf9da3821249e346db7beee103e96a74f517ee929dcc1c865f79a07837a5f8c10efac357f748

data/lib/puppeteer/dom_world.rb

@@ -132,45 +132,48 @@ class Puppeteer::DOMWorld
     document.SS(selector)
   end
 
-  # /**
-  #  * @return {!Promise<String>}
-  #  */
-  # async content() {
-  #   return await this.evaluate(() => {
-  #     let retVal = '';
-  #     if (document.doctype)
-  #       retVal = new XMLSerializer().serializeToString(document.doctype);
-  #     if (document.documentElement)
-  #       retVal += document.documentElement.outerHTML;
-  #     return retVal;
-  #   });
-  # }
+  # @return [String]
+  def content
+    evaluate <<-JAVASCRIPT
+    () => {
+      let retVal = '';
+      if (document.doctype)
+        retVal = new XMLSerializer().serializeToString(document.doctype);
+      if (document.documentElement)
+        retVal += document.documentElement.outerHTML;
+      return retVal;
+    }
+    JAVASCRIPT
+  end
 
-  # /**
-  #  * @param {string} html
-  #  * @param {!{timeout?: number, waitUntil?: string|!Array<string>}=} options
-  #  */
-  # async setContent(html, options = {}) {
-  #   const {
-  #     waitUntil = ['load'],
-  #     timeout = this._timeoutSettings.navigationTimeout(),
-  #   } = options;
-  #   // We rely upon the fact that document.open() will reset frame lifecycle with "init"
-  #   // lifecycle event. @see https://crrev.com/608658
-  #   await this.evaluate(html => {
-  #     document.open();
-  #     document.write(html);
-  #     document.close();
-  #   }, html);
-  #   const watcher = new LifecycleWatcher(this._frameManager, this._frame, waitUntil, timeout);
-  #   const error = await Promise.race([
-  #     watcher.timeoutOrTerminationPromise(),
-  #     watcher.lifecyclePromise(),
-  #   ]);
-  #   watcher.dispose();
-  #   if (error)
-  #     throw error;
-  # }
+  # @param html [String]
+  # @param timeout [Integer]
+  # @param wait_until [String|Array<String>]
+  def set_content(html, timeout: nil, wait_until: nil)
+    option_wait_until = [wait_until || 'load'].flatten
+    option_timeout = @timeout_settings.navigation_timeout
+
+    # We rely upon the fact that document.open() will reset frame lifecycle with "init"
+    # lifecycle event. @see https://crrev.com/608658
+    js = <<-JAVASCRIPT
+    (html) => {
+      document.open();
+      document.write(html);
+      document.close();
+    }
+    JAVASCRIPT
+    evaluate(js, html)
+
+    watcher = Puppeteer::LifecycleWatcher.new(@frame_manager, @frame, option_wait_until, option_timeout)
+    begin
+      await_any(
+        watcher.timeout_or_termination_promise,
+        watcher.lifecycle_promise,
+      )
+    ensure
+      watcher.dispose
+    end
+  end
 
   # /**
   #  * @param {!{url?: string, path?: string, content?: string, type?: string}} options

data/lib/puppeteer/frame.rb

@@ -110,12 +110,14 @@ class Puppeteer::Frame
 
   define_async_method :async_SS
 
+  # @return [String]
   def content
     @secondary_world.content
   end
 
-  # @param {string} html
-  # @param {!{timeout?: number, waitUntil?: string|!Array<string>}=} options
+  # @param html [String]
+  # @param timeout [Integer]
+  # @param wait_until [String|Array<String>]
   def set_content(html, timeout: nil, wait_until: nil)
     @secondary_world.set_content(html, timeout: timeout, wait_until: wait_until)
   end

data/lib/puppeteer/page.rb

@@ -1,5 +1,7 @@
 require 'base64'
+require "stringio"
 
+require_relative './page/pdf_options'
 require_relative './page/screenshot_options'
 
 class Puppeteer::Page
@@ -649,13 +651,14 @@ class Puppeteer::Page
     main_frame.content
   end
 
-  # @param {string} html
-  # @param {!{timeout?: number, waitUntil?: string|!Array<string>}=} options
+  # @param html [String]
+  # @param timeout [Integer]
+  # @param wait_until [String|Array<String>]
   def set_content(html, timeout: nil, wait_until: nil)
     main_frame.set_content(html, timeout: timeout, wait_until: wait_until)
   end
 
-  # @param {string} html
+  # @param html [String]
   def content=(html)
     main_frame.set_content(html)
   end
@@ -915,60 +918,53 @@ class Puppeteer::Page
     buffer
   end
 
-  # /**
-  #  * @param {!PDFOptions=} options
-  #  * @return {!Promise<!Buffer>}
-  #  */
-  # async pdf(options = {}) {
-  #   const {
-  #     scale = 1,
-  #     displayHeaderFooter = false,
-  #     headerTemplate = '',
-  #     footerTemplate = '',
-  #     printBackground = false,
-  #     landscape = false,
-  #     pageRanges = '',
-  #     preferCSSPageSize = false,
-  #     margin = {},
-  #     path = null
-  #   } = options;
+  class ProtocolStreamReader
+    def initialize(client:, handle:, path:)
+      @client = client
+      @handle = handle
+      @path = path
+    end
 
-  #   let paperWidth = 8.5;
-  #   let paperHeight = 11;
-  #   if (options.format) {
-  #     const format = Page.PaperFormats[options.format.toLowerCase()];
-  #     assert(format, 'Unknown paper format: ' + options.format);
-  #     paperWidth = format.width;
-  #     paperHeight = format.height;
-  #   } else {
-  #     paperWidth = convertPrintParameterToInches(options.width) || paperWidth;
-  #     paperHeight = convertPrintParameterToInches(options.height) || paperHeight;
-  #   }
+    def read
+      out = StringIO.new
+      File.open(@path, 'w') do |file|
+        eof = false
+        until eof
+          response = @client.send_message('IO.read', handle: @handle)
+          eof = response['eof']
+          data =
+            if response['base64Encoded']
+              Base64.decode64(response['data'])
+            else
+              response['data']
+            end
+          out.write(data)
+          file.write(data)
+        end
+      end
+      @client.send_message('IO.close', handle: @handle)
+      out.read
+    end
+  end
 
-  #   const marginTop = convertPrintParameterToInches(margin.top) || 0;
-  #   const marginLeft = convertPrintParameterToInches(margin.left) || 0;
-  #   const marginBottom = convertPrintParameterToInches(margin.bottom) || 0;
-  #   const marginRight = convertPrintParameterToInches(margin.right) || 0;
-
-  #   const result = await this._client.send('Page.printToPDF', {
-  #     transferMode: 'ReturnAsStream',
-  #     landscape,
-  #     displayHeaderFooter,
-  #     headerTemplate,
-  #     footerTemplate,
-  #     printBackground,
-  #     scale,
-  #     paperWidth,
-  #     paperHeight,
-  #     marginTop,
-  #     marginBottom,
-  #     marginLeft,
-  #     marginRight,
-  #     pageRanges,
-  #     preferCSSPageSize
-  #   });
-  #   return await helper.readProtocolStream(this._client, result.stream, path);
-  # }
+  class PrintToPdfIsNotImplementedError < StandardError
+    def initialize
+      super('pdf() is only available in headless mode. See https://github.com/puppeteer/puppeteer/issues/1829')
+    end
+  end
+
+  # @return [String]
+  def pdf(options = {})
+    pdf_options = PDFOptions.new(options)
+    result = @client.send_message('Page.printToPDF', pdf_options.page_print_args)
+    ProtocolStreamReader.new(client: @client, handle: result['stream'], path: pdf_options.path).read
+  rescue => err
+    if err.message.include?('PrintToPDF is not implemented')
+      raise PrintToPdfIsNotImplementedError.new
+    else
+      raise
+    end
+  end
 
   # @param run_before_unload [Boolean]
   def close(run_before_unload: false)

data/lib/puppeteer/page/pdf_options.rb

@@ -0,0 +1,166 @@
+require 'mime/types'
+
+class Puppeteer::Page
+  # /**
+  # * @typedef {Object} PDFOptions
+  # * @property {number=} scale
+  # * @property {boolean=} displayHeaderFooter
+  # * @property {string=} headerTemplate
+  # * @property {string=} footerTemplate
+  # * @property {boolean=} printBackground
+  # * @property {boolean=} landscape
+  # * @property {string=} pageRanges
+  # * @property {string=} format
+  # * @property {string|number=} width
+  # * @property {string|number=} height
+  # * @property {boolean=} preferCSSPageSize
+  # * @property {!{top?: string|number, bottom?: string|number, left?: string|number, right?: string|number}=} margin
+  # * @property {string=} path
+  # */
+  class PDFOptions
+    # @params options [Hash]
+    def initialize(options)
+      unless options[:path]
+        # Original puppeteer allows path = nil, however nothing to do without path actually.
+        # Also in most case, users forget to specify path parameter. So let's raise ArgumentError.
+        raise ArgumentError('"path" parameter must be specified.')
+      end
+
+      @scale = options[:scale]
+      @display_header_footer = options[:display_header_footer]
+      @header_template = options[:header_template]
+      @footer_template = options[:footer_template]
+      @print_background = options[:print_background]
+      @landscape = options[:landscape]
+      @page_ranges = options[:page_ranges]
+      @format = options[:format]
+      @width = options[:width]
+      @height = options[:height]
+      @prefer_css_page_size = options[:prefer_css_page_size]
+      @margin = Margin.new(options[:margin] || {})
+      @path = options[:path]
+    end
+
+    attr_reader :path
+
+    class PaperSize
+      def initialize(width:, height:)
+        @width = width
+        @height = height
+      end
+      attr_reader :width, :height
+    end
+
+    PAPER_FORMATS = {
+      letter: PaperSize.new(width: 8.5, height: 11),
+      legal: PaperSize.new(width: 8.5, height: 14),
+      tabloid: PaperSize.new(width: 11, height: 17),
+      ledger: PaperSize.new(width: 17, height: 11),
+      a0: PaperSize.new(width: 33.1, height: 46.8),
+      a1: PaperSize.new(width: 23.4, height: 33.1),
+      a2: PaperSize.new(width: 16.54, height: 23.4),
+      a3: PaperSize.new(width: 11.7, height: 16.54),
+      a4: PaperSize.new(width: 8.27, height: 11.7),
+      a5: PaperSize.new(width: 5.83, height: 8.27),
+      a6: PaperSize.new(width: 4.13, height: 5.83),
+    }
+
+    UNIT_TO_PIXELS = {
+      px: 1,
+      in: 96,
+      cm: 37.8,
+      mm: 3.78,
+    }
+
+    # @param parameter [String|Integer|nil]
+    private def convert_print_parameter_to_inches(parameter)
+      return nil if parameter.nil?
+
+      pixels =
+        if parameter.is_a?(Numeric)
+          parameter.to_i
+        elsif parameter.is_a?(String)
+          unit = parameter[-2..-1].downcase
+          value =
+            if UNIT_TO_PIXELS.has_key?(unit)
+              parameter[0...-2].to_i
+            else
+              unit = 'px'
+              parameter.to_i
+            end
+
+          value * UNIT_TO_PIXELS[unit]
+        else
+          raise ArgumentError.new("page.pdf() Cannot handle parameter type: #{parameter.class}")
+        end
+
+      pixels / 96
+    end
+
+    private def paper_size
+      @paper_size ||= calc_paper_size
+    end
+
+    # @return [PaperSize]
+    private def calc_paper_size
+      if @format
+        PAPER_FORMATS[@format.downcase] or raise ArgumentError.new("Unknown paper format: #{@format}")
+      else
+        PaperSize.new(
+          width: convert_print_parameter_to_inches(@width) || 8.5,
+          height: convert_print_parameter_to_inches(@height) || 11.0,
+        )
+      end
+    end
+
+    class Margin
+      def initialize(options)
+        @top = options[:top]
+        @bottom = options[:bottom]
+        @left = options[:left]
+        @right = options[:right]
+      end
+
+      def translate(&block)
+        new_margin ={
+          top: block.call(@top),
+          bottom: block.call(@bottom),
+          left: block.call(@left),
+          right: block.call(@right),
+        }
+        Margin.new(new_margin)
+      end
+      attr_reader :top, :bottom, :left, :right
+    end
+
+    private def margin
+      @__margin ||= calc_margin
+    end
+
+    private def calc_margin
+      @margin.translate do |value|
+        convert_print_parameter_to_inches(value) || 0
+      end
+    end
+
+    def page_print_args
+      {
+        transferMode: 'ReturnAsStream',
+        landscape: @landscape || false,
+        displayHeaderFooter: @display_header_footer || false,
+        headerTemplate: @header_template || '',
+        footerTemplate: @footer_template || '',
+        printBackground: @print_background || false,
+        scale: @scale || 1,
+        paperWidth: paper_size.width,
+        paperHeight: paper_size.height,
+        marginTop: margin.top,
+        marginBottom: margin.bottom,
+        marginLeft: margin.left,
+        marginRight: margin.right,
+        pageRanges: @page_ranges || '',
+        preferCSSPageSize: @prefer_css_page_size || false,
+      }
+    end
+  end
+end

data/lib/puppeteer/version.rb

@@ -1,3 +1,3 @@
 class Puppeteer
-  VERSION = '0.0.14'
+  VERSION = '0.0.15'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppeteer-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.15
 platform: ruby
 authors:
 - YusukeIwaki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-27 00:00:00.000000000 Z
+date: 2020-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -224,6 +224,7 @@ files:
 - lib/puppeteer/mouse.rb
 - lib/puppeteer/network_manager.rb
 - lib/puppeteer/page.rb
+- lib/puppeteer/page/pdf_options.rb
 - lib/puppeteer/page/screenshot_options.rb
 - lib/puppeteer/remote_object.rb
 - lib/puppeteer/target.rb