pincers 0.6.0 → 0.7.0

data/lib/pincers/core/helpers/form.rb

@@ -0,0 +1,106 @@
+require 'pincers/http/utils'
+
+module Pincers::Core::Helpers
+
+  class Form
+
+    attr_reader :backend
+
+    def initialize(_backend, _form_element, _trigger_element = nil)
+      @backend = _backend
+      @form = _form_element
+      @trigger = _trigger_element
+      @force_multipart = false
+    end
+
+    def action
+      @action ||= begin
+        (trigger_attr(:formaction) || form_attr(:action) || '')
+      end
+    end
+
+    def method
+      @method ||= begin
+        (trigger_attr(:formmethod) || form_attr(:method) || 'get').downcase.to_sym
+      end
+    end
+
+    def target
+      @target ||= begin
+        trigger_attr(:formtarget) || form_attr(:target)
+      end
+    end
+
+    def encoding
+      process_inputs
+      @encoding ||= begin
+        if @force_multipart
+          Pincers::Http::Utils::FORM_MULTIPART
+        else
+          trigger_attr(:formenctype) || form_attr(:enctype) || Pincers::Http::Utils::FORM_URLENCODED
+        end
+      end
+    end
+
+    def inputs
+      process_inputs
+      @inputs
+    end
+
+  private
+
+    def trigger_attr(_name)
+      return nil if @trigger.nil?
+      backend.extract_element_attribute(@trigger, _name)
+    end
+
+    def form_attr(_name)
+      backend.extract_element_attribute(@form, _name)
+    end
+
+    def process_inputs
+      return unless @inputs.nil?
+      elements = backend.search_by_xpath(@form, './/*[@name]', nil)
+      @inputs = elements.map do |input|
+        category = categorize_input input
+        next nil if category.nil?
+
+        @force_multipart = true if category == :multipart
+
+        value = backend.extract_element_attribute(input, :value)
+        next nil if value.nil?
+
+        name = backend.extract_element_attribute(input, :name)
+        [name, value]
+      end.reject(&:nil?)
+    end
+
+    def categorize_input(_input)
+      case backend.extract_element_tag _input
+      when 'input'
+        input_type = backend.extract_element_attribute(_input, :type)
+        return nil if input_type == 'submit' && !is_trigger?(_input)
+        return nil if input_type == 'checkbox' && !is_checked?(_input)
+        return nil if input_type == 'radio' && !is_checked?(_input)
+        input_type == 'file' ? :multipart : :urlencoded
+      when 'button'
+        input_type = backend.extract_element_attribute(_input, :type) || 'submit'
+        return nil if input_type != 'submit' || !is_trigger?(_input)
+        :urlencoded
+      when 'textarea', 'select'
+        :urlencoded
+      else
+        nil
+      end
+    end
+
+    def is_trigger?(_input)
+      return false if @trigger.nil?
+      backend.elements_equal _input, @trigger
+    end
+
+    def is_checked?(_input)
+      backend.extract_element_attribute _input, :checked
+    end
+  end
+end

data/lib/pincers/core/{query.rb → helpers/query.rb}

@@ -1,10 +1,10 @@
 require 'pincers/css/parser'
 require 'pincers/support/xpath_builder'
 
-module Pincers::Core
+module Pincers::Core::Helpers
   class Query
 
-    def self.build_from_options(_backend, _selector, _options={}, &_block)
+    def self.build_from_options(_backend, _selector, _options = {}, &_block)
       limit = _options.delete(:limit)
       lang = :xpath
       exp = nil
@@ -38,7 +38,7 @@ module Pincers::Core
       @limit = _limit
     end
 
-    def execute(_elements, _force_limit=nil)
+    def execute(_elements, _force_limit = nil)
       fun = case @lang
       when :xpath then :search_by_xpath
       else :search_by_css end
@@ -67,6 +67,5 @@ module Pincers::Core
         end
       end
     end
-
   end
 end

data/lib/pincers/core/replicas/form.rb

@@ -0,0 +1,43 @@
+require 'pincers/core/helpers/form'
+
+module Pincers::Core::Replicas
+  class Form
+
+    def initialize(_backend, _element)
+      @backend = _backend
+      @form = Pincers::Core::Helpers::Form.new(_backend, _element)
+      @pairs = @form.inputs
+    end
+
+    def set(_name, _value, _replace = true)
+      _name = _name.to_s
+      unset(_name) if _replace
+      @pairs << [_name, _value]
+      _value
+    end
+
+    def unset(_name)
+      _name = _name.to_s
+      @pairs.delete_if { |p| p[0] == _name }
+      self
+    end
+
+    def get(_name, _as_array = false)
+      _name = _name.to_s
+      values = @pairs.select { |p| p[0] == _name }.map { |p| p[1] }
+      _as_array = true if _na me.include? '['
+      return values.first if values.length <= 1 && !_as_array
+      values
+    end
+
+    alias :[] :get
+    alias :[]= :set
+
+    def submit(_http_client=nil)
+      client = _http_client || @backend.as_http_client
+      client.send(@form.method, @form.action) do |request|
+        request.set_form_data(@pairs, @form.encoding)
+      end
+    end
+  end
+end

data/lib/pincers/core/replicas/link.rb

@@ -0,0 +1,18 @@
+require 'pincers/http/utils'
+
+module Pincers::Core::Replicas
+  class Link
+
+    attr_reader :ref
+
+    def initialize(_backend, _element)
+      @backend = _backend
+      @ref = Pincers::Http::Utils.parse_uri _backend.extract_element_attribute(_element, :href)
+    end
+
+    def fetch(_http_client=nil)
+      client = _http_client || @backend.as_http_client
+      client.get(@ref)
+    end
+  end
+end

data/lib/pincers/core/root_context.rb

@@ -7,7 +7,7 @@ module Pincers::Core
     attr_reader :config
 
     def initialize(_backend, _config={})
-      super _backend.document_root, nil, nil
+      super nil, nil, nil
       @backend = _backend
       @config = Pincers.config.values.merge _config
     end
@@ -20,6 +20,14 @@ module Pincers::Core
       true
     end
 
+    def elements
+      @backend.document_root
+    end
+
+    def element
+      @backend.document_root.first
+    end
+
     def document
       @backend.document
     end
@@ -61,10 +69,6 @@ module Pincers::Core
       self
     end
 
-    def download(_url)
-      wrap_errors { backend.fetch_resource _url }
-    end
-
     def forward(_steps=1)
       wrap_errors { backend.navigate_forward _steps }
       self
@@ -76,7 +80,7 @@ module Pincers::Core
     end
 
     def refresh
-      wrap_errors { backend.refresh_document _steps }
+      wrap_errors { backend.refresh_document }
       self
     end
 
@@ -97,6 +101,21 @@ module Pincers::Core
       @config[:advanced_mode]
     end
 
+    def download(_url)
+      as_http_client.get(_url).document
+    end
+
+    def as_http_client(&_block)
+      http_client = backend.as_http_client
+      unless _block.nil?
+        r = _block.call http_client
+        # sync_with http_client # TODO :copy cookies and maybe url?
+        r
+      else
+        http_client
+      end
+    end
+
   private
 
     def wrap_siblings(_elements)

data/lib/pincers/core/search_context.rb

@@ -1,7 +1,9 @@
+require 'pincers/core/helpers/query'
+require 'pincers/core/replicas/link'
+require 'pincers/core/replicas/form'
 require 'pincers/extension/queries'
 require 'pincers/extension/actions'
 require 'pincers/extension/labs'
-require 'pincers/core/query'
 
 module Pincers::Core
   class SearchContext
@@ -97,7 +99,7 @@ module Pincers::Core
         _selector = nil
       end
 
-      query = Query.build_from_options(backend, _selector, _options, &_block)
+      query = Helpers::Query.build_from_options(backend, _selector, _options, &_block)
 
       wrap_errors { wrap_childs query }
     end
@@ -164,6 +166,26 @@ module Pincers::Core
       self
     end
 
+    def submit(&_block)
+      wrap_errors do
+        # _block.call(FormSetter.new _element) if _block
+        backend.submit_form element!
+      end
+    end
+
+    def replicate
+      wrap_errors do
+        case tag
+        when 'form'
+          Replicas::Form.new backend, element!
+        when 'a'
+          Replicas::Link.new backend, element!
+        else
+          raise Pincers::MissingFeatureError, "No replica avaliable for #{tag}"
+        end
+      end
+    end
+
     # context related
 
     def goto
@@ -297,6 +319,5 @@ module Pincers::Core
 
       return false
     end
-
   end
 end

data/lib/pincers/errors.rb

@@ -69,7 +69,10 @@ module Pincers
       @original = _exc
     end
 
-    # IDEA: join backtraces?
+    def backtrace
+      # IDEA: join backtraces?
+      @original.backtrace
+    end
 
   end
 

data/lib/pincers/extension/labs.rb

@@ -4,6 +4,9 @@ module Pincers::Extension
     def readonly(&_block)
       nk_root = Pincers.for_nokogiri to_html
 
+      # nk_root = Pincers.for_chenso http_client
+      # nk_root.backend.push_document current_url, to_html
+
       unless root?
         nk_root = nk_root.search('body > *') # nokogiri will inject valid html structure around contents
       end

data/lib/pincers/factory.rb

@@ -2,7 +2,7 @@ module Pincers
   module Factory
 
     def for_webdriver(_driver=nil, _options={}, &_block)
-      require 'pincers/factories/webdriver'
+      require 'pincers/webdriver/factory'
 
       if _driver.is_a? Hash
         _options = _driver
