scrap_kit 0.1.6 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffb35087e7e374b2e5fa15d2f9c2d41374d0242e4f2b5a986db195929a530dc6
-  data.tar.gz: 904246fc2061a3ec1686a70d6755fd81f13b215b3dce7816177f0774af666b89
+  metadata.gz: 36f370f43360cdc2725cbb83591738dc46c5949cb995039f45cf1ddaccd091a4
+  data.tar.gz: b904bef830b3e5cd88892677eed3f0cf97635e2d46277cc69280ca5ee7b6a0a3
 SHA512:
-  metadata.gz: c55754d5f772f7bfd9c9bd4fdda802f77a898f6c86f0956d9f94d9c81e7151fdaed07ec45f56d0b7010eb56dc7a1a94e58079bcb1da4753586766eefd4bd4954
-  data.tar.gz: b20fc3e3b8852361e707d4597ec510d44cb3d76a9260f6d719e2547adf5a68abafeb7423f02c47ba853a4f92ee43df3ccfc88bb60dd21913249ef8b62613a53c
+  metadata.gz: e0c1321ef88bf5be53603e41e0826676d9bc50bb741b4d45d8cc79ff42bc6e0360d989c3deb097d8c784b9c795495898a39cf7ff4a41f36c62f57d0f030a8915
+  data.tar.gz: b668a193cf260b94239d1d1e016e9eb4b2d8e3de43aaf604d6d9fb255b5147295e2079e5da7b3b3dbb6177ea45ac413ce73467f11ba73d0f2495fa91b3196af4

data/CHANGELOG.md

@@ -1,6 +1,34 @@
 # Changelog
 
+## [0.1.11] 2020-09-03
+
+### Changed/Added
+- Add `user_agent` accessor for browser
+
+## [0.1.10] 2020-09-03
+
+### Changed/Added
+- Map attributes to JavaScript calls
+
+## [0.1.9] 2020-08-31
+
+### Changed/Added
+- Set arguments for Chrome driver
+
+## [0.1.8] 2020-08-29
+
+### Changed/Added
+- Add new ways to declare selectors
+- Add steps
+
+## [0.1.7] 2020-08-28
+
+### Changed/Added
+- Match selector condition by regexp or exact value
+
 ## [0.1.6] 2020-08-28
+
+### Changed/Added
 - Update activesupport requirement from = 6.0.2.1 to ~> 6.0
 - Fix bug when matching selector condition
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    scrap_kit (0.1.6)
+    scrap_kit (0.1.11)
       activesupport (~> 6.0)
       watir (~> 6.16.5)
       webdrivers (~> 4.0)
@@ -21,7 +21,7 @@ GEM
     i18n (1.8.5)
       concurrent-ruby (~> 1.0)
     mini_portile2 (2.4.0)
-    minitest (5.14.1)
+    minitest (5.14.2)
     nokogiri (1.10.10)
       mini_portile2 (~> 2.4.0)
     rake (13.0.1)

data/README.md

@@ -81,6 +81,66 @@ output = recipe.run
 #=> {:posts=>[{:title=>"APIs de Internacionalización en JavaScript"}, {:title=>"Ejecutando comandos desde Ruby"}, {:title=>"Usando Higher-Order Components"}]}
 ```
 
+### Working with selectors
+
+Each attribute can be mapped to a selector, which can be any of the following types:
+
+* A string, which represents a CSS selector.
+
+```ruby
+".subnav__inner .ember-view:nth-child(1) > .status-summary__description"
+```
+
+* A hash, which can have any of the following options:
+  * `xpath: [String]`
+  * `css: [String]`
+  * `index: [Integer]`
+  * `tag_name: [String]`
+  * `text: [String]`
+
+```ruby
+{ text: "View Archive" }
+```
+
+* An array, which represents a path of selectors, where its last item must be a hash that matches a selector with an expected value.
+
+```ruby
+[".up-time-chart", { ".region-header .u-margin-Tm": "REGION" }]
+```
+
+Use any of them as it suits you best.
+
+### Writing steps
+
+Recipes can have a `steps` entry. This entry defines previous actions the scraper have to follow before extract the attributes. The following steps are supported:
+
+* **`goto`**: It instructs the scraper to go to a link inside the current page. Its value can be a hash or array selector, or a URL:
+
+```ruby
+{
+  goto: { text: "View Archive" }
+}
+```
+
+* **`click`**: It instructs the scraper to click on an element inside the current page. Its value can be a hash or array selector:
+
+```ruby
+{
+  click: { css: "[type=submit]" }
+}
+```
+
+* **`fill_form`**: It instructs the scraper to fill a form or any form field inside the current page. Its value is a hash where the keys are either a input's name or a CSS selector, and the values are the values to be entered into those fields:
+
+```ruby
+{
+  fill_form: {
+    gem_name: "ScrapKit",
+    author: "hpneo",
+  }
+}
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/scrap_kit/recipe.rb

@@ -4,6 +4,22 @@ require "watir"
 
 module ScrapKit
   class Recipe
+    attr_accessor :user_agent
+
+    class << self
+      def load(source)
+        input = if source.is_a?(Hash)
+          source
+        elsif source.is_a?(IO)
+          JSON.parse(source.read)
+        else
+          JSON.parse(File.read(source))
+        end
+
+        new(input.deep_symbolize_keys)
+      end
+    end
+
     def initialize(url: nil, steps: [], attributes: {})
       @url = url
       @steps = steps
@@ -13,42 +29,63 @@ module ScrapKit
     def run
       output = {}
 
-      browser = Watir::Browser.new(:chrome, headless: true)
-      browser.goto @url
+      @browser = create_browser
+      @browser.goto @url
 
       @steps.each do |step|
-        run_step(browser, step)
+        run_step(step)
       end
 
       @attributes.each do |attribute_name, selector|
-        output[attribute_name] = extract_attribute(browser, selector)
+        output[attribute_name] = extract_attribute(@browser, selector)
       end
 
-      browser.close
-      browser = nil
+      @browser.close
+      @browser = nil
 
       output
     end
 
-    def run_step(browser, step)
+    def run_step(step)
+      return goto(step[:goto]) if step[:goto]
+      return click(step[:click]) if step[:click]
+      return fill_form(step[:fill_form]) if step[:fill_form]
+
+      nil
+    end
+
+    def find_element_by_name_or_selector(browser_or_element, name_or_selector)
+      element = browser_or_element.element(name: name_or_selector.to_s)
+      return element if element.exists?
+
+      element = browser_or_element.element(css: name_or_selector.to_s)
+      return element if element.exists?
+
+      nil
     end
 
     def elements_from_selector(browser_or_element, selector)
       if selector.is_a?(String)
         browser_or_element.elements(css: selector)
+      elsif selector.is_a?(Hash)
+        browser_or_element.elements(selector)
       elsif selector.is_a?(Array)
         *remainder, condition = selector
+        condition_key, condition_value = condition.first
         elements = browser_or_element
 
-        remainder.each do |item|
-          elements = elements.elements(css: item)
+        if remainder.empty?
+          elements = elements.elements(css: condition_key.to_s)
+        else
+          remainder.each do |item|
+            elements = elements.elements(css: item)
+          end
         end
 
         elements.filter do |element|
-          condition_key = condition.keys.first.to_s
-          condition_value = condition.values.first
-          found_element = element.element(css: condition_key)
-          extract_value_from_element(found_element) == condition_value
+          found_element = element.element(css: condition_key.to_s)
+          extracted_value = extract_value_from_element(found_element)
+          extracted_value.match(condition_value) || extracted_value == condition_value
         end
       end
     end
@@ -63,37 +100,117 @@ module ScrapKit
       element&.text_content
     end
 
-    def extract_attribute(browser_or_element, selector_or_hash)
-      if selector_or_hash.is_a?(String)
-        extract_value_from_element(browser_or_element.element(css: selector_or_hash))
-      elsif selector_or_hash.is_a?(Hash)
-        selector = selector_or_hash[:selector]
-        selector_for_children_attributes = selector_or_hash[:children_attributes]
+    def extract_attribute(browser_or_element, selector_or_object)
+      if selector_or_object.is_a?(String)
+        extract_value_from_element(browser_or_element.element(css: selector_or_object))
+      elsif selector_or_object.is_a?(Array)
+        found_elements = elements_from_selector(browser_or_element, selector_or_object)
 
