screenshot 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 463f6b75a51edc417e5e3b3f4e6af7cf1b0991a8
-  data.tar.gz: 55e25638ce41681938342f35b4285d3e1b5d6889
+  metadata.gz: 3da4c0f81e3a99c26ad33877274e7e160a096d9d
+  data.tar.gz: 0e36a57cd73ec600435f516682293297a2d5eafb
 SHA512:
-  metadata.gz: 95483fa46626177a0502dea6d19974040d9f45d04f625eee3e23f8543870e6b034f989e3e066ee3edbcc801a6299c3ace14cb7097930320583cdc12977f4ee44
-  data.tar.gz: bdb0d61c094336bb8d297050bb1cac0e17ed9b9163de16443bf941ca886de8ee50180afc02413b43754632de8e75b34415a1604ad0aa4955512047a1bb51bd72
+  metadata.gz: 543c4140553429600008c8f4723a12c4b2fca0f745d9cbb50fd351c735d0cbeae8c2706f4f68c7330df42d302851c7e89c26cbea981faa416794fde684c87ccd
+  data.tar.gz: 22efffd640d47a48e31663a344da57029586352646d4c14dcf378a41dea64c8d47d97f6480d1358a56610b972c7d2f82117456f570edcb16314a3326981c77cc

data/lib/screenshot.rb

@@ -1,5 +1,106 @@
 require "screenshot/version"
 
 module Screenshot
-  # Your code goes here...
+  def capture_screenshot(file_name, page_elements)
+    screenshot_directory = ENV['LANGUAGE_SCREENSHOT_PATH'] || 'screenshots'
+    FileUtils.mkdir_p screenshot_directory
+    screenshot_path = "#{screenshot_directory}/#{file_name}"
+
+    @browser.screenshot.save screenshot_path
+    crop_image screenshot_path, page_elements, nil
+  end
+
+  def zoom_browser(rate)
+    rate.abs.times do
+      direction = rate > 0 ? :add : :subtract
+      @browser.send_keys [:control, direction]
+    end
+  end
+
+  def crop_image(path, page_elements, offset_element)
+    if offset_element
+      offset_rectangle = coordinates_from_page_element(offset_element)
+    else
+      offset_rectangle = [0, 0, 0, 0]
+    end
+    rectangles = coordinates_from_page_elements(page_elements)
+    crop_rectangle = rectangle(rectangles, offset_rectangle)
+
+    top_left_x = crop_rectangle[0]
+    top_left_y = crop_rectangle[1]
+    width = crop_rectangle[2]
+    height = crop_rectangle[3]
+
+    require 'chunky_png'
+    image = ChunkyPNG::Image.from_file path
+
+    # It happens with some elements that an image goes off the screen a bit,
+    # and chunky_png fails when this happens
+    width = image.width - top_left_x if image.width < top_left_x + width
+
+    image.crop!(top_left_x, top_left_y, width, height)
+    image.save path
+  end
+
+  def self.rectangle(rectangles, offset_rectangle = [0, 0, 0, 0])
+    top_left_x, top_left_y = top_left_x_y rectangles
+    bottom_right_x, bottom_right_y = bottom_right_x_y rectangles
+
+    # Finding width and height
+    width = bottom_right_x - top_left_x
+    height = bottom_right_y - top_left_y
+
+    # We are calculating the offset co-ordinates
+    x_offset = offset_rectangle[0]
+    y_offset = offset_rectangle[1]
+
+    # The new rectangle is constructed with all the co-ordinates calculated above
+    [top_left_x + x_offset, top_left_y + y_offset, width, height]
+  end
+
+  def coordinates_from_page_elements(page_elements)
+    page_elements.collect do |page_element|
+      coordinates_from_page_element page_element
+    end
+  end
+
+  def coordinates_from_page_element(page_element)
+    [page_element.element.wd.location.x, page_element.element.wd.location.y, page_element.element.wd.size.width, page_element.element.wd.size.height]
+  end
+
+  def self.top_left_x_coordinates(input_rectangles)
+    input_rectangles.collect do |rectangle|
+      rectangle[0]
+    end
+  end
+
+  def self.top_left_y_coordinates(input_rectangles)
+    input_rectangles.collect do |rectangle|
+      rectangle[1]
+    end
+  end
+
+  def self.bottom_right_x_coordinates(input_rectangles)
+    input_rectangles.collect do |rectangle|
+      rectangle[0] + rectangle[2]
+    end
+  end
+
+  def self.bottom_right_y_coordinates(input_rectangles)
+    input_rectangles.collect do |rectangle|
+      rectangle[1] + rectangle[3]
+    end
+  end
+
+  def self.bottom_right_x_y(input_rectangles)
+    [bottom_right_x_coordinates(input_rectangles).max, bottom_right_y_coordinates(input_rectangles).max]
+  end
+
+  def self.top_left_x_y(input_rectangles)
+    [top_left_x_coordinates(input_rectangles).min, top_left_y_coordinates(input_rectangles).min]
+  end
+
+  def highlight(element, color = '#FF00FF')
+    @current_page.execute_script("arguments[0].style.border = 'thick solid #{color}'", element)
+  end
 end

