cloud_search 0.0.1 → 0.0.2

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+bin

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.3

data/Guardfile

@@ -0,0 +1,10 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+end
+

data/README.md

@@ -1,3 +1,5 @@
+[![Build Status](https://secure.travis-ci.org/willian/cloud_search.png)](http://travis-ci.org/willian/cloud_search)
+
 # CloudSearch
 
 TODO: Write a gem description
@@ -28,24 +30,22 @@ CloudSearch.configure do |config|
 end
 
 # Search for 'star wars' on 'imdb-movies'
-resp, msg = CloudSearch::Search.request("star wars",
-                                        :actor,
-                                        :director,
-                                        :title,
-                                        :year,
-                                        :text_relevance)
+search = CloudSearch::Search.new
+resp   = search.with_fields(:actor, :director, :title, :year, :text_relevance)
+      .query("star wars")
+      .request
 
 # Or you can search using part of the name
-resp, msg = CloudSearch::Search.request("matri*",
-                                        :actor,
-                                        :title,
-                                        :year,
-                                        :text_relevance)
+search = CloudSearch::Search.new
+resp   = search.with_fields(:actor, :director, :title, :year, :text_relevance)
+      .query("matri*")
+      .request
 
 # Number of results
-resp["found"]
+resp.hits
 
-resp["hit"].each do |result|
+# Results
+res.results.each do |result|
   movie = result["data"]
 
   # List of actors on the movie
@@ -60,6 +60,20 @@ resp["hit"].each do |result|
 end
 ```
 
+## Indexing documents
+
+``` ruby
+document = CloudSearch::Document.new :type => "add", # or "delete"
+                                     :version => 123,
+                                     :id => 680, :lang => :en,
+                                     :fields => {:title => "Lord of the Rings"}
+
+indexer = CloudSearch::Indexer.new
+indexer << document # add as many documents as you want
+indexer.index
+```
+
+
 ## Contributing
 
 1. Fork it

data/cloud_search.gemspec

@@ -24,6 +24,9 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "simplecov" , "~> 0.6"
   gem.add_development_dependency "vcr"       , "~> 2.2"
   gem.add_development_dependency "webmock"
+  gem.add_development_dependency "guard"
+  gem.add_development_dependency "guard-rspec"
+  gem.add_development_dependency "rb-fsevent"
 
   gem.add_dependency "em-http-request"       , "~> 1.0"
 end

data/lib/cloud_search.rb

@@ -1,9 +1,14 @@
 require "em-http"
+require "json"
 require "cloud_search/version"
 
 module CloudSearch
-  autoload :Config, "cloud_search/config"
-  autoload :Search, "cloud_search/search"
+  autoload :Config,          "cloud_search/config"
+  autoload :Searcher,        "cloud_search/searcher"
+  autoload :SearchResponse,  "cloud_search/search_response"
+  autoload :Indexer,         "cloud_search/indexer"
+  autoload :Document,        "cloud_search/document"
+  autoload :InvalidDocument, "cloud_search/invalid_document"
 
   def self.config
     Config.instance

data/lib/cloud_search/config.rb

@@ -21,7 +21,7 @@ module CloudSearch
     end
 
     def document_url
-      @document_url ||= "http://doc-#{self.domain_name}-#{self.domain_id}.#{self.region}.cloudsearch.amazonaws.com"
+      @document_url ||= "http://doc-#{self.domain_name}-#{self.domain_id}.#{self.region}.cloudsearch.amazonaws.com/#{self.api_version}"
     end
 
     def region
@@ -29,7 +29,7 @@ module CloudSearch
     end
 
     def search_url
-      @search_url ||= "http://search-#{self.domain_name}-#{self.domain_id}.#{self.region}.cloudsearch.amazonaws.com"
+      @search_url ||= "http://search-#{self.domain_name}-#{self.domain_id}.#{self.region}.cloudsearch.amazonaws.com/#{self.api_version}"
     end
   end
 end

data/lib/cloud_search/document.rb

@@ -0,0 +1,94 @@
+module CloudSearch
+  class Document
+    MAX_VERSION = 4294967295
+
+    attr_accessor :type, :lang, :fields
+    attr_reader :errors, :id, :version
+
+    def initialize(attributes = {})
+      attributes.each_pair { |key, value| self.__send__("#{key}=", value) }
+      @errors = {}
+    end
+
+    def id=(_id)
+      @id = _id.to_s
+    end
+
+    def version=(_version)
+      begin
+        @version = Integer(_version)
+      rescue ArgumentError, TypeError
+        @version = _version
+      end
+    end
+
+    def valid?
+      @errors = {}
+      run_id_validations
+      run_version_validations
+      run_type_validations
+      run_lang_validations
+      run_fields_validations
+      errors.empty?
+    end
+
+    def as_json
+      {:type => type, :id => id, :version => version}.tap do |hash|
+        hash.merge!(:lang => lang, :fields => fields) if type == "add"
+      end
+    end
+
+    def to_json
+      JSON.unparse as_json
+    end
+
+    private
+
+    def run_id_validations
+      validate :id do |messages|
+        messages << "can't be blank" if blank?(:id)
+        messages << "is invalid" unless blank?(:id) or id =~ /\A[^_][a-z0-9_]+\z/
+      end
+    end
+
+    def run_version_validations
+      validate :version do |messages|
+        messages << "can't be blank" if blank?(:version)
+        messages << "is invalid" unless blank?(:version) or version.to_s =~ /\A[0-9]+\z/
+        messages << "must be less than #{MAX_VERSION + 1}" if messages.empty? and version > MAX_VERSION
+      end
+    end
+
+    def run_type_validations
+      validate :type do |messages|
+        messages << "can't be blank" if blank?(:type)
+        messages << "is invalid" if !blank?(:type) and !%w(add delete).include?(type)
+      end
+    end
+
+    def run_lang_validations
+      validate :lang do |messages|
+        messages << "can't be blank" if blank?(:lang)
+        messages << "is invalid" unless blank?(:lang) or lang =~ /\A[a-z]{2}\z/
+      end
+    end
+
+    def run_fields_validations
+      validate :fields do |messages|
+        messages << "can't be empty" if fields.nil?
+        messages << "must be an instance of Hash" if !fields.nil? and !fields.instance_of?(Hash)
+      end
+    end
+
+    def blank?(attr)
+      self.__send__(attr).to_s.strip.length.zero?
+    end
+
+    def validate(attr, &block)
+      messages = []
+      yield messages
+      errors[attr] = messages unless messages.empty?
+    end
+  end
+end
+

data/lib/cloud_search/indexer.rb

@@ -0,0 +1,54 @@
+module CloudSearch
+  class Indexer
+    def initialize
+      @documents = []
+    end
+
+    def <<(document)
+      raise InvalidDocument.new(document) unless document.valid?
+      @documents << document
+    end
+
+    alias :add :<<
+
+    def documents
+      @documents.freeze
+    end
+
+    def index
+      response, message = nil
+      EM.run do
+        http = EM::HttpRequest.new(url).post :body => documents_json, :head => headers
+
+        http.callback {
+          message  = "#{http.response_header.status} - #{http.response.length} bytes\n#{url}\n"
+          response = JSON.parse(http.response)
+
+          EM.stop
+        }
+
+        http.errback {
+          message = "#{url}\n#{http.error}"
+
+          EM.stop
+        }
+      end
+
+      [response, message]
+    end
+
+    private
+
+    def headers
+      {"Content-Type" => "application/json"}
+    end
+
+    def documents_json
+      JSON.unparse(@documents.map(&:as_json))
+    end
+
+    def url
+      "#{CloudSearch.config.document_url}/documents/batch"
+    end
+  end
+end

data/lib/cloud_search/invalid_document.rb

@@ -0,0 +1,11 @@
+module CloudSearch
+  class InvalidDocument < StandardError
+    def initialize(document)
+      document.valid?
+      error_message = document.errors.map do
+        |attribute, errors| errors.empty? ? nil : "#{attribute}: #{errors.join(", ")}"
+      end.join("; ")
+      super error_message
+    end
+  end
+end

data/lib/cloud_search/search_response.rb

@@ -0,0 +1,23 @@
+module CloudSearch
+  class SearchResponse
+    attr_accessor :body
+    attr_accessor :http_code
+
+    def results
+      (_hits and _hits['hit']) or []
+    end
+
+    def hits
+      (_hits and _hits['found']) or 0
+    end
+
+    def found?
+      hits >= 1
+    end
+
+    private
+    def _hits
+      body and body['hits']
+    end
+  end
+end

data/lib/cloud_search/searcher.rb

@@ -0,0 +1,48 @@
+module CloudSearch
+  class Searcher
+
+    def search
+      response = SearchResponse.new
+
+      EM.run do
+        http = EM::HttpRequest.new(url).get
+
+        http.callback do
+          response.http_code = http.response_header.status
+          response.body = JSON.parse(http.response)
+
+          EM.stop
+        end
+
+        http.errback do
+          response.http_code = http.error
+          response.body = http.response
+
+          EM.stop
+        end
+      end
+
+      response
+    end
+
+    def query(q)
+      @query = q
+      self
+    end
+
+    def with_fields(*fields)
+      @fields = fields
+      self
+    end
+
+    private
+
+    def url
+      url = CloudSearch.config.search_url
+      url+= "/search"
+      url+= "?q=#{CGI.escape(@query)}"
+      url+= "&return-fields=#{CGI.escape(@fields.join(","))}" if @fields.any?
+    end
+  end
+end
+

data/lib/cloud_search/version.rb

@@ -1,3 +1,3 @@
 module CloudSearch
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/cloud_search/config_spec.rb

@@ -15,9 +15,9 @@ describe CloudSearch::Config do
     it { expect(subject.configuration_url).to eql("https://cloudsearch.us-east-1.amazonaws.com") }
     it { expect(subject.domain_id).to eql("pl6u4t3elu7dhsbwaqbsy3y6be") }
     it { expect(subject.domain_name).to eql("imdb-movies") }
-    it { expect(subject.document_url).to eql("http://doc-imdb-movies-pl6u4t3elu7dhsbwaqbsy3y6be.us-east-1.cloudsearch.amazonaws.com") }
+    it { expect(subject.document_url).to eql("http://doc-imdb-movies-pl6u4t3elu7dhsbwaqbsy3y6be.us-east-1.cloudsearch.amazonaws.com/2011-02-01") }
     it { expect(subject.region).to eql("us-east-1") }
-    it { expect(subject.search_url).to eql("http://search-imdb-movies-pl6u4t3elu7dhsbwaqbsy3y6be.us-east-1.cloudsearch.amazonaws.com") }
+    it { expect(subject.search_url).to eql("http://search-imdb-movies-pl6u4t3elu7dhsbwaqbsy3y6be.us-east-1.cloudsearch.amazonaws.com/2011-02-01") }
   end
 end
 

data/spec/cloud_search/document_spec.rb

@@ -0,0 +1,315 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe CloudSearch::Document do
+  it "has a 'id' attribute" do
+    expect(described_class.new(:id => 123).id).to eq("123")
+  end
+
+  it "has a 'type' attribute" do
+    expect(described_class.new(:type => "add").type).to eq("add")
+  end
+
+  it "has a 'version' attribute" do
+    expect(described_class.new(:version => 1234).version).to eq(1234)
+  end
+
+  it "has a 'lang' attribute" do
+    expect(described_class.new(:lang => "en").lang).to eq("en")
+  end
+
+  it "has a 'fields' attribute" do
+    expect(described_class.new(:fields => {:foo => "bar"}).fields).to eq(:foo => "bar")
+  end
+
+  it "clears errors between validations" do
+    document = described_class.new :id => nil
+    expect(document).to_not be_valid
+    document.id = "123"
+    document.valid?
+    expect(document.errors[:id]).to be_nil
+  end
+
+  context "id validation" do
+    it "is invalid without an id" do
+      document = described_class.new
+      document.valid?
+      expect(document.errors[:id]).to eq(["can't be blank"])
+    end
+
+    %w(- ? A & * ç à @ % $ ! = +).each do |char|
+      it "is invalid containing #{char}" do
+        document = described_class.new :id => "1#{char}2"
+        document.valid?
+        expect(document.errors[:id]).to eq(["is invalid"])
+      end
+    end
+
+    it "is invalid starting with an '_'" do
+      document = described_class.new :id => "_abc"
+      document.valid?
+      expect(document.errors[:id]).to eq(["is invalid"])
+    end
+
+    it "is invalid with a string containing only spaces" do
+      document = described_class.new :id => " "
+      document.valid?
+      expect(document.errors[:id]).to eq(["can't be blank"])
+    end
+
+    it "is valid with a valid id" do
+      document = described_class.new :id => "507c54a44a42c408f4000001"
+      document.valid?
+      expect(document.errors[:id]).to be_nil
+    end
+
+    it "is valid with integers" do
+      document = described_class.new :id => 123
+      document.valid?
+      expect(document.errors[:id]).to be_nil
+    end
+
+    it "converts integers to strings" do
+      expect(described_class.new(:id => 123).id).to eq("123")
+    end
+  end
+
+  context "version validation" do
+    it "is invalid with a non numeric value" do
+      document = described_class.new :version => "123a3545656"
+      document.valid?
+      expect(document.errors[:version]).to eq(["is invalid"])
+    end
+
+    it "is invalid with a nil value" do
+      document = described_class.new :version => nil
+      document.valid?
+      expect(document.errors[:version]).to eq(["can't be blank"])
+    end
+
+    it "converts strings to integers" do
+      expect(described_class.new(:version => "123").version).to eq(123)
+    end
+
+    it "does not convert strings to integers if they contain non numerical characters" do
+      expect(described_class.new(:version => "123abc567").version).to eq("123abc567")
+    end
+
+    it "is invalid if value is greater than CloudSearch::Document::MAX_VERSION" do
+      document = described_class.new :version => 4294967296
+      document.valid?
+      expect(document.errors[:version]).to eq(["must be less than 4294967296"])
+    end
+
+    it "is valid with integers greater than zero and less or equal to CloudSearch::Document::MAX_VERSION" do
+      document = described_class.new :version => 4294967295
+      document.valid?
+      expect(document.errors[:version]).to be_nil
+    end
+  end
+
+  context "type validation" do
+    it "is valid if type is 'add'" do
+      document = described_class.new :type => "add"
+      document.valid?
+      expect(document.errors[:type]).to be_nil
+    end
+
+    it "is valid if type is 'delete'" do
+      document = described_class.new :type => "delete"
+      document.valid?
+      expect(document.errors[:type]).to be_nil
+    end
+
+    it "is invalid if type is anything else" do
+      document = described_class.new :type => "wrong"
+      document.valid?
+      expect(document.errors[:type]).to eq(["is invalid"])
+    end
+
+    it "is invalid if type is nil" do
+      document = described_class.new :type => nil
+      document.valid?
+      expect(document.errors[:type]).to eq(["can't be blank"])
+    end
+
+    it "is invalid if type is a blank string" do
+      document = described_class.new :type => "   "
+      document.valid?
+      expect(document.errors[:type]).to eq(["can't be blank"])
+    end
+  end
+
+  context "lang validation" do
+    it "is invalid if lang is nil" do
+      document = described_class.new :lang => nil
+      document.valid?
+      expect(document.errors[:lang]).to eql(["can't be blank"])
+    end
+
+    it "is invalid if lang contains digits" do
+      document = described_class.new :lang => "a1"
+      document.valid?
+      expect(document.errors[:lang]).to eql(["is invalid"])
+    end
+
+    it "is invalid if lang contains more than 2 characters" do
+      document = described_class.new :lang => "abc"
+      document.valid?
+      expect(document.errors[:lang]).to eql(["is invalid"])
+    end
+
+    it "is invalid if lang contains upper case characters" do
+      document = described_class.new :lang => "Ab"
+      document.valid?
+      expect(document.errors[:lang]).to eql(["is invalid"])
+    end
+
+    it "is valid if lang contains 2 lower case characters" do
+      document = described_class.new :lang => "en"
+      document.valid?
+      expect(document.errors[:lang]).to be_nil
+    end
+  end
+
+  context "fields validation" do
+    it "is invalid if fields is nil" do
+      document = described_class.new :fields => nil
+      document.valid?
+      expect(document.errors[:fields]).to eql(["can't be empty"])
+    end
+
+    it "is invalid if fields is not a hash" do
+      document = described_class.new :fields => []
+      document.valid?
+      expect(document.errors[:fields]).to eql(["must be an instance of Hash"])
+    end
+
+    it "is valid with a Hash" do
+      document = described_class.new :fields => {}
+      document.valid?
+      expect(document.errors[:fields]).to be_nil
+    end
+  end
+
+  context "#as_json" do
+    let(:attributes) { {
+      :type    => type,
+      :id      => "123abc",
+      :version => 123456,
+      :lang    => "pt",
+      :fields  => {:foo => "bar"}
+    } }
+    let(:document) { described_class.new attributes }
+    let(:as_json) { document.as_json }
+
+    context "when 'type' is 'add'" do
+      let(:type) { "add" }
+
+      it "includes the 'type' attribute" do
+        expect(as_json[:type]).to eq("add")
+      end
+
+      it "includes the 'id' attribute" do
+        expect(as_json[:id]).to eq("123abc")
+      end
+
+      it "includes the 'version' attribute" do
+        expect(as_json[:version]).to eq(123456)
+      end
+
+      it "includes the 'lang' attribute" do
+        expect(as_json[:lang]).to eq("pt")
+      end
+
+      it "includes the 'fields' attribute" do
+        expect(as_json[:fields]).to eq(:foo => "bar")
+      end
+    end
+
+    context "when 'type' is 'delete'" do
+      let(:type) { "delete" }
+
+      it "includes the 'type' attribute" do
+        expect(as_json[:type]).to eq("delete")
+      end
+
+      it "includes the 'id' attribute" do
+        expect(as_json[:id]).to eq("123abc")
+      end
+
+      it "includes the 'version' attribute" do
+        expect(as_json[:version]).to eq(123456)
+      end
+
+      it "does not include the 'lang' attribute" do
+        expect(as_json[:lang]).to be_nil
+      end
+
+      it "does not include the 'fields' attribute" do
+        expect(as_json[:fields]).to be_nil
+      end
+    end
+  end
+
+  context "#to_json" do
+    let(:attributes) { {
+      :type    => type,
+      :id      => "123abc",
+      :version => 123456,
+      :lang    => "pt",
+      :fields  => {:foo => "bar"}
+    } }
+    let(:parsed_json) { JSON.parse(described_class.new(attributes).to_json) }
+
+    context "when 'type' is 'add'" do
+      let(:type) { "add" }
+
+      it "includes the 'type' attribute" do
+        expect(parsed_json["type"]).to eq("add")
+      end
+
+      it "includes the 'id' attribute" do
+        expect(parsed_json["id"]).to eq("123abc")
+      end
+
+      it "includes the 'version' attribute" do
+        expect(parsed_json["version"]).to eq(123456)
+      end
+
+      it "includes the 'lang' attribute" do
+        expect(parsed_json["lang"]).to eq("pt")
+      end
+
+      it "includes the 'fields' attribute" do
+        expect(parsed_json["fields"]).to eq("foo" => "bar")
+      end
+    end
+
+    context "when 'type' is 'delete'" do
+      let(:type) { "delete" }
+
+      it "includes the 'type' attribute" do
+        expect(parsed_json["type"]).to eq("delete")
+      end
+
+      it "includes the 'id' attribute" do
+        expect(parsed_json["id"]).to eq("123abc")
+      end
+
+      it "includes the 'version' attribute" do
+        expect(parsed_json["version"]).to eq(123456)
+      end
+
+      it "does not include the 'lang' attribute" do
+        expect(parsed_json["lang"]).to be_nil
+      end
+
+      it "does not include the 'fields' attribute" do
+        expect(parsed_json["fields"]).to be_nil
+      end
+    end
+  end
+end
+