locatine 0.01659 → 0.01811

data/lib/locatine/search.rb

@@ -4,21 +4,22 @@ require 'fileutils'
 require 'chromedriver-helper'
 
 # Internal requires
-require 'locatine/merge'
-require 'locatine/public'
-require 'locatine/helpers'
-require 'locatine/file_work'
-require 'locatine/highlight'
-require 'locatine/data_logic'
-require 'locatine/find_logic'
-require 'locatine/find_by_css'
-require 'locatine/dialog_logic'
-require 'locatine/find_by_magic'
-require 'locatine/find_by_guess'
-require 'locatine/data_generate'
-require 'locatine/dialog_actions'
-require 'locatine/xpath_generator'
-require 'locatine/find_by_locator'
+require 'locatine/for_search/merge'
+require 'locatine/for_search/public'
+require 'locatine/for_search/saying'
+require 'locatine/for_search/helpers'
+require 'locatine/for_search/file_work'
+require 'locatine/for_search/highlight'
+require 'locatine/for_search/data_logic'
+require 'locatine/for_search/find_logic'
+require 'locatine/for_search/find_by_css'
+require 'locatine/for_search/dialog_logic'
+require 'locatine/for_search/find_by_magic'
+require 'locatine/for_search/find_by_guess'
+require 'locatine/for_search/data_generate'
+require 'locatine/for_search/listening'
+require 'locatine/for_search/xpath_generator'
+require 'locatine/for_search/find_by_locator'
 
 module Locatine
   ##
@@ -26,21 +27,22 @@ module Locatine
   #
   # Locatine can search.
   class Search
-    include Locatine::Merge
-    include Locatine::Public
-    include Locatine::Helpers
-    include Locatine::FileWork
-    include Locatine::DataLogic
-    include Locatine::FindLogic
-    include Locatine::Highlight
-    include Locatine::FindByCss
-    include Locatine::FindByMagic
-    include Locatine::DialogLogic
-    include Locatine::FindByGuess
-    include Locatine::DataGenerate
-    include Locatine::FindByLocator
-    include Locatine::DialogActions
-    include Locatine::XpathGenerator
+    include Locatine::ForSearch::Merge
+    include Locatine::ForSearch::Public
+    include Locatine::ForSearch::Saying
+    include Locatine::ForSearch::Helpers
+    include Locatine::ForSearch::FileWork
+    include Locatine::ForSearch::DataLogic
+    include Locatine::ForSearch::Listening
+    include Locatine::ForSearch::FindLogic
+    include Locatine::ForSearch::Highlight
+    include Locatine::ForSearch::FindByCss
+    include Locatine::ForSearch::FindByMagic
+    include Locatine::ForSearch::DialogLogic
+    include Locatine::ForSearch::FindByGuess
+    include Locatine::ForSearch::DataGenerate
+    include Locatine::ForSearch::FindByLocator
+    include Locatine::ForSearch::XpathGenerator
 
     attr_accessor :data,
                   :depth,

data/lib/locatine/version.rb

@@ -1,6 +1,6 @@
 module Locatine
   # constants here...
-  VERSION = '0.01659'.freeze
+  VERSION = '0.01811'.freeze
   NAME = 'locatine'.freeze
   HOME = if File.readable?("#{Dir.pwd}/lib/#{Locatine::NAME}")
            "#{Dir.pwd}/lib/#{Locatine::NAME}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: locatine
 version: !ruby/object:Gem::Version
-  version: '0.01659'
+  version: '0.01811'
 platform: ruby
 authors:
 - Sergei Seleznev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-24 00:00:00.000000000 Z
+date: 2019-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -124,25 +124,27 @@ files:
 - lib/locatine/app/popup.css
 - lib/locatine/app/popup.html
 - lib/locatine/app/popup.js
-- lib/locatine/data_generate.rb
-- lib/locatine/data_logic.rb
-- lib/locatine/dialog_actions.rb
-- lib/locatine/dialog_logic.rb
-- lib/locatine/file_work.rb
-- lib/locatine/find_by_css.rb
-- lib/locatine/find_by_guess.rb
-- lib/locatine/find_by_locator.rb
-- lib/locatine/find_by_magic.rb
-- lib/locatine/find_logic.rb
-- lib/locatine/helpers.rb
-- lib/locatine/highlight.rb
+- lib/locatine/for_search.rb
+- lib/locatine/for_search/data_generate.rb
+- lib/locatine/for_search/data_logic.rb
+- lib/locatine/for_search/dialog_logic.rb
+- lib/locatine/for_search/file_work.rb
+- lib/locatine/for_search/find_by_css.rb
+- lib/locatine/for_search/find_by_guess.rb
+- lib/locatine/for_search/find_by_locator.rb
+- lib/locatine/for_search/find_by_magic.rb
+- lib/locatine/for_search/find_logic.rb
+- lib/locatine/for_search/helpers.rb
+- lib/locatine/for_search/highlight.rb
+- lib/locatine/for_search/listening.rb
+- lib/locatine/for_search/merge.rb
+- lib/locatine/for_search/public.rb
+- lib/locatine/for_search/saying.rb
+- lib/locatine/for_search/xpath_generator.rb
 - lib/locatine/large_scripts/css.js
 - lib/locatine/large_scripts/dimensions.js
-- lib/locatine/merge.rb
-- lib/locatine/public.rb
 - lib/locatine/search.rb
 - lib/locatine/version.rb
-- lib/locatine/xpath_generator.rb
 homepage: https://github.com/sseleznevqa/locatine
 licenses:
 - MIT

data/lib/locatine/data_generate.rb

@@ -1,98 +0,0 @@
-module Locatine
-  ##
-  # Collecting data of element and making it dynamic
-  module DataGenerate
-    private
-
-    def real_text_of(element)
-      element.text == element.inner_html ? element.text : ''
-    end
-
-    def mesure(element)
-      xy = element.location
-      wh = element.size
-      return xy.x, xy.y, wh.width, wh.height
-    end
-
-    def get_dynamic_tag(element, vars)
-      tag = element.tag_name
-      tag = "\#{tag}" if vars[:tag] == tag
-      push_hash('tag', tag, 'tag')
-    end
-
-    def get_dynamic_text(element, vars)
-      attrs = []
-      real_text_of(element).split(/['" ]/).each do |word|
-        final = if !vars[:text].to_s.strip.empty?
-                  word.gsub(vars[:text].to_s, "\#{text}")
-                else
-                  word
-                end
-        attrs.push push_hash('text', final, 'text') unless final.empty?
-      end
-      attrs
-    end
-
-    def process_dimension(name, value, vars)
-      s_name = name.to_s
-      value = value.to_s.gsub(vars[name], "\#{#{s_name}}") if vars[name]
-      value
-    end
-
-    def processed_dimensions(element, vars)
-      x, y, width, height = mesure(element)
-      x = process_dimension(:x, x, vars)
-      y = process_dimension(:y, y, vars)
-      width = process_dimension(:width, width, vars)
-      height = process_dimension(:height, height, vars)
-      return x, y, width, height
-    end
-
-    def get_dimensions(element, vars)
-      resolution = window_size
-      x, y, w, h = processed_dimensions(element, vars)
-      push_hash(resolution, "#{x}*#{y}*#{w}*#{h}", 'dimensions')
-    end
-
-    def hash_by_style(style, value, vars)
-      value.gsub!(vars[style.to_sym], "\#{#{style}}") if vars[style.to_sym]
-      push_hash(style, value, 'css')
-    end
-
-    def get_raw_css(element)
-      test_script = 'return typeof(arguments[0])'
-      ok = engine.execute_script(test_script, element) == 'object'
-      script = 'return getComputedStyle(arguments[0]).cssText'
-      return engine.execute_script(script, element) if ok
-    end
-
-    def get_dynamic_css(element, vars)
-      attrs = []
-      raw = get_raw_css(element)
-      if raw
-        styles = css_text_to_hash(get_raw_css(element))
-        (styles.to_a - @default_styles).to_h.each_pair do |style, value|
-          hash = hash_by_style(style, value, vars)
-          attrs.push(hash) if hash
-        end
-      end
-      attrs
-    end
-
-    ##
-    # Collecting attributes of the element
-    def get_attributes(element)
-      attributes = element.attributes
-      array = []
-      attributes.each_pair do |name, value|
-        next if name.to_s == 'locatineclass' # Should never happen
-
-        value.split(/['" ]/).reject(&:empty?).uniq.each do |part|
-          array.push('name' => name.to_s, 'type' => 'attribute',
-                     'value' => part)
-        end
-      end
-      array
-    end
-  end
-end

data/lib/locatine/data_logic.rb

@@ -1,53 +0,0 @@
-module Locatine
-  ##
-  # Logic of collecting data of the element
-  module DataLogic
-    private
-
-    def get_dynamic_attributes(element, vars)
-      attrs = []
-      get_attributes(element).each do |hash|
-        if vars[hash['name'].to_sym]
-          hash['value'].gsub!(vars[hash['name'].to_sym], "\#{#{hash['name']}}")
-        end
-        attrs.push hash
-      end
-      attrs
-    end
-
-    ##
-    # Generating array of hashes representing data of the element
-    def get_element_info(element, vars, depth)
-      attrs = get_dynamic_attributes(element, vars)
-      attrs.push get_dynamic_tag(element, vars)
-      attrs += get_dynamic_text(element, vars)
-      attrs += get_dynamic_css(element, vars) if depth.to_i.zero? && visual?
-      attrs.push get_dimensions(element, vars) if depth.to_i.zero? && visual?
-      attrs
-    end
-
-    ##
-    # Generating data for group of elements
-    def generate_data(result, vars)
-      family = {}
-      result.each do |item|
-        family = get_commons(get_family_info(item, vars), family)
-      end
-      family
-    end
-
-    ##
-    # Getting element\\parents information
-    def get_family_info(element, vars)
-      i = 0
-      attributes = {}
-      while i != @depth
-        attributes[i.to_s] = get_element_info(element, vars, i)
-        i += 1
-        element = element.parent
-        i = @depth unless element.exists?
-      end
-      attributes
-    end
-  end
-end

data/lib/locatine/dialog_actions.rb

@@ -1,71 +0,0 @@
-module Locatine
-  ##
-  # Simple actions about communicating with chrome extension (and user)
-  module DialogActions
-    private
-
-    ##
-    # Setting attribute of locatine div (way to communicate)
-    def send_to_app(what, value, bro = engine)
-      fix_iframe
-      bro.wd.execute_script(
-        %[if (document.getElementById('locatine_magic_div')){
-          const magic_div = document.getElementById('locatine_magic_div');
-           return magic_div.setAttribute("#{what}", "#{value}")}]
-      )
-      fix_iframe
-    end
-
-    ##
-    # Getting attribute of locatine div (way to communicate)
-    def get_from_app(what)
-      fix_iframe
-      result = engine.wd.execute_script(
-        %[if (document.getElementById('locatine_magic_div')) {
-           const magic_div = document.getElementById('locatine_magic_div');
-           return magic_div.getAttribute("#{what}")}]
-      )
-      fix_iframe
-      result
-    end
-
-    def fix_iframe
-      @iframe = @browser.iframe(@iframe.selector) if @iframe && @iframe.stale?
-    end
-
-    def push_title(text)
-      puts text
-      send_to_app('locatinetitle', text)
-    end
-
-    ##
-    # Sending request to locatine app
-    def start_listening(scope, name)
-      push_title "You are selecting #{name} in #{scope}"
-      send_to_app('locatinestyle', 'blocked', @browser) if @iframe
-      send_to_app('locatinehint', 'Toggle single//collection mode button if '\
-        'you need. If you want to do some actions on the page toggle Locatine'\
-        ' waiting button. You also can select element on devtools -> Elements.'\
-        ' Do not forget to confirm your selection.')
-      send_to_app('locatinestyle', 'set_true')
-      sleep 0.5
-    end
-
-    def tag_index
-      tag = get_from_app('tag')
-      tag = tag.downcase unless tag.nil?
-      index = get_from_app('index').to_i
-      return tag, index
-    end
-
-    def response_action(element)
-      send_to_app('locatineconfirmed', 'ok')
-      push_title 'Right now you are defining nothing. So no button will work'
-      send_to_app('locatinehint', 'Place for a smart hint here')
-      mass_highlight_turn(element, false)
-      send_to_app('locatinestyle', 'set_false')
-      send_to_app('locatinestyle', 'ok', @browser) if @iframe
-      sleep 1
-    end
-  end
-end

data/lib/locatine/dialog_logic.rb

@@ -1,118 +0,0 @@
-module Locatine
-  ##
-  # Logic of recieving element selected by user
-  module DialogLogic
-    private
-
-    def suggest_element(element, vars, name, scope)
-      attributes = {}
-      if !element.nil?
-        attributes = generate_data(element, vars)
-        push_title("#{element.length} elements found as #{name} in #{scope}.")
-      elsif name.length >= 5
-        push_title("Locatine is trying to guess what is #{name} in #{scope}.")
-        element, attributes = find_by_guess(scope, name, vars)
-      end
-      mass_highlight_turn(element) if element
-      return element, attributes
-    end
-
-    def add_selected_attributes(new_attributes, attributes)
-      if get_from_app('locatinecollection') == 'true'
-        get_commons(new_attributes, attributes.to_h)
-      else
-        new_attributes
-      end
-    end
-
-    def selected_element_attributes(tag, index, vars)
-      generate_data([engine.elements(tag_name: tag)[index]], vars).to_h
-    end
-
-    def selected_element(tag, index, vars, attributes)
-      new_attributes = selected_element_attributes(tag, index, vars)
-      new_attributes = add_selected_attributes(new_attributes, attributes)
-      element = find_by_data(new_attributes, vars)
-      return element, new_attributes
-    end
-
-    def working_on_selected(tag, index, vars, attributes)
-      push_title "You've selected //#{tag}[#{index}]. Wait while Locatine works"
-      element, new_attributes = selected_element(tag, index, vars, attributes)
-      warn 'Cannot proceed with selected. Dropping it.' unless element
-
-      warn "Maybe #{tag} can't be found as a #{@type}?" if @type && !element
-
-      return_selected(element, attributes, new_attributes, vars)
-    end
-
-    def return_old_selection(attrs, vars)
-      return find_by_data(attrs, vars).to_a, attrss.to_h if attrs.to_h != {}
-
-      return nil, {}
-    end
-
-    def return_selected(element, attributes, new_attributes, vars)
-      if !element && new_attributes.to_h != {}
-        push_title 'Selected element was lost before locatine locate it. '\
-                 'Consider choosing it from devtools or write your own locator'
-        return return_old_selection(attributes, vars)
-
-      end
-      return element, new_attributes
-    end
-
-    def what_was_selected(element, attributes, vars, name, scope)
-      tag, index = tag_index
-      send_to_app('locatineconfirmed', 'ok')
-      mass_highlight_turn(element, false) if element
-      element, attributes = working_on_selected(tag, index, vars, attributes)
-      if element
-        mass_highlight_turn(element)
-        push_title "#{element.length} elements were selected as #{name} in "\
-                  "#{scope}. If it is correct - confirm the selection."
-      end
-      return element, attributes
-    end
-
-    def decline(element, name, scope)
-      mass_highlight_turn(element, false) if element
-      send_to_app('locatineconfirmed', 'ok')
-      push_title "Nothing is selected as #{name} in #{scope}"
-      return nil, {}
-    end
-
-    def user_selection(els, attrs, vars, name, scope)
-      case get_from_app('locatineconfirmed')
-      when 'selected'
-        els, attrs = what_was_selected(els, attrs, vars, name, scope)
-      when 'declined'
-        els, attrs = decline(els, name, scope)
-      end
-      return els, attrs
-    end
-
-    def listening(els, attrs, vars, name, scope)
-      until get_from_app('locatineconfirmed') == 'true'
-        sleep(0.1)
-        els, attrs = user_selection(els, attrs, vars, name, scope)
-      end
-      return els, attrs if els
-
-      decline(els, name, scope)
-      listening(els, attrs, vars, name, scope)
-    end
-
-    ##
-    # request send and waiting for an answer
-    def ask(scope, name, element, vars)
-      start_listening(scope, name)
-      element, attributes = suggest_element(element, vars, name, scope)
-      @cold_time = 0
-      element, attributes = listening(element, attributes, vars, name, scope)
-      @cold_time = nil
-      response_action(element)
-      return element, attributes
-    end
-  end
-end

data/lib/locatine/file_work.rb

@@ -1,61 +0,0 @@
-module Locatine
-  ##
-  # Methods about creating, reading and writing files
-  module FileWork
-    private
-
-    ##
-    # Reading data from provided file which is set on init of the class instance
-    #
-    # If there is no dir or\and file they will be created
-    def read_create
-      FileUtils.mkdir_p(@folder) unless File.directory?(@folder)
-      hash = Hash.new { |h, k| h[k] = Hash.new { |hi, ki| hi[ki] = {} } }
-      create_json_file unless File.exist?(@json)
-      hash.merge(JSON.parse(File.read(@json))['data'])
-    end
-
-    def import_file(json)
-      @json = json
-      @folder = File.dirname(@json)
-      @name = File.basename(@json)
-      @data = read_create
-    end
-
-    def create_json_file
-      f = File.new(@json, 'w')
-      f.puts '{"data" : {}}'
-      f.close
-    end
-
-    ##
-    # Setting stability
-    def set_stability(first, second)
-      second = first if second.to_h == {}
-      final = Hash.new { |hash, key| hash[key] = [] }
-      first.each_pair do |depth, array|
-        final[depth] = same_entries(array, second, depth, true).uniq
-      end
-      final
-    end
-
-    def stability_bump(to_add, hash)
-      if to_add.empty? # new ones
-        hash['stability'] = '1'
-      elsif to_add[0]['stability'].to_i < @stability_limit # old ones
-        to_add[0]['stability'] = (to_add[0]['stability'].to_i + 1).to_s
-      end
-      to_add.empty? ? [hash] : to_add
-    end
-
-    ##
-    # Saving json
-    def store(attributes, scope, name)
-      @data[scope][name] = set_stability(attributes, @data[scope][name])
-      to_write = { 'data' => @data }
-      File.open(@json, 'w') do |f|
-        f.write(JSON.pretty_generate(to_write))
-      end
-    end
-  end
-end

data/lib/locatine/find_by_css.rb

@@ -1,45 +0,0 @@
-module Locatine
-  ##
-  # Looking for elements by css values
-  module FindByCss
-    private
-
-    def css_array_by_data(data, vars)
-      q_css = []
-      get_trusted(data['0']).each do |hash|
-        if hash['type'] == 'css'
-          value = process_string(hash['value'], vars) if vars[hash['name']]
-          q_css.push("#{hash['name']}: #{value || hash['value']}")
-        end
-      end
-      q_css
-    end
-
-    def return_caught_elements(caught)
-      all = []
-      caught.each do |i|
-        @help_hash[i[0]] ||= engine.elements(tag_name: i[0].downcase).to_a
-        elm = @help_hash[i[0]][i[1].to_i]
-        all.push(elm) if elm
-      end
-      all
-    end
-
-    def select_elements_from_raws_by_css(q_css, raws)
-      all = []
-      @help_hash = {}
-      q_css.each do |item|
-        caught = (raws.select { |i| i[2].include?(item) })
-        all += return_caught_elements(caught)
-      end
-      all
-    end
-
-    def full_find_by_css(data, vars)
-      q_css = css_array_by_data(data, vars)
-      script = File.read("#{HOME}/large_scripts/css.js")
-      raws = engine.execute_script(script)
-      select_elements_from_raws_by_css(q_css, raws)
-    end
-  end
-end

data/lib/locatine/find_by_guess.rb

@@ -1,62 +0,0 @@
-module Locatine
-  ##
-  # If html code is good and name is related to the code, Locatine can guess it
-  #
-  # Methods for finding element by name only
-  module FindByGuess
-    private
-
-    def main_guess(name)
-      all = []
-      name.split(' ').each do |part|
-        all += guess_by_part(part)
-      end
-      all
-    end
-
-    def guess_by_part(part)
-      all = []
-      tag_xpath = "//#{part}#{not_magic_div}"
-      text_xpath = "//*[contains(text(),'#{part}')]#{not_magic_div}"
-      attr_xpath = "//*[@*[contains(., '#{part}')]]#{not_magic_div}"
-      all += find_by_locator(xpath: tag_xpath).to_a
-      all += find_by_locator(xpath: text_xpath).to_a
-      all += find_by_locator(xpath: attr_xpath).to_a
-      all
-    end
-
-    def full_guess(all, vars, name)
-      max = all.count(all.max_by { |i| all.count(i) })
-      if max >= name.split(' ').length
-        guess = (all.select { |i| all.count(i) == max }).uniq
-        guess_data = generate_data(guess, vars)
-        found_by_data = find_by_data(guess_data, vars)
-      end
-      return found_by_data, guess_data.to_h
-    end
-
-    def check_guess(all, vars, name, scope)
-      guess, guess_data = full_guess(all, vars, name)
-      if guess.nil? || (engine.elements.length / guess.length <= 4)
-        push_title "Locatine has no good guess for #{name} in #{scope}."
-        guess = nil
-        guess_data = {}
-      else
-        push_title "#{guess.length} elements guessed as #{name} in #{scope}."
-      end
-      return guess, guess_data
-    end
-
-    def find_by_guess(scope, name, vars)
-      @cold_time = 0
-      all = main_guess(name)
-      if all.empty?
-        push_title "Locatine has no guess for #{name} in #{scope}."
-      else
-        guess, guess_data = check_guess(all, vars, name, scope)
-      end
-      @cold_time = nil
-      return guess, guess_data.to_h
-    end
-  end
-end