scrapula 0.6.3

data/spec/lib/scrapula/page/meta_spec.rb

@@ -0,0 +1,89 @@
+describe Scrapula::Page::Meta do
+
+  let(:page) { Scrapula::Request.new(url: url, method: :get).execute }
+  subject { described_class.new page }
+
+  describe '#initialize' do
+  end
+
+  describe '#[]' do
+    use_vcr_cassette
+
+    let(:url) { 'ogp.me' }
+
+    it 'symbols'
+
+    it 'returns nil when does not include a meta' do
+      expect(subject['yeah']).to eq nil
+    end
+
+    it '"charset" meta' do
+      expect(subject['charset']).to eq 'utf-8'
+    end
+
+    describe 'pragma directives' do
+    end
+
+    describe 'standard names' do
+      use_vcr_cassette
+
+      # FIXME other URL
+      let(:url) { 'http://ruby-doc.org/' }
+
+      it '"application-name" meta' do
+        expect(subject['application-name']).to eq 'Webby'
+      end
+
+      it '"author" meta' do
+        expect(subject['author']).to eq 'Webby'
+      end
+
+      it '"generator" meta' do
+        expect(subject['generator']).to eq 'Webby'
+      end
+
+      it '"description" meta' do
+        expect(subject['description']).to eq 'Fast and searchable Ruby documentation for core, standard libraries, and rubygems. Available in both RDoc and Yard format. Plus, links to tutorials, guides, books, and related sites.'
+      end
+
+      it '"keywords" meta' do
+        expect(subject['keywords']).to eq 'Webby'
+      end
+    end
+
+    describe 'Open Graph' do
+      use_vcr_cassette
+
+      let(:url) { 'ogp.me' }
+
+      it '"og:title" meta' do
+        expect(subject['og:title']).to eq 'Open Graph protocol'
+      end
+
+      it '"og:image:height" meta' do
+        expect(subject['og:image:height']).to eq '300'
+      end
+
+      context 'more than 1 property with the same name' do
+        # An array could be ambiguous
+        xit '"og:image:height" meta' do
+          expect(subject['og:image:height']).to eq '300'
+        end
+      end
+    end
+
+    describe 'other pragma directives' do
+    end
+
+    describe 'other names' do
+      use_vcr_cassette
+
+      let(:url) { 'https://dev.twitter.com/cards/markup' }
+
+      it '"twitter:title" meta' do
+        expect(subject['twitter:title']).to eq 'Cards Markup Tag Reference'
+      end
+    end
+  end
+
+end

data/spec/lib/scrapula/page_spec.rb

@@ -0,0 +1,136 @@
+describe Scrapula::Page do
+
+  let(:query) { '.example' }
+
+  let(:agent_page_double) { instance_double Mechanize::Page }
+
+  subject { described_class.new agent_page_double }
+
+  describe '#initialize' do
+    it 'requires a Mechanize::Page'
+  end
+
+  describe '#scrape' do
+
+    let(:scraper_double) { instance_double Scrapula::Scraper }
+
+    let(:expect_new_scraper) {
+      allow(scraper_double).to receive(:data!)
+      expect(Scrapula::Scraper).to receive(:new).and_return scraper_double
+    }
+
+    it 'creates a scraper for the page' do
+      expect_new_scraper
+      subject.scrape & proc{}
+    end
+    
+    it 'returns the scrapped data' do
+      expect_new_scraper
+      expect(scraper_double).to receive(:data!).and_return example: 'example value'
+
+      result = subject.scrape do
+        example '#example'
+      end
+
+      expect(result).to eq({ example: 'example value' })
+    end
+  end
+
+  describe '#meta!' do
+    it 'returns a Scrapula::Meta object' do
+      subject.meta!
+    end
+  end
+
+  # TODO
+  describe '#metas!' do
+  end
+
+  # TODO
+  describe '#search!' do
+  end
+
+  describe '#at!' do
+
+    let(:page_search_result_double) { instance_double Nokogiri::XML::NodeSet }
+
+    let(:expects_page_search) {
+      allow(agent_page_double).to receive(:at).and_return page_search_result_double
+    }
+
+    it 'requires a query' do
+      expect { subject.at! [] }.to raise_error
+    end
+
+    it 'performs the query' do
+      expects_page_search
+      expect(agent_page_double).to receive(:at)
+
+      subject.at! query
+    end
+
+    context 'without receiving an array with operations'  do
+      it 'returns the query result' do
+        expects_page_search
+
+        expect(subject.at! query).to be page_search_result_double
+      end
+    end
+
+    context 'receiving an array with method names'  do
+      
+      let(:operations)          { [:to_s, :upcase, :length] }
+      let(:example_string)      { "You FOOL! This isn't even my final form!" }
+      let(:transformed_example) { example_string.upcase.length }
+
+      let(:expects_scraping_using_at) {
+        expects_page_search.with query
+        expect(page_search_result_double).to receive(:to_s).and_return example_string
+      }
+
+      context 'but not receiving a block' do
+        it 'applies them in order to the result' do
+          expects_scraping_using_at
+
+          expect(subject.at!(query, operations)).to eq transformed_example
+        end
+      end
+
+      context 'and a block' do
+        it 'applies them in order to the result and yields that value' do
+          expects_scraping_using_at
+
+          expect {|b| subject.at!(query, operations, &b) }.to yield_with_args transformed_example
+        end
+      end
+    end
+    
+  end
+
+  describe '#html!' do
+
+    it 'performs the query' do
+      expect(subject).to receive(:at!).with query, any_args
+      subject.html! query
+    end
+
+    context 'without operations' do
+      it 'adds one for converting to HTML'
+    end
+
+    describe 'with operations' do
+      it 'prepends them for converting first to HTML'
+    end
+
+    describe 'block' do
+    end
+
+  end
+
+  describe '#text!' do
+    it 'performs the query'
+
+    it 'returns the inner text'
+  end
+  
+end

data/spec/lib/scrapula/request_spec.rb

@@ -0,0 +1,91 @@
+describe Scrapula::Request do
+
+  let(:url)  { 'http://example.net' }
+  let(:data) { { url: url, method: 'get', params: [{ q: 'lol' }] } }
+
+  subject { described_class.new data }
+
+  describe '#initialize' do
+
+    describe 'requires an URL' do
+      %w[http https].each do |protocol|
+        context "receives one with the #{protocol.upcase} protocol" do
+          let(:url) { "#{protocol}://example.net" }
+
+          it 'maintains it' do
+            expect(described_class.new(url: url, method: :get).instance_variable_get :@url).to eq url
+          end
+        end
+      end
+
+      context 'receives one without protocol' do
+        let(:url) { 'example.net' }
+
+        it 'adds the HTTP one' do
+          expect(described_class.new(url: url, method: :get).instance_variable_get :@url).to eq "http://#{url}"
+        end
+      end
+    end
+
+    describe 'requires a valid HTTP method' do
+    end
+
+    describe 'can receive parameters' do
+      it 'as an array'
+    end
+    'or not'
+
+    context 'receives a block'  do
+      it "doesn't invoke it now"
+    end
+
+  end
+
+  describe '#execute' do
+
+    let(:agent_double) { instance_double Scrapula::Agent }
+
+    let(:page_double) { instance_double Scrapula::Page }
+
+    let(:expects_agent) {
+      expect(subject).to receive(:agent).and_return agent_double
+    }
+
+    # TODO for each method
+
+    it 'performs an HTTP request using the attributes' do
+      expects_agent
+
+      expect(agent_double).to receive(:get) do |*args|
+        expect(args[0]).to eq data[:url]
+        expect(args[1]).to eq data[:params]
+
+        # TODO other parameters
+      end
+
+      subject.execute
+    end
+
+    it 'returns the received page' do
+      expect(agent_double).to receive(:get).and_return page_double
+      expects_agent
+
+      subject.execute
+    end
+
+  end
+
+  # TODO agent
+  %w[url method params].each do |attribute|
+
+    describe "##{attribute}" do
+      it { is_expected.to respond_to attribute }
+
+      it "returns the established #{attribute} of the current request" do
+        expect(subject.__send__ attribute).to eq data[attribute.to_sym]
+      end
+    end
+
+  end
+  
+end

data/spec/lib/scrapula/s_spec.rb

@@ -0,0 +1,44 @@
+require_relative '../../../lib/scrapula/s'
+
+describe 'S' do
+  
+  describe '()' do
+    it 'implicit GET request' do
+      expect(Scrapula).to receive(:get)
+      S('url')
+    end
+
+    it 'returns'
+
+    context 'with block' do
+    end
+  end
+
+  Scrapula::HTTP_METHODS.each do |http_method|
+    describe ".#{http_method.to_s}" do
+      it "explicit #{http_method.to_s.upcase} request" do
+        expect(Scrapula).to receive(http_method)
+        S.__send__ http_method, 'url'
+      end
+
+      it 'returns'
+
+      context 'with block' do
+      end
+    end
+  end
+
+  shortcuts = { g: 'get' }
+  
+  shortcuts.keys.each do |aka|
+    http_method = shortcuts[aka]
+
+    describe ".#{aka.to_s}" do
+      it "#{aka.to_s} performans a #{http_method.to_s.upcase} request" do
+        expect(Scrapula).to receive(http_method)
+        S.__send__ aka, 'url'
+      end
+    end
+  end
+
+end

data/spec/lib/scrapula/scraper_spec.rb

@@ -0,0 +1,205 @@
+describe Scrapula::Scraper do
+
+  subject { described_class.new page_double }
+
+  let(:page_double) {
+    instance_double Scrapula::Page
+  }
+
+  # TODO better test titles
+  describe '#initialize' do
+
+    xit 'requires a page' do
+    end
+
+    context 'without block' do
+    end
+
+    context 'with block' do
+
+      let(:allow_example_query) {
+        allow(page_double).to receive(:txt!).with('#example').and_return 'example value'
+      }
+
+      let(:allow_out_block) {
+        allow(page_double).to receive(:at!)
+      }
+
+      describe 'without any query' do
+        it 'returns an empty hash' do
+          result = described_class.new page_double do
+          end
+          expect(result.data!).to eq({})
+        end
+      end
+
+      describe 'and inner attribute' do
+
+        # TODO how to know if it's a value or a query and corner cases (using attr! 'value' for assigning?)
+        xcontext 'value' do
+          it 'assigns the value to hash' do
+            result = described_class.new page_double do
+              example 'value'
+            end
+            expected = { example: 'value' }
+
+            expect(result.data!).to eq expected
+          end
+        end
+
+        context 'query' do
+
+          shared_examples :query do
+            before(:each) {
+              expect(page_double).to receive(:txt!).with('.example').and_return expected_value
+            }
+
+            it 'extracts the text' do
+              described_class.new page_double do
+                example '.example'
+              end
+            end
+
+            it 'assigns the result to a hash' do
+              result = described_class.new page_double do
+                example '.example'
+              end
+              expected = { example: expected_value }
+
+              expect(result.data!).to eq expected
+            end
+          end
+
+          context "that doesn't find anything" do
+            it "doesn't crash"
+            it 'returns nil'
+          end
+
+          context 'that returns only one element' do
+            let(:expected_value) { 'example value' }
+
+            include_examples :query
+          end
+
+          # TODO
+          xcontext 'that returns several elements' do
+            let(:expected_value) { %w[value1 value2 value3] }
+
+            include_examples :query
+          end
+        end
+
+        # TODO how to know if it's a value or a query and corner cases (using attr? for returning values)
+        xdescribe 'attributes can be invoked' do
+          it 'returns its previous value' do
+            allow_example_query
+
+            result = described_class.new page_double do
+              example '#example'
+              other example
+            end
+            expected = { example: 'example value', other: 'example value' }
+
+            expect(result.data!).to eq expected
+          end
+        end
+      end
+
+      # TODO how should behaves? ignore the query?
+      xdescribe 'with query and inner query' do
+
+        it 'assigns the query result to a hash' do
+          allow_out_block.with '#outer', '#out'
+          allow_example_query
+
+          result = described_class.new page_double do
+            outer '#outer' do
+              out '#out' do
+                example '#example'
+              end
+            end
+          end
+          expected = { outer: { out: { example: 'example value' } } }
+
+          expect(result.data!).to eq expected
+        end
+        
+      end
+
+      describe 'without query and inner query' do
+
+        it 'assigns the query result to a hash' do
+          allow_out_block
+          allow_example_query
+
+          result = described_class.new page_double do
+            outer do
+              out do
+                example '#example'
+              end
+            end
+          end
+          expected = { outer: { out: { example: 'example value' } } }
+
+          expect(result.data!).to eq expected
+        end
+        
+      end
+    end
+
+    context 'with block with parameters' do
+      it 'yields the page' do
+        expect {|b| described_class.new page_double, &b }.to yield_with_args page_double
+      end
+    end
+    
+  end
+
+  describe '#method_missing' do
+    it 'works only inside a block'
+
+    context 'String as argument' do
+      it 'queries the page '
+    end
+
+    context 'String and an Array as arguments' do
+      it 'queries the page '
+      it 'applies the operations '
+    end
+
+    context 'block' do
+      it 'creates '
+    end
+  end
+
+  describe '#respond_to?' do
+    it 'responds always with `true`' do
+      expect(subject.respond_to? :any).to be true
+      expect(subject.respond_to? 'any.method').to be true
+    end
+  end
+
+  xdescribe '#execute' do
+
+    context 'without block' do
+      it 'returns itself' do
+        expect(subject.execute).to be subject
+      end
+    end
+
+    context 'with block' do
+      it 'returns the scrapped data'
+    end
+
+    context 'block with parameters' do
+      it 'yields the page' do
+        expect {|b| subject.execute &b }.to yield_with_args page_double
+      end
+    end
+      
+  end
+
+  describe '#validate' do
+  end
+  
+end