marta 0.37396 → 0.41245

data/lib/marta/data/style.css

@@ -158,7 +158,7 @@ div[martaclass=marta_div] {
     outline: 2px solid #bbbbbb;
     background-color: lightgray;
     position : relative;
-    z-index : 150000;
+    z-index : 2147483647;
     padding: 0;
     margin: 0px 0px 0px 0px;
     overflow-y: scroll;
@@ -228,7 +228,7 @@ div[martastyle=at_large] {
   width: 100%;
   pointer-events: visible;
   display: block;
-  z-index: 149000;
+  z-index: 2147483646;
 }
 
 div[martastyle=off] {

data/lib/marta/dialogs.rb

@@ -4,6 +4,7 @@ require 'marta/lightning'
 require 'marta/injector'
 require 'marta/public_methods'
 require 'marta/page_arithmetic'
+require 'marta/element_information'
 
 module Marta
 
@@ -23,7 +24,7 @@ module Marta
     class MethodSpeaker
 
       include XPath, Lightning, Injector, PublicMethods, SimpleElementFinder,
-              PageArithmetic
+              PageArithmetic, ElementInformation
 
       def initialize(method_name, requestor)
         @class_name = requestor.class_name
@@ -83,8 +84,7 @@ module Marta
       def attrs_plus_result
         if !attrs_exists?
           @attrs = @result
-        elsif !@attrs['options']['collection'] or
-                                          !@result['options']['collection']
+        elsif !@result['options']['collection']
           @attrs = @result
         else
           @attrs = make_collection(@attrs, @result)
@@ -93,7 +93,17 @@ module Marta
 
       # Asking: "What are you looking for?"
       def ask_for_elements
-        ask 'element', "Found #{@found} elements for #{@title}", @attrs
+        answer = ask 'element', "Found #{@found} elements for #{@title}", @attrs
+        return answer.class == Hash ? answer_to_hash(answer) : answer
+      end
+
+      # Creating new fashioned hash out of data
+      def answer_to_hash(answer)
+        result = method_structure
+        result['options']['collection'] =  answer['collection']
+        what = answer['exclude'] ? 'negative' : 'positive'
+        result[what] = get_attributes(answer['element'])
+        result
       end
 
       # Creating data to save when it is a basically defined element
@@ -173,8 +183,46 @@ module Marta
     def user_method_dialogs(method_name)
       dialog_master = MethodSpeaker.new(method_name, self)
       data = dialog_master.dialog
+      data['meths'][method_name] =
+                    dynamise_method(data['vars'], data['meths'][method_name])
       file_write(self.class_name.to_s, data)
       data
     end
+
+    # Massive gsub for attribute
+    def dynamise(variable_name, what)
+      what.each do |entry|
+        entry.each do |value|
+          value.gsub!(self.instance_variable_get("@#{variable_name}"),
+             '#{@' + variable_name + '}')
+        end
+      end
+    end
+
+    # Marta will search for page variables in attributes of element in order
+    # to create dynamic element by itself. It must be splited. And moved.
+    def dynamise_method(vars, method)
+      vars.each_pair do |variable_name, variable|
+        if variable_name.include?('text')
+          dynamise variable_name, [method['positive']['self']['text'],
+                                   method['positive']['pappy']['text'],
+                                   method['positive']['granny']['text'],
+                                   method['negative']['self']['text'],
+                                   method['negative']['pappy']['text'],
+                                   method['negative']['granny']['text']]
+        else
+          [method['positive'], method['negative']].each do |method|
+            method.each_pair do |level, content|
+              content['attributes'].each_pair do |attribute_name, values|
+                if variable_name.include?(attribute_name)
+                  dynamise variable_name, [values]
+                end
+              end
+            end
+          end
+        end
+      end
+      method
+    end
   end
 end

data/lib/marta/element_information.rb

@@ -0,0 +1,86 @@
+module Marta
+
+  # Marta is creating a hash of element data. For now it stores
+  # tag, text, and all the attributes.
+  module ElementInformation
+
+    private
+
+    #
+    # We are using helper class which can parse element attributes to our
+    # special hash format.
+    #
+    # @note It is believed that no user will use it
+    class ElementHelper
+
+      def initialize(requestor)
+        @engine = requestor.engine
+      end
+
+      # We can get data of the element or data of any parent.
+      def get_element_info(element, parent_count = 0)
+        parent = ''
+        parent_count.times do
+          parent = parent + '.parentElement'
+        end
+        result = Hash.new
+        attr_script = %Q[
+            var s = {};
+            var attrs = arguments[0]#{parent}.attributes;
+            for (var l = 0; l < attrs.length; ++l) {
+                var a = attrs[l]; s[a.name] = a.value.split(" ");
+            } ;
+            return s;]
+        tag_script = "return arguments[0]#{parent}.tagName"
+        text_script = %Q[
+        if (arguments[0]#{parent}.textContent == arguments[0]#{parent}.innerHTML)
+           {return arguments[0]#{parent}.textContent} else {return ''};]
+        result['tag'] = [@engine.execute_script(tag_script, element)]
+        txt = @engine.execute_script(text_script, element)
+        result['text'] = txt != '' ? [txt] : []
+        result['attributes'] = @engine.execute_script(attr_script, element)
+        result['attributes'].each_pair do |attribute, value|
+          value.uniq!
+        end
+        return result
+      end
+
+      # That class is also stores an empty special format hash.
+      def self.method_structure(collection = false)
+        return {'options' => {'collection' => collection},
+                 'positive' => {
+                   'self' => {
+                     'text'=>[], 'tag' => [], 'attributes' => {}},
+                    'pappy' => {
+                      'text'=>[], 'tag' => [], 'attributes' => {}},
+                    'granny' => {
+                      'text'=>[], 'tag' => [], 'attributes' => {}}},
+                  'negative' => {
+                    'self' => {
+                      'text'=>[], 'tag' => [], 'attributes' => {}},
+                     'pappy' => {
+                       'text'=>[], 'tag' => [], 'attributes' => {}},
+                     'granny' => {
+                       'text'=>[], 'tag' => [], 'attributes' => {}}}
+                    }
+      end
+    end
+
+    # We are getting three levels of attributes of element,
+    # parent and grandparent
+    def get_attributes(element, requestor = self)
+      result = Hash.new
+      element_helper = ElementHelper.new requestor
+      result['self'] = element_helper.get_element_info element
+      result['pappy'] = element_helper.get_element_info element, 1
+      result['granny'] = element_helper.get_element_info element, 2
+      return result
+    end
+
+    # We can return the default structure of our special format
+    def method_structure(collection = false)
+      ElementHelper.method_structure collection
+    end
+
+  end
+end

data/lib/marta/injector.rb

@@ -127,9 +127,9 @@ module Marta
           result = MartaServer.wait_user_dialog_response
           # We need double check for iframes here. It should be 100% changed.
           if !result
-            result = engine.execute_script("return document.marta_confirm_mark")
+            result = @engine.execute_script("return document.marta_confirm_mark")
           end
-          if (!result and !engine.element(id: 'marta_s_everything').exists?)
+          if (!result and !@engine.element(id: 'marta_s_everything').exists?)
             actual_injection
           end
         end

data/lib/marta/json_2_class.rb

@@ -104,7 +104,7 @@ module Marta
 
     def build_method(name, content)
       define_singleton_method name.to_sym do
-        learn_status ? method_edit(name) : marta_magic_finder(content)
+        learn_status ? method_edit(name) : marta_magic_finder(content, name)
       end
       exact = name + '_exact'
       define_singleton_method exact.to_sym do

data/lib/marta/lightning.rb

@@ -21,6 +21,7 @@ module Marta
       end
     end
 
+    # Method to understand that something shouldn't be highlighted
     def is_here?(element)
       element.exists?
     rescue

data/lib/marta/marta_app/content.js

@@ -6,6 +6,13 @@ async function port_set(value){
         });
 };
 
+function getSelected(value){
+  document.getElementById('marta_show_html').setAttribute('tag', value.tagName);
+  const x = document.getElementsByTagName(value.tagName);
+  const index = Array.prototype.indexOf.call(x, value);
+  document.getElementById('marta_show_html').setAttribute('index', index);
+};
+
 async function port_get(){
   await chrome.storage.sync.get(['port'], function(result) {
           port = result.port;
@@ -22,6 +29,7 @@ document.addEventListener("marta_send", async function(e) {
   //console.log(port);
   //console.log(e.detail.port);
   console.log("Marta is acting back. With port = " + port);
+  console.log("Marta is acting back. With mark = " + e.detail.mark);
   marta_real_send(e.detail.mark, port);
 });
 

data/lib/marta/marta_app/devtools.html

@@ -0,0 +1 @@
+<script src="devtools.js"></script>

data/lib/marta/marta_app/devtools.js

@@ -0,0 +1,5 @@
+
+setInterval(function(){
+
+    chrome.devtools.inspectedWindow.eval("getSelected($0)", { useContentScriptContext: true });
+}, 100);

data/lib/marta/marta_app/manifest.json

@@ -1,8 +1,9 @@
 {
   "name": "Marta app",
-  "version": "0.37396",
+  "version": "0.41245",
   "description": "Messaging from browser to main app",
-  "permissions": ["activeTab", "http://127.0.0.1*/*", "storage"],
+  "devtools_page": "devtools.html",
+  "permissions": ["activeTab", "http://127.0.0.1*/*", "storage", "contextMenus"],
   "background": {
     "scripts": ["background.js"],
     "persistent": true

data/lib/marta/options_and_paths.rb

@@ -158,7 +158,7 @@ module Marta
 
       # Marta uses simple rules to set the tolerancy value
       def self.set_tolerancy(value)
-        @@tolerancy = parameter_set(@@tolerancy, value, 1024)
+        @@tolerancy = parameter_set(@@tolerancy, value, 100000)
       end
 
       def self.parameter_check_and_set(where, value, default, expected_class)
@@ -246,14 +246,5 @@ module Marta
       SettingMaster.port
     end
 
-    # Marta can call server easily
-    def server
-      SettingMaster.server
-    end
-
-    # Marta knows was the browser started by she
-    def correct_engine?
-      SettingMaster.correct_engine?
-    end
   end
 end

data/lib/marta/page_arithmetic.rb

@@ -1,3 +1,4 @@
+require 'marta/element_information'
 module Marta
 
   #
@@ -15,126 +16,107 @@ module Marta
     # @note It is believed that no user will use it
     # Now it has only one way to merge hashes
     # This method is getting common only of two methods in order to generate a
-    # correct hash for collection element. Methods of the class are pretty
-    # esoteric. Refactoring is a must here.
+    # correct hash for collection element.
     class MethodMerger
 
+      include ElementInformation
+
       # Class is taking two hashes. Sometimes order is valuable
       def initialize(main_hash, second_hash)
         @main_hash = main_hash
         @second_hash = second_hash
       end
 
-      POSITIVE = ['self', 'pappy', 'granny']
-      NEGATIVE = ['not_self', 'not_pappy', 'not_granny']
-
       # Main method for adding two elements into a large-wide collection
       def do_collection
-        result = Hash.new
-        result['options'] = options_merge
-        NEGATIVE.each do |key|
-          result[key] = all_of key
-        end
-        POSITIVE.each do |key|
-          result[key], result["not_#{key}"] =
-                      passive_exclude(common_of(key), result["not_#{key}"])
+        result = method_structure
+        # Everything is simple for now with options)
+        result['options'] = @main_hash['options']
+        # If we are adding to collection
+        if @second_hash['positive']['self']['tag'] != []
+          result['positive'] = multiply(@main_hash['positive'],
+                                        @second_hash['positive'])
+          result['negative'] = extract(@main_hash['negative'],
+                                       @second_hash['positive'])
+        else # If we are excluding from collection
+          result['positive'] = @main_hash['positive']
+          uniqs = extract(@second_hash['negative'], @main_hash['positive'])
+          result['negative'] = summarize(uniqs, @main_hash['negative'])
         end
         result
       end
 
-      # The most esoteric part of merging elements into collection
-      # Now we are loosing nots tags if they are not good for us
-      # As well we are loosing positive tags by merging them into alltags
-      # symbol == *. The way out is to use arrays for tags.
-      def options_merge
-        temp = Hash.new
-        temp['collection'] = @main_hash['options']['collection']
-        POSITIVE.each do |key|
-          value = @main_hash['options'][key]
-          main_negative = @main_hash['options']["not_#{key}"]
-          second_negative = @second_hash['options']["not_#{key}"]
-          if (@second_hash['options'][key] == value) or
-             ((@second_hash['options'][key].nil?) and (!value.nil?))
-            temp[key] = value
-          else
-            temp[key] = "*"
-          end
-          if (second_negative != temp[key]) and
-               ((second_negative == main_negative) or
-                 (main_negative.nil?))
-                   temp["not_#{key}"] = second_negative
-          end
-        end
-        temp
+      # When black magic finds something
+      # she's not trusting dynamic attribute anymore. So she's forgetting
+      # unstable attributes and remembering stable and new ones
+      def forget_unstable
+        result = method_structure
+        result['options'] = @main_hash['options']
+        result['positive'] = merge(@main_hash['positive'],
+                                      @second_hash['positive'])
+        result['negative'] = extract(@main_hash['negative'],
+                                      @second_hash['positive'])
+        result
       end
 
-      # This method will leave only common elements of both hashes
-      def common_of(what)
-        temp = Hash.new
-        first, second = @main_hash[what], @second_hash[what]
-        if !first.nil? and !second.nil?
-          first.each_pair do |key, value|
-            if second[key] == value
-              temp[key] = value
-            elsif second[key].class == Array and value.class == Array
-              temp[key] = value & second[key]
+      # Recursive operations with method.
+      def do_arithmetic(first, second, what)
+        what == '+' ? result = second : result = Hash.new
+        first.each_pair do |key, value|
+          if value.is_a? Hash
+            result[key] = do_arithmetic(first[key], second[key], what)
+          elsif !second[key].nil? and !value.nil?
+            if what == '+'
+              result[key] = (first[key] + second[key]).uniq
+            elsif what == '&'
+              result[key] = first[key] & second[key]
+            elsif what == '-'
+              result[key] = first[key] - second[key]
+            elsif what == '*'
+              if (second[key] != [])
+                result[key] = first[key] & second[key]
+              end
             end
           end
-        else
-          temp = first
+          if (second[key] == [] or second[key].nil?) and
+                ((what == '+') or (what == '*'))
+            result[key] = first[key]
+          end
         end
-        temp
+        result
       end
 
-      # This method will leave all the elements of hashes. But if one attribute
-      # is presented in both. Method will use the one from the main.
-      # When it will be possible to use arrays for tags and attributes this
-      # logic will be changed
-      def all_of(what)
-        temp = Hash.new
-        first, second = @main_hash[what], @second_hash[what]
-        if !first.nil?
-          temp = first
-        end
-        if !second.nil? and !temp.nil?
-          second.each_pair do |key, value|
-            if (temp[key].nil?) or ((temp[key] != value) and
-               (temp[key].class != Array) and (value.class != Array))
-                 temp[key] = value
-            elsif (temp[key].class == Array) and (value.class == Array)
-              temp[key] = (value + temp[key]).uniq
-            end
-          end
-          if !first.nil?
-            first.each_pair do |key, value|
-              if second[key].nil? and !value.nil?
-                temp[key] = nil
-              end
-            end
-          end
-        else
-          temp = second
-        end
-        temp
+      # That is not a real merge. We are leaving everything that is the same
+      # or new and deleting everyting that is not the same
+      #
+      # Idea:
+      # merge({a:[1],b:[2],c:[3]},{a:[1],b:[2,3]}) #=> {a:[1],b:[2],c:[3]}
+      def merge(first, second)
+        do_arithmetic(second, first, '*')
       end
 
-      # That is about excluding only attributes that are not presented as
-      # positives.
-      def passive_exclude(main, passive)
-        temp = main
-        not_temp = passive
-        if !passive.nil?
-          passive.each_pair do |key, value|
-            if !main[key].nil?
-              if main[key] == value
-                not_temp[key] = value.class == Array ? []:nil
-              elsif (value.class == Array) and (main[key].class == Array)
-                not_temp[key] = value - main[key]
-              end
-            end
-          end
-        end
-        return temp, not_temp
+      # Simple adding everyting to everything
+      #
+      # Idea:
+      # summarize({a:[1],c:[4]},{a:[2],b:[3]}) #=> {a:[1,2],b:[3],c:[4]}
+      def summarize(first, second)
+        do_arithmetic(second, do_arithmetic(first, second, '+'), '+')
+      end
+
+      # That will leave only the same options in the result
+      #
+      # Idea:
+      # multiply({a:[1,2],b:[2],c:[5]},{a:[1,3],b:[4],d:[0]}) #=> {a:[1],b:[2]}
+      def multiply(first, second)
+        do_arithmetic(first, second, '&')
+      end
+
+      # That will take out of the result all options of second
+      #
+      # Idea
+      # extract({a:[1,2],b:[2],c:[5]},{a:[2],c:[5],d:[0]}) #=> {a:[1],b:[2]}
+      def extract(first, second)
+        do_arithmetic(first, second, '-')
       end
     end
 
@@ -143,5 +125,11 @@ module Marta
       merger = MethodMerger.new(one, two)
       merger.do_collection
     end
+
+    # Forgetting unstable attributes leaving the same ones and new ones
+    def forget_unstable(old_one, new_one)
+      merger = MethodMerger.new(old_one, new_one)
+      merger.forget_unstable
+    end
   end
 end