-        elements_from_selector(browser_or_element, selector).map do |element|
-          output = {}
+        if found_elements.size === 1
+          extract_value_from_element(found_elements.first)
+        else
+          found_elements.map do |element|
+            extract_value_from_element(element)
+          end
+        end
+      elsif selector_or_object.is_a?(Hash)
+        if selector_or_object[:selector] && selector_or_object[:children_attributes]
+          selector = selector_or_object[:selector]
+          selector_for_children_attributes = selector_or_object[:children_attributes]
+
+          elements_from_selector(browser_or_element, selector).map do |element|
+            output = {}
+
+            selector_for_children_attributes.each do |child_attribute_name, child_selector|
+              output[child_attribute_name] = extract_attribute(element, child_selector)
+            end
 
-          selector_for_children_attributes.each do |child_attribute_name, child_selector|
-            output[child_attribute_name] = extract_attribute(element, child_selector)
+            output
           end
+        elsif selector_or_object[:javascript]
+          @browser.execute_script(selector_or_object[:javascript])
+        else
+          found_elements = elements_from_selector(browser_or_element, selector_or_object)
+
+          if found_elements.size === 1
+            extract_value_from_element(found_elements.first)
+          else
+            found_elements.map do |element|
+              extract_value_from_element(element)
+            end
+          end
+        end
+      end
+    end
 
-          output
+    private
+
+    def goto(link_or_selector)
+      if link_or_selector.is_a?(String)
+        @browser.goto(link_or_selector)
+      elsif link_or_selector.is_a?(Array) || link_or_selector.is_a?(Hash)
+        if found_element = elements_from_selector(@browser, link_or_selector).first
+          found_element.click
         end
       end
+
+      sleep 0.5
+      @browser.wait_until do
+        @browser.ready_state == "complete"
+      end
+    rescue
+      nil
     end
 
-    class << self
-      def load(source)
-        input = if source.is_a?(Hash)
-          source
-        elsif source.is_a?(IO)
-          JSON.parse(source.read)
-        else
-          JSON.parse(File.read(source))
+    def click(selector)
+      if selector.is_a?(Array) || selector.is_a?(Hash)
+        if found_element = elements_from_selector(@browser, selector).first
+          found_element.click
         end
+      end
 
-        new(input.deep_symbolize_keys)
+      sleep 1
+      @browser.wait_until do
+        @browser.ready_state == "complete"
       end
+
+    rescue
+      nil
+    end
+
+    def fill_form(form_data)
+      form_data.each do |name, value|
+        if element = find_element_by_name_or_selector(@browser.body, name.to_s)
+          element = element.to_subtype
+
+          if element.respond_to?(:set)
+            element.set(value)
+          elsif element.respond_to?(:select)
+            element.select(value)
+          end
+        end
+      end
+
+      sleep 0.25
+      @browser.wait_until do
+        @browser.ready_state == "complete"
+      end
+    end
+
+    def create_browser
+      options = Selenium::WebDriver::Chrome::Options.new
+
+      options.add_argument "--headless"
+      options.add_argument "--window-size=1080x720"
+      options.add_argument "--hide-scrollbars"
+      options.add_argument "--user-agent=#{@user_agent}" if @user_agent
+
+      if chrome_bin = ENV["GOOGLE_CHROME_SHIM"]
+        options.add_argument "--no-sandbox"
+        options.binary = chrome_bin
+      end
+
+      Watir::Browser.new(:chrome, options: options)
     end
   end
 end

data/lib/scrap_kit/version.rb

@@ -1,3 +1,3 @@
 module ScrapKit
-  VERSION = "0.1.6"
+  VERSION = "0.1.11"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scrap_kit
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.11
 platform: ruby
 authors:
 - Gustavo Leon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-28 00:00:00.000000000 Z
+date: 2020-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler