SurfCustomCalabash 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: aa6393311248346a1bfdbb65386455b6299b01b5
-  data.tar.gz: 49d689215e69269719e47378f7298449d1b03070
+SHA256:
+  metadata.gz: 2584314c724fb94ff419dd4513cf5ff7aff9cfa1aa096e57ee788b2f2f8eb14f
+  data.tar.gz: ba9ac40807f121a1dfab4e34b646528cc970c097cb1d32dcb08907231e88f1c7
 SHA512:
-  metadata.gz: fb9273680f9bf8ea1b0aa4fdc0884d40d29dd39cfdf437044b0f46e2c4bfc55c053fa505f86e2704030e311aa131fed91a0e25ee3ed2df2a612cec097f4aacb0
-  data.tar.gz: cb8d7e6e95c75051f0d19d4bec14c3dc7284f4b76be85351d6b2c905c60f696b8bd7be0604005baa49ef58c185f5b9b932799c5bbc502b73bfe94709e38c3c6f
+  metadata.gz: 19a77b8a812760dfc779faf6580e315014ba9628919b6912744d63baab971bd6880edbd56a4c4d0466d57093b302bb2c49dcb42ecb7872e51607d55a6ec22495
+  data.tar.gz: b1e7895eade91dc479e2afffda0feabc4fb3cc639183e0f40e885827eac7a345f15e58f6a8ba1257fd7762019cc1d2c284516311bb8fb4578abb65b69a61cd78

data/SurfCustomCalabash.gemspec

@@ -6,7 +6,7 @@ require "SurfCustomCalabash/version"
 Gem::Specification.new do |spec|
   spec.name          = "SurfCustomCalabash"
   spec.version       = SurfCustomCalabash::VERSION
-  spec.authors       = ["Alexey Hripunov"]
+  spec.authors       = ["Alexey Hripunov", "Igor Tolubaev"]
   spec.email         = ["hripunov@surfstudio.ru"]
 
   spec.summary       = "Custom methods for calabash ios and android"

data/lib/SurfCustomCalabash/CommonMethods.rb

@@ -1,271 +1,365 @@
 require 'rspec/expectations'
 
-module CommonMethods
-
+def enter_text_from_keyboard(text, timeout_duration: 5)
+  wait_for_keyboard(timeout: timeout_duration)
+  keyboard_enter_text(text)
+end
 
-  def enter_text(text)
-    wait_for_keyboard(:timeout=>5)
-    keyboard_enter_text(text)
-  end
+# ----------------------------------------------Custom Taps-----------------------------------------------------------
+# wait element and tap
+def tap_on(element, timeout_duration: 15, sleep_duration: 0.5)
+  wait_element(element, timeout_duration: timeout_duration, sleep_duration: sleep_duration)
+  touch(element)
+end
 
-  # ----------------------------------------------Custom Taps-----------------------------------------------------------
-  # wait element and tap
-  def tap_on(element)
-    wait_for_elements_exist(element, :timeout=>15, :retry_frequency=>5)
-    sleep(0.5)
-    touch(element)
-  end
+def tap_on_text(text, timeout_duration: 15, sleep_duration: 0.5)
+  tap_on("* {text CONTAINS'#{text}'}", timeout_duration: timeout_duration, sleep_duration: sleep_duration)
+end
 
-  def tap_on_text(text)
-    tap_on("* {text CONTAINS'#{text}'}")
+# if element exists - tap, if not - swipe until element exists and tap
+def tap_or_swipe(element, timeout_duration: 30, sleep_duration: 0.5)
+  if element_does_not_exist(element)
+    light_swipe_until_exists('down', element, timeout_duration: timeout_duration)
   end
+  tap_on(element, sleep_duration: sleep_duration)
+end
 
-  # if element exists - tap, if not - swipe until element exists and tap
-  def tap_or_swipe(element)
-    if element_exists(element)
-      sleep(1)
-      touch(element)
-    else
-      until_element_exists(element,:action => lambda{light_swipe('down')},  :timeout => 30)
-      touch(element)
-    end
-  end
+# ----------------------------------------------------Custom Waits----------------------------------------------------
+def wait_element(element, timeout_duration: 15, sleep_duration: 0, retry_frequency: 0.3)
+  wait_for_element_exists(element, timeout: timeout_duration, retry_frequency: retry_frequency)
+  sleep(sleep_duration)
+end
 
