http_reader 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 342e596f1ce05595886d576288111a8d873e5d06
+  data.tar.gz: d1bb9056c0e5ef44fa9185fbb8b97943fffa6639
+SHA512:
+  metadata.gz: 9983010f18f2bee05fadc9a7583c4c1d1740a173191a5bab70129e2d55fdc6da6da2d061a70e39c4fa6daed91337e366a058b6ccebc74a2666fb8d0ef2690d6a
+  data.tar.gz: af912964ef1658a387989e177c4be500a4938aca5df004fc6d203dfcdf469c4f8fe8e7614ccf89cae4d7f67dd89d13835ee7ef0d9c01258110d36275d53135a3

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--require spec_helper
+--format progress
+--no-profile

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+script: bundle exec rake
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in http_reader.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,6 @@
+guard :rspec, cmd: 'rspec' do
+  watch(%r{^lib/(.+).rb$})      { |m| "spec/unit/lib/#{m[1]}_spec.rb" }
+  watch(%r{^spec/(.+).rb$})     { |m| "spec/#{m[1]}.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch('Gemfile')
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Paweł Niemczyk
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,114 @@
+# HttpReader
+
+Read any document on internet and parse to your own format :D
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'http_reader'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install http_reader
+
+## Usage
+
+    engine = HttpReader::Engine.new(opts)
+    engine.read('http://www.google.com')
+
+### Available opts [Hash]
+- **parsers:** list of document parser Classes [ default: [] ]
+- **default_parser:** parser used when none parser was match for url [default: HashPageParser]
+- **http_client:** http_client for downloading pages sources, [default: HTTParty]
+- **browser:** browser_client to processing and download source, [default: Watir::Browser]
+- **logger:** default: Logger
+
+## Examples
+
+### Usage default_parser as HashPageParser
+
+    engine = HttpReader::Engine.new
+    read_opts = {title: 'h1', items: '.content li;array'}
+    engine.read('http://example.org', read_opts)
+
+**Where page body is:**
+
+    <h1>Information</h1>
+    <p>not importante</p>
+    <div class="content">
+        Items: <ul><li>A</li><li>B</li><li>C</li></ul>
+    </div>
+
+**Result should be:**
+
+    {:title=>"Information", :items=>%w{A B C}}
+
+
+### Usage own Parser class 
+
+**Class body:**
+
+    Class TestParser < BasePageParser
+      @pattern = /^((http|https):\/\/www.google.com)$/
+      class << self
+        def browse_actions_for_html(browser, opts = {})
+          div  = browser.div(id: 'als')
+          raise 'Cannot find div' unless div.exists?
+          div.html
+        end
+
+        def parse(response, opts = {})
+          n_body = Nokogiri::HTML(response.body)
+          { text: n_body.css('p').text }
+        end
+
+        def use_browser
+          true
+        end
+      end
+    end
+
+**initializtion:**
+
+    engine = HttpReader::Engine.new(default_parser: TestParser)
+    engine.read('http://www.google.com')
+
+**Or**
+
+    engine = HttpReader::Engine.new(parsers: [TestParser])
+    engine.read('http://www.google.com')
+
+**Or**
+
+    engine = HttpReader::Engine.new
+    engine.read('http://www.google.com', parser: TestParser)
+
+
+
+## More info about syntax
+- [watir-webdriver](https://github.com/watir/watir-webdriver)
+- [nokogiri](http://ruby.bastardsbook.com/chapters/html-parsing/)
+
+## Dependecies
+### Gems
+- nokogiri
+- httparty
+- headless
+- watir-webdriver
+### System components
+- xvfb
+instalation on ubuntu: sudo apt-get install xvfb
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/http_reader.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'http_reader/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'http_reader'
+  spec.version       = HttpReader::VERSION
+  spec.authors       = ['Paweł Niemczyk']
+  spec.email         = ['pniemczyk@o2.pl']
+  spec.description   = %q{Read page body and parse to specific data}
+  spec.summary       = %q{Page parser}
+  spec.homepage      = 'https://github.com/pniemczyk/http_reader'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'httparty', '~> 0.13'
+  spec.add_dependency 'nokogiri', '~> 1.6'
+  spec.add_dependency 'headless', '~> 1.0'
+  spec.add_dependency 'watir-webdriver', '~> 0.6'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake' , '~> 0'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'guard-rspec', '~> 0'
+  spec.add_development_dependency 'coveralls', '~> 0'
+  spec.add_development_dependency 'awesome_print', '~> 0'
+
+  spec.post_install_message = 'Do not forget install xvfb. Have fun !'
+end
+

data/lib/http_reader/base_page_matcher.rb

@@ -0,0 +1,23 @@
+module HttpReader
+  class BasePageMatcher
+    @pattern = /^.*$/
+
+    class << self
+      attr_reader :pattern
+
+      def match(url)
+        !(url =~ pattern).nil?
+      end
+    end
+
+    def read(body)
+      body
+    end
+
+    private
+
+    def pattern
+      self.class.pattern
+    end
+  end
+end

data/lib/http_reader/base_page_parser.rb

@@ -0,0 +1,24 @@
+module HttpReader
+  class BasePageParser
+    @pattern = /^((http|https):\/\/).*$/
+
+    class << self
+      attr_reader :pattern
+
+      def match(url)
+        !(url =~ pattern).nil?
+      end
+
+      def parse(response, opts = {})
+        response.body
+      end
+
+      def browse_actions_for_html(browser, opts = {})
+      end
+
+      def use_browser
+        false
+      end
+    end
+  end
+end

data/lib/http_reader/engine.rb

@@ -0,0 +1,78 @@
+require 'httparty'
+require 'logger'
+require 'watir-webdriver'
+require 'headless'
+
+
+module HttpReader
+  class Engine
+    ReadError       = Class.new(StandardError)
+    DefaultResponse = Struct.new(:body, :code, :message, :headers)
+    attr_reader :parsers, :default_parser, :http_client, :browser, :logger
+
+    def initialize(config = {})
+      @parsers        = config.fetch(:parsers, [])
+      @default_parser = config.fetch(:default_parser, HashPageParser)
+      @http_client    = config.fetch(:http_client, HTTParty)
+      @browser        = config.fetch(:browser, Watir::Browser)
+      @logger         = config.fetch(:logger, Logger.new(STDOUT))
+    end
+
+    def read(url, opts = {})
+      parser       = opts[:parser] || find_parser(url)
+      response = if parser.use_browser
+        browse_opts  = opts.fetch(:browse_opts, {})
+        browse(url, parser, browse_opts)
+      else
+        request_opts = opts.fetch(:request_opts, {})
+        request(url, request_opts)
+      end
+
+      parse_opts   = opts.fetch(:parse_opts, {})
+      parser.parse(response, parse_opts)
+    rescue => e
+      log_error('read', e, "url: #{url}, opts: #{opts.to_json}")
+      raise ReadError.new(e.message)
+    end
+
+    private
+
+    def find_parser(url)
+      parsers.each do |parser|
+        return parser if parser.match(url)
+      end
+
+      default_parser
+    end
+
+    def browse(url, parser, opts = {})
+      html = nil
+      headless.start
+      b    = browser.start(url)
+      html = parser.browse_actions_for_html(b, opts)
+      b.close
+      headless.destroy
+      DefaultResponse.new(html, 200, opts[:message] || "success")
+    rescue => e
+      log_error('browse', e)
+      DefaultResponse.new(html, 500, e.message)
+    end
+
+    def request(url, opts = {})
+      method  = opts.fetch(:method, :get)
+      options = opts.fetch(:options, {})
+      http_client.public_send(method, url, options)
+    rescue => e
+      log_error('request', e)
+      DefaultResponse.new(nil, 500, e.message)
+    end
+
+    def headless
+      @headless ||= Headless.new
+    end
+
+    def log_error(method, ex, info = nil)
+      logger.error("HttpReader::Engine##{method} - #{ex.message} #{info}")
+    end
+  end
+end

data/lib/http_reader/hash_page_parser.rb

@@ -0,0 +1,35 @@
+require 'nokogiri'
+
+module HttpReader
+  class HashPageParser < BasePageParser
+    KEY_IDX        = 0
+    SELECTOR_IDX   = 1
+    TYPE_SEPARATOR = ';'
+
+    @pattern = /^((http|https):\/\/).*$/
+
+    def self.parse(response, opts = {})
+      page = Nokogiri::HTML(response.body)
+      hash = opts.inject({}) do |h, item|
+        key, value = prepare_key_value(page, item)
+        h[key]     = value
+        h
+      end
+    end
+
+    private
+
+    def self.prepare_key_value(page, item)
+      key                = item[KEY_IDX]
+      selector, is_array = prepare_selector(item[SELECTOR_IDX])
+      result = page.css(selector)
+      value  = result.map(&:text)
+      [key, is_array ? value : value.first]
+    end
+
+    def self.prepare_selector(value)
+      selector, is_array = value.split(TYPE_SEPARATOR)
+      [selector, is_array.to_s.downcase == 'array']
+    end
+  end
+end

data/lib/http_reader/version.rb

@@ -0,0 +1,3 @@
+module HttpReader
+  VERSION = "0.0.1"
+end

data/lib/http_reader.rb

@@ -0,0 +1,7 @@
+require 'http_reader/version'
+require 'http_reader/base_page_parser'
+require 'http_reader/hash_page_parser'
+require 'http_reader/engine'
+
+module HttpReader
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'bundler/setup'
+require 'awesome_print'
+Bundler.setup
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'http_reader'
+
+RSpec.configure do |config|
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  config.default_formatter = 'doc' if config.files_to_run.one?
+
+  config.profile_examples = 10
+  config.order = :random
+
+  Kernel.srand config.seed
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+end

data/spec/unit/lib/http_reader/base_page_parser_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe HttpReader::BasePageParser do
+  subject { described_class }
+
+  let(:pattern) { /^((http|https):\/\/).*$/ }
+
+  context 'self' do
+    it '#pattern cover every url' do
+      expect(subject.pattern).to eq pattern
+    end
+
+    context '#match' do
+      it 'returns true for url string' do
+        expect(subject.match('http://some_url')).to eq true
+      end
+
+      it 'returns false for non url string' do
+        expect(subject.match('some_fake_url')).to eq false
+      end
+    end
+
+    context '#parse' do
+      let(:body) { 'test_body' }
+      let(:response) { double('response', body: body) }
+      it 'returns body' do
+        expect(subject.parse(response)).to eq body
+      end
+    end
+  end
+end

data/spec/unit/lib/http_reader/engine_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper'
+
+
+describe HttpReader::Engine do
+  let(:default_parser) { double('default_parser') }
+  let(:parsers)        { [] }
+  let(:http_client)    { double('HTTParty') }
+  let(:browser)        { double('Watir::Browser') }
+  let(:logger)         { double('Logger') }
+  let(:headless)       { double('Headless') }
+
+  let(:init_opts) do
+    {
+      parsers: parsers,
+      default_parser: default_parser,
+      http_client: http_client,
+      browser: browser,
+      logger: logger
+    }
+  end
+
+  let(:test_url)       { 'http://localhost/test' }
+  let(:active_browser) { double('active_browser') }
+
+  subject { described_class.new(init_opts) }
+  context '#initialize' do
+    context 'init #parsers' do
+      context 'default' do
+        let(:init_opts) { {} }
+        it 'should eq []' do
+          expect(subject.parsers).to eq []
+        end
+      end
+      context 'optional' do
+        it 'can be set as array of parsers' do
+          expect(subject.parsers).to eq parsers
+        end
+      end
+    end
+    context 'init #default_parser' do
+      context 'default' do
+        let(:init_opts) { {} }
+        it 'should eq HashPageParser' do
+          expect(subject.default_parser).to eq HttpReader::HashPageParser
+        end
+      end
+      context 'optional' do
+        it 'can be set new default_parser' do
+          expect(subject.default_parser).to eq default_parser
+        end
+      end
+    end
+    context 'init #http_client' do
+      context 'default' do
+        let(:init_opts) { {} }
+        it 'should eq HTTParty' do
+          expect(subject.http_client).to eq HTTParty
+        end
+      end
+      context 'optional' do
+        it 'can be set new http_client' do
+          expect(subject.http_client).to eq http_client
+        end
+      end
+    end
+    context 'init #browser' do
+      context 'default' do
+        let(:init_opts) { {} }
+        it 'should eq Watir::Browser' do
+          expect(subject.browser).to eq Watir::Browser
+        end
+      end
+      context 'optional' do
+        it 'can be set new browser' do
+          expect(subject.browser).to eq browser
+        end
+      end
+    end
+    context 'init #logger' do
+      context 'default' do
+        let(:init_opts) { {} }
+        it 'should eq Logger' do
+          expect(subject.logger).to be_a Logger
+        end
+      end
+      context 'optional' do
+        it 'can be set new browser' do
+          expect(subject.logger).to eq logger
+        end
+      end
+    end
+  end
+
+  context '#read' do
+    context 'should use parser' do
+      let(:parser_in_opts) { double('parser_in_opts') }
+      let(:response)       { double('response', body: 'body')}
+      it 'from provided opts' do
+        expect(parser_in_opts).to receive(:use_browser).and_return(false)
+        expect(http_client).to receive(:get)
+                               .with(test_url, {})
+                               .and_return(response)
+        expect(parser_in_opts).to receive(:parse).with(response, {})
+        subject.read(test_url, parser: parser_in_opts)
+      end
+
+      it 'default when no parsers are available' do
+        expect(default_parser).to receive(:use_browser).and_return(false)
+        expect(http_client).to receive(:get)
+                               .with(test_url, {})
+                               .and_return(response)
+        expect(default_parser).to receive(:parse).with(response, {})
+        subject.read(test_url)
+      end
+
+      context 'which' do
+        let(:parser_one) { double('parser_one') }
+        let(:parser_two) { double('parser_two') }
+        let(:parsers)        { [parser_one, parser_two] }
+        it 'match as first with url' do
+          expect(parser_one).to receive(:match).with(test_url).and_return(false)
+          expect(parser_two).to receive(:match).with(test_url).and_return(true)
+          expect(parser_two).to receive(:use_browser).and_return(false)
+          expect(http_client).to receive(:get)
+                                 .with(test_url, {})
+                                 .and_return(response)
+          expect(parser_two).to receive(:parse).with(response, {})
+          subject.read(test_url)
+        end
+
+        it 'is default_parser when no parser match' do
+          expect(parser_one).to receive(:match).with(test_url).and_return(false)
+          expect(parser_two).to receive(:match).with(test_url).and_return(false)
+          expect(default_parser).to receive(:use_browser).and_return(false)
+          expect(http_client).to receive(:get)
+                                 .with(test_url, {})
+                                 .and_return(response)
+          expect(default_parser).to receive(:parse).with(response, {})
+          subject.read(test_url)
+        end
+      end
+    end
+
+    it 'should provide parse_opts to #parser#parse method' do
+      parse_opts =  { title: 'h1' }
+      response   = double('response', body: 'body')
+      expect(default_parser).to receive(:use_browser).and_return(false)
+      expect(http_client).to receive(:get)
+                             .with(test_url, {})
+                             .and_return(response)
+      expect(default_parser).to receive(:parse).with(response, parse_opts)
+      subject.read(test_url, parse_opts: parse_opts)
+    end
+
+    it 'should provide request_opts to request method' do
+      http_client_method = :post
+      request_opts       = { method: http_client_method, options: { body: {token: '123'}}}
+      response   = double('response', body: 'body')
+      expect(default_parser).to receive(:use_browser).and_return(false)
+      expect(http_client).to receive(http_client_method)
+                             .with(test_url, request_opts[:options])
+                             .and_return(response)
+      expect(default_parser).to receive(:parse).with(response, {})
+      subject.read(test_url, request_opts: request_opts)
+    end
+
+    it 'should provide request_opts to request method' do
+      message      = 'done'
+      browse_opts  = { process: :continue, message: message}
+      browser_body = "body"
+      response = described_class::DefaultResponse.new(browser_body, 200, message)
+      expect(Headless).to receive(:new).and_return(headless)
+      expect(headless).to receive(:start)
+      expect(default_parser).to receive(:use_browser).and_return(true)
+      expect(browser).to receive(:start).with(test_url).and_return(active_browser)
+      expect(default_parser).to receive(:browse_actions_for_html)
+                                .with(active_browser, browse_opts)
+                                .and_return(browser_body)
+      expect(active_browser).to receive(:close)
+      expect(headless).to receive(:destroy)
+      expect(default_parser).to receive(:parse).with(response, {})
+
+      subject.read(test_url, browse_opts: browse_opts)
+    end
+
+    context 'on raise errors' do
+
+      it 'raise ReadError' do
+        error_msg = 'HttpReader::Engine#read - Bad url: http://localhost/test, opts: {}'
+        expect(default_parser).to receive(:use_browser).and_raise('Bad')
+        expect(logger).to receive(:error).with(error_msg)
+        expect { subject.read(test_url) }.to raise_error(described_class::ReadError, 'Bad')
+      end
+
+      it 'in #request' do
+        error_msg = 'HttpReader::Engine#request - Bad '
+        response  = described_class::DefaultResponse.new(nil, 500, 'Bad')
+        expect(default_parser).to receive(:use_browser).and_return(false)
+        expect(http_client).to receive(:get).with(test_url, {}).and_raise('Bad')
+        expect(default_parser).to receive(:parse).with(response, {})
+        expect(logger).to receive(:error).with(error_msg)
+        subject.read(test_url)
+      end
+
+      it 'in #browse' do
+        error_msg = 'HttpReader::Engine#browse - Bad '
+        response  = described_class::DefaultResponse.new(nil, 500, 'Bad')
+        expect(default_parser).to receive(:use_browser).and_return(true)
+        expect(browser).to receive(:start).with(test_url).and_raise('Bad')
+        expect(default_parser).to receive(:parse).with(response, {})
+        expect(logger).to receive(:error).with(error_msg)
+        subject.read(test_url)
+      end
+    end
+  end
+end

data/spec/unit/lib/http_reader/hash_page_parser_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe HttpReader::HashPageParser do
+  subject { described_class }
+
+  let(:pattern) { /^((http|https):\/\/).*$/ }
+
+  context 'self' do
+    it '#pattern cover every url' do
+      expect(subject.pattern).to eq pattern
+    end
+
+    context '#match' do
+      it 'returns true for url string' do
+        expect(subject.match('http://some_url')).to eq true
+      end
+
+      it 'returns false for non url string' do
+        expect(subject.match('some_fake_url')).to eq false
+      end
+    end
+
+    context '#parse' do
+      let(:body)     { '<h1>Information</h1><p>not importante</p><div class="content">Items: <ul><li>A</li><li>B</li><li>C</li></ul></div>' }
+      let(:opts)     { {title: 'h1', items: '.content li;array'} }
+      let(:response) { double('response', body: body) }
+      let(:result)   { {:title=>"Information", :items=>%w{A B C}} }
+      it 'returns body' do
+        expect(subject.parse(response, opts)).to eq result
+      end
+    end
+  end
+end

data/spec/unit/lib/http_reader_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe HttpReader do
+
+end

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: http_reader
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Paweł Niemczyk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: headless
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: watir-webdriver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Read page body and parse to specific data
+email:
+- pniemczyk@o2.pl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- http_reader.gemspec
+- lib/http_reader.rb
+- lib/http_reader/base_page_matcher.rb
+- lib/http_reader/base_page_parser.rb
+- lib/http_reader/engine.rb
+- lib/http_reader/hash_page_parser.rb
+- lib/http_reader/version.rb
+- spec/spec_helper.rb
+- spec/unit/lib/http_reader/base_page_parser_spec.rb
+- spec/unit/lib/http_reader/engine_spec.rb
+- spec/unit/lib/http_reader/hash_page_parser_spec.rb
+- spec/unit/lib/http_reader_spec.rb
+homepage: https://github.com/pniemczyk/http_reader
+licenses:
+- MIT
+metadata: {}
+post_install_message: Do not forget install xvfb. Have fun !
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Page parser
+test_files:
+- spec/spec_helper.rb
+- spec/unit/lib/http_reader/base_page_parser_spec.rb
+- spec/unit/lib/http_reader/engine_spec.rb
+- spec/unit/lib/http_reader/hash_page_parser_spec.rb
+- spec/unit/lib/http_reader_spec.rb
+has_rdoc: