bataille 0.0.1

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/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'nokogiri'
+
+group :test do
+  gem 'webmock'
+  gem 'rspec'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 kotohata
+
+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,65 @@
+# Bataille
+
+Bataille is smart custom web searcher and analyzer for SEO.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bataille'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bataille
+
+## Usage
+
+
+### Search
+- - -
+
+	results = Bataille::Search.google_search("test") #=> #<Bataille::SearchResult>
+	
+	site = results.first #=> #<Bataille::Site>
+	site.url #=> "test.jp/"
+	site.title #=> "test title"
+	site.description #=> "test description"
+	site.rank #=> 1 //search result page ranking
+	
+or you can specify the number of result, default length is 10
+
+	result = Bataille::Search.google_search("test", 20)
+	result.length # 20
+	
+---
+you can use finder for search result
+
+	results = Bataille::Search.google_search("test")
+	results.where(title: "hoge")
+	results.where(description: "fuga")
+	results.where(url: /com$/)
+	# you can chain finders
+	results.where(title: "hoge").where(url: /com$/)
+	# or
+	results.where({title: "hoge", url: /com$/})
+	
+Bataille::SearchResult#where returns another Bataille::SearchResult instance.
+
+if you want to get the only 1 result, use '#find_by'
+	
+	results.find_by(:url, /com$/) #=> #<Bataille::Site>
+
+
+	
+
+## 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 @@
+require "bundler/gem_tasks"

data/bataille.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bataille/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "bataille"
+  gem.version       = Bataille::VERSION
+  gem.authors       = ["kotohata"]
+  gem.email         = ["t.kotohata@gmail.com"]
+  gem.description   = %q{Bataille is custom web searcher and utility for SEO}
+  gem.summary       = %q{custom web searcher and utilify for SEO}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/bataille/analytics.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+module Bataille
+  class Analytics
+    def initialize(search_result, site)
+      @search_result = search_result
+      @site = site
+    end
+
+    def rate
+      @search_result.detect { |x| x.url == @site.url }.rank
+    end
+  end
+end

data/lib/bataille/category.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+module Bataille
+  class Category
+    attr_accessor :words, :name
+    def initialize(name, words=[])
+      @name = name
+      @words = words
+    end
+
+    def &(category)
+      words = self.words.product(category.words).map { |x| x.join(" ") }
+      name = "#{@name} x #{category.name}"
+      self.class.new(name, words)
+    end
+
+    def google_search(limit=10)
+      ResultSet.new(
+        self.words.map do |word|
+          Search.google_search(word, limit)
+        end,
+        @name
+      )
+    end
+  end
+end

data/lib/bataille/result_set.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+module Bataille
+  class ResultSet
+    attr_accessor :category
+    include Enumerable
+
+    def initialize(results, category)
+      @results = results
+      @categories= []
+    end
+
+    def each
+      @results.each { |r| yield r }
+    end
+  end
+end

data/lib/bataille/search.rb

@@ -0,0 +1,55 @@
+# coding: utf-8
+require 'open-uri'
+
+module Bataille
+  class Search
+    SEARCH_URL_PREFIX = "http://www.google.co.jp/search"
+    MAX_SEARCH_LIMIT = 50
+
+    class << self
+
+      def google_search(word, limit=10)
+        unless (1..MAX_SEARCH_LIMIT).include?(limit)
+          raise LimitError, limit > MAX_SEARCH_LIMIT ? "search results should be under 50" : "something wrong with limit parameter"
+        end
+        results = 0.upto(fetch_times_for(limit)).map do |n|
+          fetch_result(word, n*10)
+        end.inject(:+)
+
+        SearchResult.new(results[0..(limit-1)], word)
+      end
+
+      def fetch_result(word, start=0)
+        charset = nil
+        html = open(search_url(word, start)) do |f|
+          charset = f.charset
+          f.read
+        end
+        doc = Nokogiri::HTML.parse(html, nil, charset)
+        doc.css('.g').each_with_index.map do |result, i|
+          Site.new(
+            rank: i+1+start,
+            keyword: word,
+            title: result.css('.r').text,
+            url: result.css('.kv').search('cite').text,
+            description: result.css('.st').text
+          )
+        end
+      end
+
+      private
+      def search_url(word, start)
+        url = SEARCH_URL_PREFIX + "?q=#{word}"
+        url << "&start=#{start}" if start
+        #url << "&ie=UTF-8"
+        URI.encode(url)
+      end
+
+      def fetch_times_for(n)
+        (n-1)/10 + 1
+      end
+    end
+
+    class LimitError < StandardError; end
+  end
+end

data/lib/bataille/search_result.rb

@@ -0,0 +1,76 @@
+# coding: utf-8
+module Bataille
+  class SearchResult
+    attr_accessor :results, :word
+    include Enumerable
+    def initialize(results, word)
+      @results, @word = results, word
+    end
+
+    def length
+      @results.length
+    end
+
+    def each
+      @results.each { |r| yield r }
+    end
+
+    def limit(n=1)
+      self.class.new(@results[0..n-1])
+    end
+    alias :top :limit
+
+    def where(conditions, opt={})
+      conditions.inject(self) do |result,(key, value)|
+        Bataille::SearchResult.new(finder(key, value, opt), @word)
+      end
+    end
+
+    def find_by(match, site, opt={})
+      finder(match, site, opt).first
+    end
+
+    private
+    def finder(match, site, opt={})
+      #
+      # Bataille::Site instance or String are expected to site.
+      #
+      case site
+      when Bataille::Site
+        target = site.send(match)
+      when String, Regexp
+        target = site
+      else
+        raise ArgumentError
+      end
+
+      #
+      # perfect matching if opt[:perfect] == true
+      # default is ambiguous matching
+      #
+      # when target is regexp object, opt[:perfect] is ignored
+      #
+      if target.instance_of?(Regexp)
+        result = self.find_all { |x| x.send(match) =~ target }
+      else
+        if opt[:perfect]
+          result = self.find_all { |x| x.send(match) == target }
+        else
+          result = self.find_all { |x| x.send(match).include?(target) }
+        end
+      end
+
+      #
+      # if protocol is specified, matches results which have https protocol
+      # default, any protocol matches
+      #
+
+      if opt[:protocol] == "https"
+        result = result.find_all { |x| URI.parse(x.url).scheme == "https" }
+      elsif opt[:protocol] == "http"
+        result = result.find_all { |x| URI.parse(URI.encode(x.url)).scheme.nil? }
+      end
+      result
+    end
+  end
+end

data/lib/bataille/site.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+module Bataille
+  class Site
+    attr_accessor :rank, :title, :url, :description, :word
+
+    def initialize(args={})
+      @rank, @title, @url, @description, @keyword =
+        args[:rank], args[:title], args[:url], args[:description], args[:keyword]
+    end
+
+    def word_count(attr)
+      if [:title, :url, :description].include? attr.to_sym
+        self.send(attr).scan(/#{@keyword}/i).length
+      else
+        raise ArgumentError
+      end
+    end
+  end
+end

data/lib/bataille/version.rb

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

data/lib/bataille.rb

@@ -0,0 +1,10 @@
+require_relative "bataille/version"
+require_relative 'bataille/site'
+require_relative 'bataille/search'
+require_relative 'bataille/category'
+require_relative 'bataille/search_result'
+require_relative 'bataille/result_set'
+require_relative 'bataille/analytics'
+
+module Bataille
+end

data/spec/analytics_spec.rb

@@ -0,0 +1,12 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe Bataille::Analytics do
+  include_context 'make 10 sites'
+  let(:search_result) { Bataille::SearchResult.new(sites, "hoge") }
+  let(:site) { Bataille::Site.new(url: "http://url1.jp") }
+  subject { search_result.analyze(site) }
+
+  describe '#rate' do
+  end
+end

data/spec/category_spec.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe Bataille::Category do
+  let(:category1) { Bataille::Category.new("animal", [ "cat", "dog"] ) }
+  let(:category2) { Bataille::Category.new("country", [ "japan", "america" ]) }
+  subject { category1 & category2 }
+
+  describe "#&" do
+    its(:words) { should =~ ["cat japan", "dog japan", "cat america", "dog america"] }
+    its(:name) { should eq "animal x country" }
+  end
+
+  describe '#google_search' do
+    include_context 'make 10 sites'
+    before { stub_response_for(sites) }
+    its('google_search') { should have(4).results }
+    its('google_search') { should be_instance_of(Bataille::ResultSet) }
+    its('google_search.category') { should eq "animal x country" }
+  end
+end

data/spec/search_result_spec.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe Bataille::SearchResult do
+  include_context 'make 10 sites'
+  subject { Bataille::SearchResult.new(sites, "hoge") }
+
+  describe '#find_by' do
+    context 'when the matching record exists' do
+      let(:site) { Bataille::Site.new(url: "http://url1.jp") }
+      it { subject.find_by(:url, site).should be_instance_of(Bataille::Site) }
+    end
+
+    context 'when the matching record does not exist' do
+      let(:site) { Bataille::Site.new(url: "http://url11.jp") }
+      it { subject.find_by(:url, site).should_not be }
+    end
+
+    context 'when target argument is passed with regexp' do
+      it { subject.find_by(:url, /jp$/).should be }
+      it { subject.find_by(:url, /com$/).should_not be }
+    end
+
+    context 'when target argument is passed with string' do
+      it { subject.find_by(:url, "jp").should be }
+      it { subject.find_by(:url, "com").should_not be }
+      it { subject.find_by(:url, "jp", perfect: true).should_not be }
+    end
+  end
+end

data/spec/search_spec.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe Bataille::Search do
+
+  include_context 'make 10 sites'
+
+  before { stub_response_for(sites) }
+
+  describe '.google_search' do
+    context 'when limit is over 50' do
+      it 'should raise limit error' do
+        expect {
+          Bataille::Search.google_search('hoge', 100)
+        }.to raise_error(Bataille::Search::LimitError)
+      end
+    end
+
+    context 'limit is specified' do
+      subject { Bataille::Search.google_search('hoge', 20) }
+      it { should have(20).results }
+      its('word') { should eq 'hoge' }
+    end
+
+    context 'limit is not specified' do
+      subject { Bataille::Search.google_search('hoge') }
+      it { should have(10).results }
+    end
+  end
+
+  describe '.fetch_result' do
+    subject { Bataille::Search.fetch_result('hoge') }
+    it { should have(10).site }
+    its('first') { should be_instance_of(Bataille::Site) }
+    its('first.url') { should eq "http://url1.jp" }
+    its('last.url') { should eq "http://url10.jp" }
+  end
+
+  describe '.fetch_times_for' do
+    it 'should round up to the nearest whole number' do
+      Bataille::Search.send(:fetch_times_for, 3).should eq 1
+      Bataille::Search.send(:fetch_times_for, 10).should eq 1
+      Bataille::Search.send(:fetch_times_for, 21).should eq 3
+    end
+  end
+end

data/spec/shared_context.rb

@@ -0,0 +1,15 @@
+shared_context 'make 10 sites' do
+  let!(:sites) do
+    10.times.map do |n|
+      double(
+        Bataille::Site,
+        title: "Title#{n+1}",
+        url: "http://url#{n+1}.jp",
+        description: "Description#{n+1}",
+        rank: n+1
+      ).tap do |d|
+        d.stub(:instance_of?, with: Bataille::Site).and_return true
+      end
+    end
+  end
+end

data/spec/site_spec.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe Bataille::Site do
+  subject do
+    Bataille::Site.new(
+      rank: 1,
+      title: "Test Title Test test",
+      url: "http://test.com",
+      description: "test test this is test",
+      keyword: "test"
+    )
+  end
+
+  describe '#word_count' do
+    it { subject.word_count(:description).should eq 3 }
+    it { subject.word_count(:title).should eq 3 }
+    it { subject.word_count(:url).should eq 1 }
+
+    it "should raise argument error" do
+      expect {
+        subject.word_count(:hoge)
+      }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'bataille'
+require 'webmock/rspec'
+require 'shared_context'
+
+def build_dom_for(sites)
+  sites.each.map do |site|
+    <<-CONTENT
+    <result#{site.rank} class="g">
+      <div class="r">#{site.title}</div>
+      <div class="kv">
+        <cite>#{site.url}</cite>
+      </div>
+      <div class="st">#{site.description}</div>
+    </result#{site.rank}>
+    CONTENT
+  end.inject(:+)
+end
+
+def stub_response_for(sites)
+  stub_request(:get, %r!#{Bataille::Search::SEARCH_URL_PREFIX}\?q=[^&]*\&start=[^&]*!).
+    to_return(
+      body: "<html><body>"+build_dom_for(sites)+"</body></html>"
+    )
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: bataille
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- kotohata
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-01 00:00:00.000000000 Z
+dependencies: []
+description: Bataille is custom web searcher and utility for SEO
+email:
+- t.kotohata@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bataille.gemspec
+- lib/bataille.rb
+- lib/bataille/analytics.rb
+- lib/bataille/category.rb
+- lib/bataille/result_set.rb
+- lib/bataille/search.rb
+- lib/bataille/search_result.rb
+- lib/bataille/site.rb
+- lib/bataille/version.rb
+- spec/analytics_spec.rb
+- spec/category_spec.rb
+- spec/search_result_spec.rb
+- spec/search_spec.rb
+- spec/shared_context.rb
+- spec/site_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: custom web searcher and utilify for SEO
+test_files:
+- spec/analytics_spec.rb
+- spec/category_spec.rb
+- spec/search_result_spec.rb
+- spec/search_spec.rb
+- spec/shared_context.rb
+- spec/site_spec.rb
+- spec/spec_helper.rb