-  # ----------------------------------------------------Custom Waits----------------------------------------------------
-  def wait_element(element)
-    wait_for_element_exists(element, :timeout=>15)
-  end
+def wait_no_element(element, timeout_duration: 15, sleep_duration: 0, retry_frequency: 0.3)
+  wait_for_element_does_not_exist(element, timeout: timeout_duration, retry_frequency: retry_frequency)
+  sleep(sleep_duration)
+end
 
-  def wait_no_element(element)
-    wait_for_element_does_not_exist(element, :timeout=>15)
-  end
+# wait trait-element on screen
+def wait_for_screen(timeout_duration: 30, sleep_duration: 0, retry_frequency: 0.3)
+  wait_element(trait, sleep_duration: sleep_duration, timeout_duration: timeout_duration, retry_frequency: retry_frequency)
+end
 
-  # wait trait-element on screen
-  def wait_for_screen
-    wait_for_elements_exist(trait, :timeout=>25)
+# ----------------------------------------------------Custom Swipe----------------------------------------------------
+def strong_swipe_until_not_exist(dir, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_exists(element_destination) do
+      strong_swipe(dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  # ----------------------------------------------------Custom Swipe----------------------------------------------------
-  def strong_swipe_until_not_exist(dir, element_destination)
-    until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{strong_swipe(dir)})
+def normal_swipe_until_not_exist(dir, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_exists(element_destination) do
+      normal_swipe(dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def normal_swipe_until_not_exist(dir, element_destination)
-    until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{normal_swipe(dir)})
+def light_swipe_until_not_exist(dir, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_exists(element_destination) do
+      light_swipe(dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def light_swipe_until_not_exist(dir, element_destination)
-    until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{light_swipe( dir)})
+def strong_swipe_until_exists(dir, element_destination, sleep_duration: 0.5, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_does_not_exist(element_destination) do
+      strong_swipe(dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def strong_swipe_until_exists(dir, element_destination)
-    until_element_exists(element_destination,
-                         :action =>  lambda{strong_swipe( dir)})
+def normal_swipe_until_exists(dir, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_does_not_exist(element_destination) do
+      normal_swipe(dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def normal_swipe_until_exists(dir, element_destination)
-    until_element_exists(element_destination,
-                         :action =>  lambda{normal_swipe( dir); sleep(2)}, :timeout=>40)
+def light_swipe_until_exists(dir, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_does_not_exist(element_destination) do
+      light_swipe(dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def light_swipe_until_exists(dir, element_destination)
-    until_element_exists(element_destination,
-                         :action =>  lambda{light_swipe( dir); sleep(2)}, :timeout=>60)
-
+def strong_swipe_element_until_exists(dir, element, element_destination, sleep_duration: 0.5, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_does_not_exist(element_destination) do
+      strong_swipe_element(element, dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def strong_swipe_element_until_exists(dir, element, element_destination)
-    until_element_exists(element_destination,
-                         :action =>  lambda{strong_swipe_element(element, dir)})
+def normal_swipe_element_until_exists(dir, element, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_does_not_exist(element_destination) do
+      normal_swipe_element(element, dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def light_swipe_element_until_exists(dir, element, element_destination)
-    until_element_exists(element_destination,
-                         :action =>  lambda{light_swipe_element(element, dir)}, :timeout=>70)
+def light_swipe_element_until_exists(dir, element, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_does_not_exist(element_destination) do
+      light_swipe_element(element, dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def strong_swipe_element_until_not_exists(dir, element, element_destination)
-    until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{pan(element, dir)})
+def strong_swipe_element_until_not_exists(dir, element, element_destination, sleep_duration: 0.5, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_exists(element_destination) do
+      strong_swipe_element(element, dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def light_swipe_element_until_not_exists(dir, element, element_destination)
-    until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{light_swipe_element(element, dir)}, :timeout=>70)
+def normal_swipe_element_until_not_exists(dir, element, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_exists(element_destination) do
+      normal_swipe_element(element, dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def swipe_to_text(dir, text)
-    sleep(1)
-    if dir == 'вверх'
-      until_element_exists("* {text CONTAINS'#{text}'}", :action =>  lambda{light_swipe('up'); sleep(1)}, :timeout => 60)
-    elsif dir == 'вниз'
-      until_element_exists("* {text CONTAINS'#{text}'}", :action =>  lambda{light_swipe('down'); sleep(1.5)}, :timeout => 60)
+def light_swipe_element_until_not_exists(dir, element, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_exists(element_destination) do
+      light_swipe_element(element, dir, sleep_duration: sleep_duration)
     end
   end
+end
 
-  # Drag element from one place to place of other element
-  def drag_element(element_from , element_to)
-    x_from = get_coordinate_x(element_from)
-    y_from = get_coordinate_y(element_from)
+def swipe_to_text(dir, text, sleep_duration:0.2, timeout_duration: 30)
+  light_swipe_until_exists(dir, "* {text CONTAINS'#{text}'}", sleep_duration: sleep_duration, timeout_duration: timeout_duration)
+end
 
-    x_to = get_coordinate_x(element_to)
-    y_to = get_coordinate_y(element_to)
-    drag_coordinates(x_from, y_from, x_to, y_to, 10, 0.5, 0.5)
+# -------------------------------------------------Asserts------------------------------------------------------------
+def assert_eql_with_rescue(element1, element2)
+  begin
+    expect(element1).to eq(element2)
+    true
+  rescue RSpec::Expectations::ExpectationNotMetError
+    false
   end
+end
 
-  # -------------------------------------------------Asserts------------------------------------------------------------
-  def assert_eql_with_rescue(element1, element2)
-    begin
-      expect(element1).to eq(element2)
-      true
-    rescue Exception => e
-      false
-    end
-  end
+def assert_eql(element1, element2)
+  expect(element1).to eq(element2)
+end
 
-  def assert_eql(element1, element2)
-    expect(element1).to eq(element2)
-  end
+def assert_not_eql(element1, element2)
+  expect(element1).not_to eql(element2)
+end
 
-  def assert_not_eql(element1, element2)
-    expect(element1).not_to eql(element2)
-  end
+def assert_true(element)
+  expect(element).to be true
+end
 
-  def assert_true(element)
-    expect(element).to be true
-  end
+def assert_false(element)
+  expect(element).to be false
+end
 
-  def assert_false(element)
-    expect(element).to be false
-  end
+def assert_nil(element)
+  expect(element).to be_nil
+end
 
-  def assert_nil(element)
-    expect(element).to be_nil
-  end
+# ------------------------------------------Generate String-----------------------------------------------------------
+def get_random_num_string(length)
+  source = (0..9).to_a
+  key = ""
+  length.times{ key += source[rand(source.size)].to_s }
+  return key
+end
 
-  # ------------------------------------------Generate String-----------------------------------------------------------
-  def get_random_num_string(length)
-    source=(0..9).to_a
-    key=""
-    length.times{ key += source[rand(source.size)].to_s }
-    return key
-  end
+def get_random_text_string(length)
+  source = ("a".."z").to_a
+  key = ""
+  length.times{ key += source[rand(source.size)].to_s }
+  return key
+end
 
-  def get_random_text_string(length)
-    source=("a".."z").to_a
-    key=""
-    length.times{ key += source[rand(source.size)].to_s }
-    return key
-  end
+def get_random_email
+  return get_random_text_string(7) + "@" + get_random_text_string(2) + ".test"
+end
 
-  def get_random_email
-    return get_random_text_string(7) + "@" + get_random_text_string(2) + ".test"
-  end
+# get first digital from string
+def extract_num_from_str(text)
+  text.gsub!(/[[:space:]]/, '')
+  num = text.scan(/\d+/).first.nil? ? "0" : text.scan(/\d+/).first
+  p num
+end
 
-  # get first digital from string
-  def extract_num_from_str(text)
-    text.gsub!(/[[:space:]]/, '')
-    num = text.scan(/\d+/).first.nil? ? "0" : text.scan(/\d+/).first
-    p num
-  end
+# get last digital from string
+def extract_last_num_from_str(text)
+  text.gsub!(/[[:space:]]/, '')
+  num = text.scan(/\d+/).first.nil? ? "0" : text.scan(/\d+/).last
+  p num
+end
 
-  # get text from first element
-  def remember(element)
-    wait_for_element_exists(element, :timeout => 5)
-    sleep(1.5)
-    name = query(element)
-    save_name = name.first['text']
-    puts(save_name)
-    return save_name
-  end
+# get text from first element
+def remember(element, sleep_duration: 1, timeout_duration: 5)
+  wait_element(element, sleep_duration: sleep_duration, timeout_duration: timeout_duration)
+  name = query(element)
+  save_name = name.first['text']
+  puts(save_name)
+  return save_name
+end
 
-  # get text from last element
-  def remember_last_text(element)
-    wait_for_element_exists(element, :timeout => 5)
-    sleep(1.5)
-    name = query(element)
-    save_name = name.last['text']
-    puts(save_name)
-    return save_name
-  end
+# get text from last element
+def remember_last_text(element, sleep_duration: 1, timeout_duration: 5)
+  wait_element(element, sleep_duration: sleep_duration, timeout_duration: timeout_duration)
+  name = query(element)
+  save_name = name.last['text']
+  puts(save_name)
+  return save_name
+end
 
-  # wait text
-  def check_text(text)
-    wait_for_element_exists("* {text CONTAINS'#{text}'}", :timeout => 5, :retry_frequency => 2)
-  end
+# wait text
+def check_text(text, sleep_duration: 0, timeout_duration: 5)
+  wait_element("* {text CONTAINS'#{text}'}", sleep_duration: sleep_duration, timeout_duration: timeout_duration)
+end
 
-  def no_check_text(text)
-    wait_for_element_does_not_exist("* {text CONTAINS'#{text}'}", :timeout => 5, :retry_frequency => 5)
-  end
+def no_check_text(text, timeout_duration: 5)
+  warn "Deprecated with 0.1.9 version SurfCustomCalabash, use check_no_text intead"
+  check_no_text(text, timeout_duration: timeout_duration)
+end
 
-  # get element's coordinates
-  def get_coordinate_x(element)
-    el = query(element)
-    coordinate = el[0]['rect']['center_x']
-    # puts(coordinate)
-    return coordinate.to_i
-  end
+def check_no_text(text, sleep_duration: 0, timeout_duration: 5)
+  wait_no_element("* {text CONTAINS'#{text}'}", sleep_duration: sleep_duration, timeout_duration: timeout_duration)
+end
 
-  def get_coordinate_y(element)
-    el = query(element)
-    coordinate = el[0]['rect']['center_y']
-    # puts(coordinate)
-    return coordinate.to_i
-  end
+# get element's coordinates
+def get_coordinate_x(element)
+  el = query(element)
+  coordinate = el[0]['rect']['center_x']
+  return coordinate.to_i
+end
+
+def get_coordinate_y(element)
+  el = query(element)
+  coordinate = el[0]['rect']['center_y']
+  return coordinate.to_i
+end
 
+# Drag element from one place to place of other element
+def drag_element(element_from , element_to)
+  x_from = get_coordinate_x(element_from)
+  y_from = get_coordinate_y(element_from)
 
-  # if elements cross - return true, if not - false
-  def cross_coordinate(element_front, element_behind)
-    cross = false
+  x_to = get_coordinate_x(element_to)
+  y_to = get_coordinate_y(element_to)
+  drag_coordinates(x_from, y_from, x_to, y_to, 10, 0.5, 0.5)
+end
+
+# if elements cross - return true, if not - false
+def cross_coordinate(element_front, element_behind, delta: 100)
+  cross = false
 
-    if element_exists(element_front) && element_exists(element_behind)
-      coordinate_front = get_coordinate_y(element_front)
-      coordinate_behind = get_coordinate_y(element_behind)
-      delta = 100
+  if element_exists(element_front) && element_exists(element_behind)
+    coordinate_front = get_coordinate_y(element_front)
+    coordinate_behind = get_coordinate_y(element_behind)
 
-      if coordinate_front < coordinate_behind + delta
-        cross = true
-      else
-        cross = false
-      end
+    if coordinate_front < coordinate_behind + delta
+      cross = true
+    else
+      cross = false
     end
-    # puts(cross)
-    return cross
   end
+  # puts(cross)
+  return cross
+end
 
-  # swipe down if two element cross
-  def swipe_if_cross(element_front, element_behind)
-    if cross_coordinate(element_front, element_behind)
-      light_swipe("down")
+# swipe down if two element cross
+def swipe_if_cross(element_front, element_behind, timeout_duration: 30, sleep_duration: 1)
+  Timeout::timeout(timeout_duration) do
+    while cross_coordinate(element_front, element_behind) do
+      light_swipe("down", sleep_duration: sleep_duration)
     end
-    sleep(1)
   end
+end
 
-  # if apps support two localization, this method check exists text in different locations
-  def text_with_locale(text_locale1, text_locale2)
-    if element_exists("* {text BEGINSWITH '#{text_locale2}'}")
-      puts (element_exists("* {text BEGINSWITH '#{text_locale2}'}"))
-      return "* {text BEGINSWITH '#{text_locale2}'}"
-    elsif element_exists("* {text BEGINSWITH '#{text_locale1}'}")
-      puts(element_exists("* {text BEGINSWITH '#{text_locale1}'}"))
-      return "* {text BEGINSWITH '#{text_locale1}'}"
+# --------------------------------------------------Localization------------------------------------------------------
+# get locale apps - Ru or Eng
+# parameter - element with text
+def get_app_location(element, sleep_duration: 1)
+  sleep(sleep_duration)
+  if element_exists(element)
+    text_element = remember(element)
+    if check_cyrillic(text_element)
+      locale = 'RUS'
     else
-      return ("No such query!")
+      locale = 'ENG'
     end
+  else
+    p "Fail localization"
+    locale = ''
   end
+  p locale
+  return locale
+end
+
+# check cyrillic symbols in string
+def check_cyrillic(str)
+  regexp = /\p{Cyrillic}+.*?\.?/
+  if str.match(regexp).nil?
+    return false
+  else
+    return true
+  end
+end
+
+# if apps support two localization, this method check exists text in different locations
+def text_with_locale(text_locale1, text_locale2, sleep_duration: 1)
+  sleep(sleep_duration)
+
+  # $locale is global variables
+  # $locale setup in first app launch
+  if !$locale.nil?
+    if check_cyrillic(text_locale1)
+      rus_locale = "* {text CONTAINS '#{text_locale1}'}"
+      eng_locale = "* {text CONTAINS '#{text_locale2}'}"
+    elsif check_cyrillic(text_locale2)
+      rus_locale = "* {text CONTAINS '#{text_locale2}'}"
+      eng_locale = "* {text CONTAINS '#{text_locale1}'}"
+    end
 
-  # if apps support two localization, this method check exists label in different locations
-  def label_with_locale(mark1, mark2)
-    if element_exists("* marked:'#{mark1}'")
-      return "* marked:'#{mark1}'"
-    elsif element_exists("* marked:'#{mark2}'")
-      return "* marked:'#{mark2}'"
+    if $locale == "RUS"
+      return rus_locale
+    elsif $locale == "ENG"
+      return eng_locale
+    end
+  else
+    # if $locale is not Rus or Eng
+    # wait element on screen with text_locale1 or text_locale2
+    locale_el1 = "* {text CONTAINS '#{text_locale1}'}"
+    locale_el2 = "* {text CONTAINS '#{text_locale2}'}"
+
+    if element_exists(locale_el1)
+      return locale_el1
+    elsif element_exists(locale_el2)
+      return locale_el2
     else
-      return false
+      return ("No such query!")
     end
   end
+end
 
+# if apps support two localization, this method check exists label in different locations
+def label_with_locale(mark1, mark2)
+  if element_exists("* marked:'#{mark1}'")
+    return "* marked:'#{mark1}'"
+  elsif element_exists("* marked:'#{mark2}'")
+    return "* marked:'#{mark2}'"
+  else
+    return false
+  end
 end
+

data/lib/SurfCustomCalabash/DroidMethods.rb

@@ -1,90 +1,123 @@
 require 'calabash-android'
 require 'SurfCustomCalabash/CommonMethods'
 
-module DroidMethods
-  include Calabash::Android::Operations
-  include CommonMethods
-
-  def close_keyboard
-    if keyboard_visible?
-      hide_soft_keyboard
-    end
+def close_keyboard
+  if keyboard_visible?
+    hide_soft_keyboard
   end
+end
 
-  #----------------------------------------------Custom Android Swipe---------------------------------------------------
-  def strong_swipe(dr)
-    if dr == "up"
-      perform_action('drag', 50, 50, 15, 75, 4)
-    elsif dr == "down"
-      perform_action('drag', 50, 50, 60, 5, 1)
-    elsif dr == "left"
-      perform_action('drag', 90, 0, 50, 50, 10)
-    elsif dr == "right"
-      perform_action('drag', 0, 90, 50, 50, 10)
-    end
-  end
+def submit_keyboard
+  press_user_action_button
+end
 
-  def normal_swipe(dr)
-    if dr == "up"
-      perform_action('drag', 50, 50, 45, 80, 10)
-    elsif dr == "down"
-      perform_action('drag', 50, 50, 80, 45, 10)
-    end
+#----------------------------------------------Custom Android Swipe---------------------------------------------------
+def strong_swipe(dr, sleep_duration: 0)
+  if dr == "up"
+    perform_action('drag', 50, 50, 15, 75, 25)
+  elsif dr == "down"
+    perform_action('drag', 50, 50, 75, 15, 25)
+  elsif dr == "left"
+    perform_action('drag', 90, 0, 50, 50, 10)
+  elsif dr == "right"
+    perform_action('drag', 0, 90, 50, 50, 10)
+  else
+    p "Use direction 'up', 'down', 'left', 'right'"
   end
+  sleep(sleep_duration)
+end
 
-  def light_swipe(dr)
-    if dr == "down"
-      perform_action('drag', 50, 50, 80, 70, 10)
-    elsif dr == "up"
-      perform_action('drag', 50, 50, 70, 80, 5)
-    end
+def normal_swipe(dr, sleep_duration: 0)
+  if dr == "up"
+    perform_action('drag', 50, 50, 15, 45, 25)
+  elsif dr == "down"
+    perform_action('drag', 50, 50, 45, 15, 25)
+  elsif dr == "left"
+    perform_action('drag', 50, 0, 50, 50, 10)
+  elsif dr == "right"
+    perform_action('drag', 0, 50, 50, 50, 10)
+  else
+    p "Use direction 'up', 'down', 'left', 'right'"
   end
+  sleep(sleep_duration)
+end
 
-  def strong_swipe_element(element, dir)
-    if dir == 'left'
-      flick(element, :left)
-    elsif  dir == 'right'
-      flick(element, :right)
-    elsif dir == 'down'
-      flick(element, :up)
-    elsif dir == 'up'
-      flick(element, :down)
-    end
+def light_swipe(dr, sleep_duration: 0)
+  if dr == "up"
+    perform_action('drag', 50, 50, 15, 30, 25)
+  elsif dr == "down"
+    perform_action('drag', 50, 50, 30, 15, 25)
+  elsif dr == "left"
+    perform_action('drag', 25, 0, 50, 50, 10)
+  elsif dr == "right"
+    perform_action('drag', 0, 25, 50, 50, 10)
+  else
+    p "Use direction 'up', 'down', 'left', 'right'"
   end
+  sleep(sleep_duration)
+end
 
-  def normal_swipe_element(element, dir)
-    if dir == 'left'
-      pan(element, :left)
-    elsif  dir == 'right'
-      pan(element, :right)
-    elsif dir == 'down'
-      pan(element, :up)
-    elsif dir == 'up'
-      pan(element, :down)
-    end
+def strong_swipe_element(element, dir, sleep_duration: 0)
+  if dir == 'left'
+    flick(element, :left)
+  elsif  dir == 'right'
+    flick(element, :right)
+  elsif dir == 'down'
+    flick(element, :up)
+  elsif dir == 'up'
+    flick(element, :down)
+  else
+    p "Use direction 'up', 'down', 'left', 'right'"
   end
+  sleep(sleep_duration)
+end
 
-  def light_swipe_element(element, dir)
-    if dir == 'left'
-      pan(element, :left)
-    elsif  dir == 'right'
-      pan(element, :right)
-    elsif dir == 'down'
-      pan(element, :up)
-    elsif dir == 'up'
-      pan(element, :down)
-    end
+def normal_swipe_element(element, dir, sleep_duration: 0)
+  if dir == 'left'
+    pan(element, :left)
+  elsif  dir == 'right'
+    pan(element, :right)
+  elsif dir == 'down'
+    pan(element, :up)
+  elsif dir == 'up'
+    pan(element, :down)
+  else
+    p "Use direction 'up', 'down', 'left', 'right'"
   end
+  sleep(sleep_duration)
+end
 
-  # swipe trait-element from element_destination
-  def light_swipe_trait_until_exists(dir, element_destination)
-    until_element_exists(element_destination,
-                         :action =>  lambda{light_swipe_element(trait, dir)}, :timeout=>50)
+def light_swipe_element(element, dir, sleep_duration: 0)
+  if dir == 'left'
+    pan(element, :left)
+  elsif  dir == 'right'
+    pan(element, :right)
+  elsif dir == 'down'
+    pan(element, :up)
+  elsif dir == 'up'
+    pan(element, :down)
+  else
+    p "Use direction 'up', 'down', 'left', 'right'"
   end
+  sleep(sleep_duration)
+end
 
-  # pull-to-refresh screen
-  def ptr
-    perform_action('drag', 50, 50, 15, 75, 4)
-  end
+# swipe trait-element from element_destination
+def light_swipe_trait_until_exists(dir, element_destination, sleep_duration: 0, timeout_duration: 30)
+  light_swipe_element_until_exists(dir, trait, element_destination, sleep_duration: sleep_duration, timeout_duration: timeout_duration)
+end
+
+# pull-to-refresh screen
+def ptr
+  perform_action('drag', 50, 50, 15, 75, 4)
+end
+
+# strong swipe to up of the screen
+def swipe_to_up
+  5.times {perform_action('drag', 50, 50, 15, 70, 1)}
+end
 
+# strong swipe to down of the screen
+def swipe_to_down
+  5.times {perform_action('drag', 50, 50, 60, 10, 1)}
 end

data/lib/SurfCustomCalabash/IosMethods.rb

@@ -1,89 +1,134 @@
 require 'calabash-cucumber/ibase'
 require 'SurfCustomCalabash/CommonMethods'
 
-module IosMethods
-  include CommonMethods
-
-  #----------------------------------------------Custom Swipe iOS-------------------------------------------------------
-  def strong_swipe(dir)
-    if dir == 'left'
-      swipe :left,  force: :strong
-    elsif dir == 'right'
-      swipe :right,  force: :strong
-    elsif dir == 'up'
-      swipe :down,  force: :strong
-    elsif dir == 'down'
-      swipe :up,  force: :strong
-    end
+# close keyboard with a swipe of the screen
+def close_keyboard
+  if keyboard_visible?
+    pan_coordinates({x: 100, y: 150}, {x: 100, y: 250})
   end
+end
 
-  def normal_swipe(dir)
-    if dir == 'left'
-      swipe :left,  force: :normal
-    elsif dir == 'right'
-      swipe :right,  force: :normal
-    elsif dir == 'up'
-      swipe :down,  force: :normal
-    elsif dir == 'down'
-      swipe :up,  force: :normal
+# tap on Done on keyboard
+def submit_keyboard
+  if keyboard_visible?
+    if element_exists("* marked:'Toolbar Done Button'")
+      touch("* marked:'Toolbar Done Button'")
+    else
+      tap_keyboard_action_key
     end
   end
+end
 
-  def light_swipe(dir)
-    if dir == 'left'
-      swipe :left,  force: :light
-    elsif dir == 'right'
-      swipe :right,  force: :light
-    elsif dir == 'up'
-      swipe :down,  force: :light
-    elsif dir == 'down'
-      swipe :up,  force: :light
-    end
+#----------------------------------------------Custom Swipe iOS-------------------------------------------------------
+def strong_swipe(dir, sleep_duration: 0)
+  if dir == 'left'
+    swipe :left,  force: :strong
+  elsif dir == 'right'
+    swipe :right,  force: :strong
+  elsif dir == 'up'
+    swipe :down,  force: :strong
+  elsif dir == 'down'
+    swipe :up,  force: :strong
+  else
+    p "Use direction 'up', 'down', 'left', 'right'"
   end
+  sleep(sleep_duration)
+end
 
-  def strong_swipe_element(element, dir)
-    if dir == 'left'
-      swipe :left, :query => element, force: :strong
-    elsif dir == 'right'
-      swipe :right, :query => element, force: :strong
-    elsif dir == 'up'
-      swipe :down, :query => element, force: :strong
-    elsif dir == 'down'
-      swipe :up, :query => element, force: :strong
-    end
+def normal_swipe(dir, sleep_duration: 0)
+  if dir == 'left'
+    swipe :left,  force: :normal
+  elsif dir == 'right'
+    swipe :right,  force: :normal
+  elsif dir == 'up'
+    swipe :down,  force: :normal
+  elsif dir == 'down'
+    swipe :up,  force: :normal
+  else
+    p "Use direction 'up', 'down', 'left', 'right'"
   end
+  sleep(sleep_duration)
+end
 
-  def normal_swipe_element(element, dir)
-    if dir == 'left'
-      swipe :left, :query => element, force: :normal
-    elsif dir == 'right'
-      swipe :right, :query => element, force: :normal
-    elsif dir == 'up'
-      swipe :down, :query => element, force: :normal
-    elsif dir == 'down'
-      swipe :up, :query => element, force: :normal
-    end
+def light_swipe(dir, sleep_duration: 0)
+  if dir == 'left'
+    swipe :left,  force: :light
+  elsif dir == 'right'
+    swipe :right,  force: :light
+  elsif dir == 'up'
+    swipe :down,  force: :light
+  elsif dir == 'down'
+    swipe :up,  force: :light
+  else
+    p "Use direction 'up', 'down', 'left', 'right'"
   end
+  sleep(sleep_duration)
+end
 
-  def light_swipe_element(element, dir)
-    if dir == 'left'
-      swipe :left, :query => element, force: :light
-    elsif dir == 'right'
-      swipe :right, :query => element, force: :light
-    elsif dir == 'up'
-      swipe :down, :query => element, force: :light
-    elsif dir == 'down'
-      swipe :up, :query => element, force: :light
-    end
+def strong_swipe_element(element, dir, sleep_duration: 0)
+  if dir == 'left'
+    swipe :left, :query => element, force: :strong
+  elsif dir == 'right'
+    swipe :right, :query => element, force: :strong
+  elsif dir == 'up'
+    swipe :down, :query => element, force: :strong
+  elsif dir == 'down'
+    swipe :up, :query => element, force: :strong
+  else
+    p "Use direction 'up', 'down', 'left', 'right'"
   end
+  sleep(sleep_duration)
+end
 
-  def light_swipe_trait_until_exists(dir, element_destination)
-    normal_swipe_until_exists(dir, element_destination)
+def normal_swipe_element(element, dir, sleep_duration: 0)
+  if dir == 'left'
+    swipe :left, :query => element, force: :normal
+  elsif dir == 'right'
+    swipe :right, :query => element, force: :normal
+  elsif dir == 'up'
+    swipe :down, :query => element, force: :normal
+  elsif dir == 'down'
+    swipe :up, :query => element, force: :normal
+  else
+    p "Use direction 'up', 'down', 'left', 'right'"
   end
+  sleep(sleep_duration)
+end
 
-  # pull-to-refresh screen
-  def ptr
-    swipe(:down, :offset => {:x => 0, :y => -200})
+def light_swipe_element(element, dir, sleep_duration: 0)
+  if dir == 'left'
+    swipe :left, :query => element, force: :light
+  elsif dir == 'right'
+    swipe :right, :query => element, force: :light
+  elsif dir == 'up'
+    swipe :down, :query => element, force: :light
+  elsif dir == 'down'
+    swipe :up, :query => element, force: :light
+  else
+    p "Use direction 'up', 'down', 'left', 'right'"
   end
+  sleep(sleep_duration)
+end
+
+def light_swipe_trait_until_exists(dir, element_destination, sleep_duration: 0, timeout_duration: 30)
+  normal_swipe_until_exists(dir, element_destination, sleep_duration: sleep_duration, timeout_duration: timeout_duration)
+end
+
+# pull-to-refresh screen
+def ptr
+  pan_coordinates({x: 50, y: 100}, {x: 50, y: 600})
+end
+
+# touch on status bar -> scroll to up of the screen
+def swipe_to_up
+  touch(nil, :offset => {:x => 0, :y => 0})
+end
+
+# strong swipe to down of the screen
+def swipe_to_down
+  10.times {swipe :up,  force: :strong}
+end
 
+def back_swipe
+  pan_coordinates({x:0, y:300}, {x:500, y:300})
 end

data/lib/SurfCustomCalabash/version.rb

@@ -1,3 +1,3 @@
 module SurfCustomCalabash
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: SurfCustomCalabash
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Alexey Hripunov
-autorequire: 
+- Igor Tolubaev
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-03-18 00:00:00.000000000 Z
+date: 2020-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,7 +82,7 @@ metadata:
   homepage_uri: https://github.com/alexeyhripunov/SurfCustomCalabash
   source_code_uri: https://github.com/alexeyhripunov/SurfCustomCalabash
   changelog_uri: https://github.com/alexeyhripunov/SurfCustomCalabash
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -96,9 +97,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.1
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.7.6
+signing_key:
 specification_version: 4
 summary: Custom methods for calabash ios and android
 test_files: []