data/lib/screenshot/version.rb

@@ -1,3 +1,3 @@
 module Screenshot
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/screenshot.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.2.0"
 end

data/spec/rectangle_spec.rb

@@ -0,0 +1,204 @@
+require_relative "../lib/screenshot.rb"
+
+# Rectangle is defined as set of co-ordinates represented by top left x, top left y, width, height
+describe 'Rectangle' do
+  it 'should return the co-ordinates of provided 1 rectangle' do
+    input_rectangle = [0, 0, 1, 1]
+    input_rectangles = [input_rectangle]
+    expect(Screenshot.rectangle(input_rectangles)).to eq(input_rectangle)
+  end
+
+  it 'should return the co-ordinates of the rectangle which is inside a iframe' do
+    input_rectangle  = [50, 50, 10, 10]
+    iframe_rectangle = [100, 100, 20, 20]
+    input_rectangles = [input_rectangle]
+    output_rectangle = [150, 150, 10, 10]
+    expect(Screenshot.rectangle(input_rectangles, iframe_rectangle)).to eq(output_rectangle)
+  end
+
+  it 'if we provide 2 rectangles and if one contains the other then it should return co-ordinates of bigger rectangle' do
+    input_rectangle_1 = [0, 0, 1, 1]
+    input_rectangle_2 = [0, 0, 2, 2]
+    input_rectangles = [input_rectangle_1, input_rectangle_2]
+    expect(Screenshot.rectangle(input_rectangles)).to eq(input_rectangle_2)
+  end
+
+  it 'if we provide 2 rectangles it should return co-ordinates of third rectangle which contains both' do
+    input_rectangle_1  = [0, 0, 1, 1]
+    input_rectangle_2  = [1, 0, 1, 1]
+    input_rectangles_1 = [input_rectangle_1, input_rectangle_2]
+    output_rectangle_1 = [0, 0, 2, 1]
+    expect(Screenshot.rectangle(input_rectangles_1)).to eq(output_rectangle_1)
+
+    input_rectangle_3  = [1, 1, 1, 1]
+    input_rectangle_4  = [3, 3, 1, 1]
+    input_rectangles_2 = [input_rectangle_3, input_rectangle_4]
+    output_rectangle_2 = [1, 1, 3, 3]
+    expect(Screenshot.rectangle(input_rectangles_2)).to eq(output_rectangle_2)
+  end
+
+  it 'if we provide 3 rectangles it should return co-ordinates the rectangle which contains all the input rectangles' do
+    input_rectangle_1  = [1, 1, 1, 1]
+    input_rectangle_2  = [2, 2, 1, 1]
+    input_rectangle_3  = [3, 3, 1, 1]
+    input_rectangles   = [input_rectangle_1, input_rectangle_2, input_rectangle_3]
+    output_rectangle_1 = [1, 1, 3, 3]
+    expect(Screenshot.rectangle(input_rectangles)).to eq(output_rectangle_1)
+  end
+end
+
+describe 'Calculate topleft co-ordinates' do
+  it 'if we provide 1 rectangle then it should return top left co-ordinates of the input rectangle' do
+    input_rectangle = [2, 2, 1, 1]
+    input_rectangles = [input_rectangle]
+    output_coordinates = [2, 2]
+    expect(Screenshot.top_left_x_y(input_rectangles)).to eq(output_coordinates)
+  end
+
+  it 'if we provide 2 rectangles then it should return top left co-ordinates of the biggest rectangle containing both rectangles' do
+    input_rectangle_1  = [1, 0, 1, 1]
+    input_rectangle_2  = [0, 0, 1, 1]
+    input_rectangles = [input_rectangle_1, input_rectangle_2]
+    output_coordinates = [0, 0]
+    expect(Screenshot.top_left_x_y(input_rectangles)).to eq(output_coordinates)
+  end
+
+  it 'if we provide 3 rectangles then it should return top left co-ordinates of the biggest rectangle containing both rectangles' do
+    input_rectangle_1  = [3, 3, 1, 1]
+    input_rectangle_2  = [2, 2, 1, 1]
+    input_rectangle_3  = [1, 1, 1, 1]
+    input_rectangles   = [input_rectangle_1, input_rectangle_2, input_rectangle_3]
+    output_coordinates = [1, 1]
+    expect(Screenshot.top_left_x_y(input_rectangles)).to eq(output_coordinates)
+  end
+end
+
+describe 'Topleft co-ordinates x' do
+  it 'if we provide 1 rectangle then it should return array of top left x co-ordinate of the input rectangle' do
+    input_rectangle = [2, 2, 1, 1]
+    input_rectangles = [input_rectangle]
+    output_coordinates = [2]
+    expect(Screenshot.top_left_x_coordinates(input_rectangles)).to eq(output_coordinates)
+  end
+
+  it 'if we provide 2 rectangles then it should return array top left x co-ordinates' do
+    input_rectangle_1  = [0, 0, 1, 1]
+    input_rectangle_2  = [1, 0, 1, 1]
+    input_rectangles   = [input_rectangle_1, input_rectangle_2]
+    output_coordinates = [0, 1]
+    expect(Screenshot.top_left_x_coordinates(input_rectangles)).to eq(output_coordinates)
+  end
+
+  it 'if we provide 3 rectangles then it should return array of top left x co-ordinates' do
+    input_rectangle_1  = [3, 3, 1, 1]
+    input_rectangle_2  = [2, 2, 1, 1]
+    input_rectangle_3  = [1, 1, 1, 1]
+    input_rectangles   = [input_rectangle_1, input_rectangle_2, input_rectangle_3]
+    output_coordinates = [3, 2, 1]
+    expect(Screenshot.top_left_x_coordinates(input_rectangles)).to eq(output_coordinates)
+  end
+end
+
+describe 'Topleft co-ordinates y' do
+  it 'if we provide 1 rectangle then it should return array of top left y co-ordinate of the input rectangle' do
+    input_rectangle = [2, 2, 1, 1]
+    input_rectangles = [input_rectangle]
+    output_coordinates = [2]
+    expect(Screenshot.top_left_y_coordinates(input_rectangles)).to eq(output_coordinates)
+  end
+
+  it 'if we provide 2 rectangles then it should return array top left y co-ordinates' do
+    input_rectangle_1  = [0, 0, 1, 1]
+    input_rectangle_2  = [1, 0, 1, 1]
+    input_rectangles   = [input_rectangle_1, input_rectangle_2]
+    output_coordinates = [0, 0]
+    expect(Screenshot.top_left_y_coordinates(input_rectangles)).to eq(output_coordinates)
+  end
+
+  it 'if we provide 3 rectangles then it should return array of top left y co-ordinates' do
+    input_rectangle_1  = [3, 3, 1, 1]
+    input_rectangle_2  = [2, 2, 1, 1]
+    input_rectangle_3  = [1, 1, 1, 1]
+    input_rectangles   = [input_rectangle_1, input_rectangle_2, input_rectangle_3]
+    output_coordinates = [3, 2, 1]
+    expect(Screenshot.top_left_y_coordinates(input_rectangles)).to eq(output_coordinates)
+  end
+end
+
+describe 'Calculate bottomright co-ordinates' do
+  it 'if we provide 1 rectangle then it should return bottom right co-ordinates of the input rectangle' do
+    input_rectangle = [2, 2, 1, 1]
+    input_rectangles = [input_rectangle]
+    output_coordinates = [3, 3]
+    expect(Screenshot.bottom_right_x_y(input_rectangles)).to eq(output_coordinates)
+  end
+
+  it 'if we provide 2 rectangles then it should return bottom right co-ordinates of the biggest rectangle containing both rectangles' do
+    input_rectangle_1  = [1, 0, 1, 1]
+    input_rectangle_2  = [0, 0, 1, 1]
+    input_rectangles = [input_rectangle_1, input_rectangle_2]
+    output_coordinates = [2, 1]
+    expect(Screenshot.bottom_right_x_y(input_rectangles)).to eq(output_coordinates)
+  end
+
+  it 'if we provide 3 rectangles then it should return bottom right co-ordinates of the biggest rectangle containing both rectangles' do
+    input_rectangle_1  = [3, 3, 1, 1]
+    input_rectangle_2  = [2, 2, 1, 1]
+    input_rectangle_3  = [1, 1, 1, 1]
+    input_rectangles   = [input_rectangle_1, input_rectangle_2, input_rectangle_3]
+    output_coordinates = [4, 4]
+    expect(Screenshot.bottom_right_x_y(input_rectangles)).to eq(output_coordinates)
+  end
+end
+
+describe 'Bottom right co-ordinates x' do
+  it 'if we provide 1 rectangle then it should return array of bottom right x co-ordinate of the input rectangle' do
+    input_rectangle = [2, 2, 1, 1]
+    input_rectangles = [input_rectangle]
+    output_coordinates = [3]
+    expect(Screenshot.bottom_right_x_coordinates(input_rectangles)).to eq(output_coordinates)
+  end
+
+  it 'if we provide 2 rectangles then it should return array bottom right x co-ordinates' do
+    input_rectangle_1  = [0, 0, 1, 1]
+    input_rectangle_2  = [1, 0, 1, 1]
+    input_rectangles   = [input_rectangle_1, input_rectangle_2]
+    output_coordinates = [1, 2]
+    expect(Screenshot.bottom_right_x_coordinates(input_rectangles)).to eq(output_coordinates)
+  end
+
+  it 'if we provide 3 rectangles then it should return array of bottom right x co-ordinates' do
+    input_rectangle_1  = [3, 3, 1, 1]
+    input_rectangle_2  = [2, 2, 1, 1]
+    input_rectangle_3  = [1, 1, 1, 1]
+    input_rectangles   = [input_rectangle_1, input_rectangle_2, input_rectangle_3]
+    output_coordinates = [4, 3, 2]
+    expect(Screenshot.bottom_right_x_coordinates(input_rectangles)).to eq(output_coordinates)
+  end
+end
+
+describe 'Bottom right co-ordinates y' do
+  it 'if we provide 1 rectangle then it should return array of bottom right y co-ordinate of the input rectangle' do
+    input_rectangle = [2, 2, 1, 1]
+    input_rectangles = [input_rectangle]
+    output_coordinates = [3]
+    expect(Screenshot.bottom_right_y_coordinates(input_rectangles)).to eq(output_coordinates)
+  end
+
+  it 'if we provide 2 rectangles then it should return array bottom right y co-ordinates' do
+    input_rectangle_1  = [0, 0, 1, 1]
+    input_rectangle_2  = [1, 0, 1, 1]
+    input_rectangles   = [input_rectangle_1, input_rectangle_2]
+    output_coordinates = [1, 1]
+    expect(Screenshot.bottom_right_y_coordinates(input_rectangles)).to eq(output_coordinates)
+  end
+
+  it 'if we provide 3 rectangles then it should return array of bottom right y co-ordinates' do
+    input_rectangle_1  = [3, 3, 1, 1]
+    input_rectangle_2  = [2, 2, 1, 1]
+    input_rectangle_3  = [1, 1, 1, 1]
+    input_rectangles   = [input_rectangle_1, input_rectangle_2, input_rectangle_3]
+    output_coordinates = [4, 3, 2]
+    expect(Screenshot.bottom_right_y_coordinates(input_rectangles)).to eq(output_coordinates)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: screenshot
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Vikas Yaligar
@@ -54,6 +54,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
 description: A library for taking and cropping screenshots of web pages. It uses Selenium
   and chunky_png. It was originally built for taking screenshots in many languages
   for the translations of the Wikimedia VisualEditor user manual, but now it can be
@@ -72,6 +86,7 @@ files:
 - lib/screenshot.rb
 - lib/screenshot/version.rb
 - screenshot.gemspec
+- spec/rectangle_spec.rb
 homepage: https://github.com/amire80/screenshot
 licenses:
 - MIT
@@ -96,4 +111,5 @@ rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: A library for taking and cropping screenshots of web pages.
-test_files: []
+test_files:
+- spec/rectangle_spec.rb