@@ -11,7 +11,7 @@ module Pincers
 
       _options[:driver] = _driver || config.webdriver_bridge
 
-      context = Factories::Webdriver.new_context _options
+      context = Webdriver::Factory.new_context _options
 
       if _block
         begin
@@ -23,11 +23,16 @@ module Pincers
     end
 
     def for_nokogiri(_document, _options={})
-      require 'pincers/factories/nokogiri'
+      require 'pincers/nokogiri/factory'
 
       _options[:document] = _document
 
-      Factories::Nokogiri.new_context _options
+      Nokogiri::Factory.new_context _options
+    end
+
+    def for_chenso(_options={})
+      require 'pincers/chenso/factory'
+      Chenso::Factory.new_context _options
     end
 
   end

data/lib/pincers/http/base_document.rb

@@ -0,0 +1,20 @@
+module Pincers::Http
+  class BaseDocument
+
+    def uri
+      raise NotImplementedError
+    end
+
+    def content_type
+      raise NotImplementedError
+    end
+
+    def content
+      raise NotImplementedError
+    end
+
+    def save(_path)
+      File.write _path, content
+    end
+  end
+end

data/lib/pincers/http/client.rb

@@ -0,0 +1,134 @@
+require 'forwardable'
+require 'pincers/http/utils'
+require 'pincers/http/session'
+require 'pincers/http/request'
+require 'pincers/http/response_document'
+require 'pincers/http/errors'
+
+module Pincers::Http
+  class Client
+    extend Forwardable
+
+    def self.build_from_options(_options = {})
+      session = Session.new
+      session.proxy = _options[:proxy] if _options.key? :proxy
+      session.headers.merge! _options[:headers] if _options.key? :headers
+      session.redirect_limit = _options[:redirect_limit] if _options.key? :redirect_limit
+
+      client = self.new session, _options[:document]
+      client.freeze if _options[:freeze]
+      client
+    end
+
+    attr_reader :session, :document, :frozen
+    def_delegators :@document, :content_type, :content, :uri
+
+    def initialize(_session, _document={})
+      @session = _session
+      @document = _document
+      @frozen = false
+    end
+
+    def freeze
+      @frozen = true
+    end
+
+    def unfreeze
+      @frozen = false
+    end
+
+    def cookies
+      @session.cookie_jar.cookies
+    end
+
+    def set_cookie(_cookie)
+      @session.cookie_jar.set _cookie
+    end
+
+    def get(_url, _query = nil, &_block)
+      request = build_request :get, _url
+      request.set_query _query unless _query.nil?
+      _block.call request unless _block.nil?
+      perform_in_session request
+    end
+
+    def post(_url, _data = nil, &_block)
+      request = build_request :post, _url
+      load_data_in_request request, _data unless _data.nil?
+      _block.call request unless _block.nil?
+      perform_in_session request
+    end
+
+    def put(_url, _data = nil, &_block)
+      request = build_request :put, _url
+      load_data_in_request request, _data unless _data.nil?
+      _block.call request unless _block.nil?
+      perform_in_session request
+    end
+
+    def delete(_url, &_block)
+      request = build_request :delete, _url
+      _block.call request unless _block.nil?
+      perform_in_session request
+    end
+
+    def fork(_keep_session = true)
+      fork_session = _keep_session ? @session : @session.clone
+      self.class.new fork_session, @document
+    end
+
+    def absolute_uri_for(_url)
+      uri = _url.is_a?(URI) ? _url : Utils.parse_uri(_url)
+      if uri.relative?
+        raise ArgumentError, 'Absolute url was required' if @document.nil?
+        uri = URI.join(@document.uri, uri)
+      end
+      uri
+    end
+
+  private
+
+    SUPPORTED_MODES = [:form, :urlencoded, :multipart]
+
+    def build_request(_type, _url)
+      Request.new _type, absolute_uri_for(_url)
+    end
+
+    def load_data_in_request(_request, _data)
+      if _data.is_a? Hash
+        mode = :form
+        if _data.keys.length == 1 and SUPPORTED_MODES.include? _data.keys.first
+          mode = _data.keys.first
+          _data = _data[mode]
+        end
+
+        case mode
+        when :form
+          _request.set_form_data _data
+        when :urlencoded
+          _request.set_form_data _data, Utils::FORM_URLENCODED
+        when :multipart
+          _request.set_form_data _data, Utils::FORM_MULTIPART
+        end
+      else
+        _request.data = _data.to_s
+      end
+    end
+
+    def perform_in_session(_request)
+      begin
+        new_document = ResponseDocument.new @session.perform _request
+      rescue
+        @document = nil unless frozen
+        raise
+      end
+
+      if frozen
+        self.class.new @session, @document
+      else
+        @document = new_document
+        self
+      end
+    end
+  end
+end