swiftype-rb 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in swiftype-rb.gemspec
+gemspec

data/README.md

@@ -0,0 +1,387 @@
+Swiftype Ruby Client (beta)
+===
+
+The official [Swiftype](http://swiftype.com) Ruby client for communicating with the Swiftype API. Learn more about Swiftype by visiting [swiftype.com](http://swiftype.com) and creating an account.
+
+
+Prerequisites
+---
+1. A Swiftype account. Sign up at [swiftype.com](http://swiftype.com).
+2. A compatible Ruby environment.
+
+
+Installation
+---
+
+For now, just clone this repository and then pull in the library:
+
+#### Bundler
+
+	gem 'swiftype-rb', :git => "https://github.com/swiftype/swiftype-rb.git", :require => 'swiftype'
+
+#### Non-Bundler
+
+	git clone https://github.com/swiftype/swiftype-rb.git
+
+	rake build && rake install
+
+	require 'swiftype'
+
+
+Overview
+---
+
+The client has a few basic methods on `Swiftype` for dealing with `Engines`.  Beyond that, you can perform standard (CRUD) operations on any of the resources.
+
+### Resources
+
+#### Engine
+
+`Engines` are the top-level objects in Swiftype.  They have a free-form `name` field that is translated into a `slug` identifier.
+
+#### Document Type
+
+`DocumentTypes` specify the structure of a set of documents in the `Engine` and are the entry point for searches.  There are three types of fields on a `DocumentType`: `:string`, `:text`, `:enum`, `:integer`, `:float`, and `:date`.
+
+`:string` is for short strings that can be matched in both prefix and full-text searches.  _Example: Chapter titles in a book._
+
+`:text` can be long strings.  They are meant for full-text searches only and will not be used for prefix queries.  _Example: Entire text of an essay._
+
+`:enum` are string traits of a document.  They are not analyzed in any way, and thus can be used to filter and sort queries.  _Example: Hardcover or paperback._
+
+`:date` are ISO 8601 compatible time strings.  They can also be used to filter and sort queries.
+
+
+
+#### Document
+
+`Documents` represent all of the pieces of content in an `Engine`.  They are children of a `DocumentType` and conform to its field specification (note: you do *not* need to specify the fields ahead of time, they will be inferred by the contents of a document).  When you perform a search on a `DocumentType`, you will receive `Document` results.  `external_id` is the only required field for a `Document`. It can be any value, such as a numeric ID.
+
+
+
+Basic Usage
+===
+
+Configuration:
+---
+
+Before issuing commands to the API, configure the client with your authentication credentials:
+
+	Swiftype.configure do |config|
+	  config.username = "{YOUR_SWIFTYPE_LOGIN}"
+	  config.password = "{YOUR_SWIFTYPE_PASSWORD}"
+	end
+
+Indexing:
+---
+
+#### Engines:
+
+Search engines are the top-level container for the objects you wish to search, and most sites will have a single engine. The engines themselves contain one or more document types, each of which contain the documents themselves.
+
+Create a search engine:
+
+	engine = Swiftype::Engine.new(:name => 'bookstore')
+	engine.create!
+
+Get a search engine:
+
+	Swiftype::Engine.find('bookstore')
+
+Delete a search engine:
+
+	engine = Swiftype::Engine.find('bookstore')
+	engine.destroy!
+
+
+#### Document Types
+
+Create a `document_type`:
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.create_document_type(:name => 'books')
+
+Get a `document_type`:
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+
+Delete a `document_type`. Deleting a `document_type` will also delete every `document` contained within it:
+
+	engine = Swiftype::Engine.find('bookstore')
+	engine.destroy_document_type('books')
+
+or, alternatively, call destroy on the `document_type` itself:
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+	type.destroy!
+
+
+#### Documents
+
+Create a `document`:
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+	type.create_document({
+		:external_id => '1',
+		:fields => [
+			{:name => 'title', :value => 'Information Retrieval', :type => 'string'},
+			{:name => 'genre', :value => 'non-fiction', :type => 'enum'},
+			{:name => 'author', :value => 'Stefan Buttcher', :type => 'string'},
+			{:name => 'in_stock', :value => true, :type => 'enum'},
+			{:name => 'on_sale', :value => false, :type => 'enum'}
+		]});
+
+Get a `document`:
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+	doc = type.document('1')
+
+Get every `document` within a `document_type`:
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+	type.documents
+
+Update field(s) of a `document`:
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+	doc = type.document('1')
+	doc.update_fields!({:in_stock => false })
+
+or, alternatively, update a `document` without retrieving it first:
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+	type.update_document(:external_id => '1', :fields => { :in_stock => false })
+
+you can also update multiple fields in the same call:
+
+	doc.update_fields({:in_stock => false, :on_sale => true })
+
+Delete a `document`:
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+	doc = type.document('1')
+	doc.destroy!
+
+or, alternatively, delete a `document` without retrieving it first:
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+	type.destroy_document('1')
+
+
+#### Bulk Operations
+
+Bulk operations will allow you to perform rapid indexing updates and avoid the latency overhead of making repeated requests.
+
+Create `document`s in bulk:
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+	type.create_documents([{
+		:external_id => '2',
+		:fields => [
+			{:name => 'title', :value => 'Lucene in Action', :type => 'string'},
+			{:name => 'genre', :value => 'non-fiction', :type => 'enum'},
+			{:name => 'author', :value => 'Michael McCandless', :type => 'string'},
+			{:name => 'in_stock', :value => true, :type => 'enum'},
+			{:name => 'on_sale', :value => false, :type => 'enum'}
+		]},{
+		:external_id => '3',
+		:fields => [
+			{:name => 'title', :value => 'MongoDB in Action', :type => 'string'},
+			{:name => 'genre', :value => 'non-fiction', :type => 'enum'},
+			{:name => 'author', :value => 'Kyle Banker', :type => 'string'},
+			{:name => 'in_stock', :value => true, :type => 'enum'},
+			{:name => 'on_sale', :value => false, :type => 'enum'}
+		]},{
+		:external_id => '4',
+		:fields => [
+			{:name => 'title', :value => 'The Great Gatsby', :type => 'string'},
+			{:name => 'genre', :value => 'fiction', :type => 'enum'},
+			{:name => 'author', :value => 'F. Scott Fitzgerald', :type => 'string'},
+			{:name => 'in_stock', :value => true, :type => 'enum'},
+			{:name => 'on_sale', :value => false, :type => 'enum'}
+		]}
+	])
+
+Update `document`s in bulk:
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+	type.update_documents([
+		{:external_id => '2', :fields => {:in_stock => false, :on_sale => 'false'}},
+	 	{:external_id => '3', :fields => {:in_stock => false, :on_sale => 'false'}}
+	])
+
+Delete `document`s in bulk:
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+	type.destroy_documents(['1','2','3','4'])
+
+
+Searching:
+---
+
+#### Full text search
+
+Search a `document_type` for the query "lucene":
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+	results = type.search("lucene")
+
+You can pass the following options to the search method: `page`, `per_page`, `fetch_fields`, `search_fields`, and `filters`.
+
+* `page` should be an integer of the page of results you want
+* `per_page` should be an integer of the number of results you want from each page
+* `fetch_fields` is a hash containing arrays of the fields you want to have returned for each object of each  document_type
+* `search_fields` is a hash containing arrays of the fields you want to match your query against for each object of each document_type
+* `functional_boosts` is a hash containing boosts that are to be applied to numerically valued fields
+* `filters` is a hash specifying additional conditions that should be applied to your query for each document_type
+
+An example of using search options is as follows:
+
+	results = type.search('lucene', :filters => { :books => { :in_stock => false, :genre => 'fiction' }}, :per_page => 10, :page => 2, :fetch_fields => {:books => ['title','genre']}, :search_fields => {:books => ['title']})
+
+Filters also support datetime range queries. For example, to return only those books with an `updated_at` field between `2012-02-16` and now, use the following filter:
+
+	results = type.search('lucene', :filters => { :books => { :updated_at => '[2012-02-16 TO *]' }})
+
+
+##### Functional Boosts
+
+Functional boosts allow you to boost result scores based on some numerically valued field. For example, you might want your search engine to return the most popular books first, so you would boost results on the `total_purchases` field, which contains an `integer` of the total number of purchases of that book:
+
+	results = type.search('lucene', :functional_boosts => { :books => { :total_purchases => 'logarithmic' }})
+
+There are 3 types of functional boosts:
+
+* `logarithmic` - multiplies the original score by log(numeric_value)
+* `exponential` - multiplies the original score by exp(numeric_value)
+* `linear` - multiplies the original score numeric_value
+
+Functional boosts may be applied to `integer` and `float` valued fields.
+
+#### Autocomplete
+
+Get autocomplete suggestions from a `document_type` for the prefix "act"
+
+	engine = Swiftype::Engine.find('bookstore')
+	type = engine.document_type('books')
+	results = type.suggest("act")
+
+The suggest method also accepts the same options specified for the search method above.
+
+
+Simple Client:
+===
+The Simple Client is a convenience class that gives you basic, direct access to the Swiftype REST API, without mapping each call to the intermediate objects seen in the examples above. These methods will be more performant, because they avoid unnecessary round-trips to the server, but you will also have to provide more information to each call. Choose whatever suites your use-case.
+
+#### Create a Simple Client
+
+	client = Swiftype::Easy.new
+
+#### Search
+
+	results = client.search('bookstore',{SEARCH QUERY} [, OPTIONAL SEARCH OPTIONS])
+
+#### Autocomplete
+
+	results = client.suggest('bookstore',{AUTOCOMPLETE PREFIX QUERY} [, OPTIONAL SEARCH OPTIONS])
+
+#### Engines
+
+	client.engines # retrieves every engine
+	client.create_engine(:name => 'bookstore')
+	client.destroy_engine('bookstore')
+
+#### Document Types
+
+	client.document_types('bookstore')
+	client.create_document_type('bookstore', :name => 'books')
+	client.destroy_document_type('bookstore', 'books')
+
+#### Documents
+
+	# retrieve all documents
+	client.documents('bookstore', 'books')
+
+	# create a document
+	client.create_document('bookstore', 'books', {
+		:external_id => '1',
+		:fields => [
+			{:name => 'title', :value => 'Information Retrieval', :type => 'string'},
+			{:name => 'genre', :value => 'non-fiction', :type => 'enum'},
+			{:name => 'author', :value => 'Stefan Buttcher', :type => 'string'},
+			{:name => 'in_stock', :value => true, :type => 'enum'},
+			{:name => 'on_sale', :value => false, :type => 'enum'}
+		]})
+
+	# create documents in bulk
+	client.create_documents('bookstore', 'books', [{
+		:external_id => '2',
+		:fields => [
+			{:name => 'title', :value => 'Lucene in Action', :type => 'string'},
+			{:name => 'genre', :value => 'non-fiction', :type => 'enum'},
+			{:name => 'author', :value => 'Michael McCandless', :type => 'string'},
+			{:name => 'in_stock', :value => true, :type => 'enum'},
+			{:name => 'on_sale', :value => false, :type => 'enum'}
+		]},{
+		:external_id => '3',
+		:fields => [
+			{:name => 'title', :value => 'MongoDB in Action', :type => 'string'},
+			{:name => 'genre', :value => 'non-fiction', :type => 'enum'},
+			{:name => 'author', :value => 'Kyle Banker', :type => 'string'},
+			{:name => 'in_stock', :value => true, :type => 'enum'},
+			{:name => 'on_sale', :value => false, :type => 'enum'}
+		]}])
+
+	# update a document
+	client.update_document('bookstore','books','1', { :in_stock => false })
+
+	# update documents in bulk
+	client.update_documents('bookstore','books', [
+		{:external_id => '2', :fields => {:in_stock => false}},
+		{:external_id => '3', :fields => {:in_stock => true}}
+	])
+
+	# create or update a document
+	client.create_or_update_document('bookstore', 'books', {
+		:external_id => '1',
+		:fields => [
+			{:name => 'title', :value => 'Information Retrieval', :type => 'string'},
+			{:name => 'genre', :value => 'non-fiction', :type => 'enum'},
+			{:name => 'author', :value => 'Stefan Buttcher', :type => 'string'},
+			{:name => 'in_stock', :value => false, :type => 'enum'},
+			{:name => 'on_sale', :value => true, :type => 'enum'}
+		]})
+
+	# destroy a document
+	client.destroy_document('bookstore','books','1')
+
+	# destroy documents in bulk
+	client.destroy_documents('bookstore','books',['1','2','3'])
+
+
+Todo
+===
+
++ Proper response code handling for non-successful requests.
++ Publish gem to rubygems.org
++ Tests!
+
+
+Questions?
+===
+Get in touch! We would be happy to help you get up and running.
+
+[Quin](mailto:quin@swiftype.com) and [Matt](mailto:matt@swiftype.com) from [Swiftype](http://swiftype.com)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/swiftype/base_model.rb

@@ -0,0 +1,93 @@
+require 'active_support/inflector'
+
+module Swiftype
+  class BaseModel < OpenStruct
+    include Swiftype::Connection
+    include Swiftype::Request
+
+    class << self
+      attr_reader :parent_classes
+
+      def model_name
+        name.split('::').last.underscore
+      end
+
+      def collection_name
+        model_name.pluralize
+      end
+
+      def parents(*parent_classes)
+        @parent_classes = parent_classes
+      end
+    end
+
+    def id
+      self._id
+    end
+
+    def to_hash
+      table
+    end
+
+    def to_json
+      to_hash.to_json
+    end
+
+    def create!
+      update_with! post(path_to_collection, {self.class.model_name => to_hash})
+    end
+
+    def update!
+      update_with! put(path_to_model, {self.class.model_name => to_hash})
+    end
+
+    def destroy!
+      !!delete(path_to_model)
+    end
+
+    def path_to_model
+      "#{raw_path_to_model}.json"
+    end
+
+    def raw_path_to_model
+      path = (self.class.parent_classes || []).inject("") do |_, parent|
+        parent_id = send("#{parent.model_name}_id")
+        _ += "#{parent.collection_name}/#{parent_id}/"
+        _
+      end
+      "#{path}#{self.class.collection_name}/#{identifier}"
+    end
+
+    def path_to_collection
+      "#{raw_path_to_collection}.json"
+    end
+
+    def raw_path_to_collection
+      path = (self.class.parent_classes || []).inject("") do |_, parent|
+        parent_id = send("#{parent.model_name}_id")
+        _ += "#{parent.collection_name}/#{parent_id}/"
+        _
+      end
+      "#{path}#{self.class.collection_name}"
+    end
+
+    def update_with!(hash)
+      hash.each do |k, v|
+        send "#{k}=", v
+      end
+      self
+    end
+
+    def reload
+      update_with! get(path_to_model)
+    end
+
+    def identifier
+      slugged? ? slug : id
+    end
+
+    def slugged?
+      respond_to?(:slug)
+    end
+  end
+end

data/lib/swiftype/client.rb

@@ -0,0 +1,30 @@
+module Swiftype
+  class Client
+    include Swiftype::Connection
+
+    def initialize(options={})
+    end
+
+    module Engine
+      def engine(id)
+        Swiftype::Engine.find(id)
+      end
+
+      def create_engine(attributes)
+        Swiftype::Engine.new(attributes).create!
+      end
+
+      def update_engine(id, attributes)
+        engine = Swiftype::Engine.find(id)
+        engine.merge!(attributes)
+        engine.update!(attributes)
+      end
+
+      def destroy_engine(id)
+        Swiftype::Engine.find(id).destroy!
+      end
+    end
+
+    include Swiftype::Client::Engine
+  end
+end

data/lib/swiftype/configuration.rb

@@ -0,0 +1,42 @@
+require 'swiftype/version'
+
+module Swiftype
+  module Configuration
+    DEFAULT_ENDPOINT = "http://api.swiftype.com/api/v1/"
+    DEFAULT_USER_AGENT = "Swiftype-Ruby/#{Swiftype::VERSION}"
+
+    VALID_OPTIONS_KEYS = [
+      :username,
+      :password,
+      :api_key,
+      :user_agent,
+      :endpoint
+    ]
+
+    attr_accessor *VALID_OPTIONS_KEYS
+
+    def self.extended(base)
+      base.reset
+    end
+
+    def reset
+      self.username = nil
+      self.password = nil
+      self.api_key = nil
+      self.endpoint = DEFAULT_ENDPOINT
+      self.user_agent = DEFAULT_USER_AGENT
+      self
+    end
+
+    def configure
+      yield self
+      self
+    end
+
+    def options
+      options = {}
+      VALID_OPTIONS_KEYS.each{|k| options[k] = send(k)}
+      options
+    end
+  end
+end

data/lib/swiftype/connection.rb

@@ -0,0 +1,47 @@
+module Swiftype
+  module Connection
+    include Swiftype::Request
+
+    def connection
+      raise(InvalidCredentials, "You must supply credentials to Swiftype.configure") unless (Swiftype.username && Swiftype.password ) || Swiftype.api_key
+
+      @connection ||= begin
+        conn = Faraday.new(Swiftype.endpoint) do |b|
+          b.response :raise_error
+          b.use Faraday::Request::UrlEncoded
+          b.use FaradayMiddleware::ParseJson
+          b.use FaradayMiddleware::Mashify
+          b.use ApiResponseMiddleware
+          b.adapter Faraday.default_adapter
+        end
+
+        conn.basic_auth Swiftype.username, Swiftype.password if Swiftype.username && Swiftype.password
+        conn.headers['User-Agent'] = Swiftype.user_agent
+
+        conn
+      end
+    end
+
+    class ApiResponseMiddleware < Faraday::Response::Middleware
+      def on_complete(env)
+        case env[:status]
+        when 200, 201, 204
+          nil
+        when 401
+          raise InvalidCredentials
+        when 404
+          raise NonExistentRecord
+        when 409
+          raise RecordAlreadyExists
+        else
+          raise UnexpectedHTTPException, env[:body]
+        end
+      end
+
+      def initialize(app)
+        super
+        @parser = nil
+      end
+    end
+  end
+end

data/lib/swiftype/document.rb

@@ -0,0 +1,17 @@
+module Swiftype
+  class Document < BaseModel
+    parents Engine, DocumentType
+
+    def engine
+      Engine.find engine_id
+    end
+
+    def document_type
+      DocumentType.find document_type_id
+    end
+
+    def update_fields!(hash)
+      update_with! put("#{raw_path_to_model}/update_fields.json", {:fields => hash})
+    end
+  end
+end

data/lib/swiftype/document_type.rb

@@ -0,0 +1,72 @@
+module Swiftype
+  class DocumentType < BaseModel
+    parents Engine
+    include Swiftype::Search
+    
+    def build_document(params={})
+      Document.new({
+        :document_type_id => id || slug,
+        :engine_id => engine_id
+      }.merge(params))
+    end
+
+    def create_document(params={})
+      doc = build_document(params)
+      doc.create!
+      doc
+    end
+
+    def create_documents(documents=[])
+      post("engines/#{engine_id}/document_types/#{slug}/documents/bulk_create.json", {:documents => documents})
+    end
+
+    def update_documents(documents=[])
+      put("engines/#{engine_id}/document_types/#{slug}/documents/bulk_update.json", {:documents => documents})
+    end
+
+    def update_document(document={})
+      document_id = document[:external_id]
+      put("engines/#{engine_id}/document_types/#{slug}/documents/#{document_id}/update_fields", {:fields => document[:fields]})
+    end
+
+    def destroy_document(document_id)
+      !!delete("engines/#{engine_id}/document_types/#{slug}/documents/#{document_id}")
+    rescue NonExistentRecord
+      false
+    end
+
+    def destroy_documents(document_ids=[])
+      post("engines/#{engine_id}/document_types/#{slug}/documents/bulk_destroy.json", {:documents => document_ids})
+    rescue NonExistentRecord
+      false
+    end
+
+    def document(id)
+      Document.new get("engines/#{engine_id}/document_types/#{slug}/documents/#{id}.json")
+    end
+
+    def engine
+      Engine.find(engine_id)
+    end
+
+    def documents
+      get("engines/#{engine_id}/document_types/#{slug}/documents.json").map { |d| Document.new(d) }
+    end
+
+    def suggest(query, options={})
+      search_params = { :q => query }.merge(parse_suggest_options(options))
+      response = get("engines/#{engine_id}/document_types/#{slug}/suggest.json", search_params)
+      results = {}
+      response['records'].each { |document_type, records| results[document_type] = records.map { |d| Swiftype::Document.new(d) }}
+      results
+    end
+
+    def search(query, options={})
+      search_params = { :q => query }.merge(parse_search_options(options))
+      response = get("engines/#{engine_id}/document_types/#{slug}/search.json", search_params)
+      results = {}
+      response['records'].each { |document_type, records| results[document_type] = records.map { |d| Swiftype::Document.new(d) }}
+      results
+    end
+  end
+end

data/lib/swiftype/easy.rb

@@ -0,0 +1,84 @@
+require 'swiftype/document'
+
+module Swiftype
+  class Easy
+    include Swiftype::Connection
+    include Swiftype::Search
+
+    def initialize(options={})
+    end
+
+    module Engine
+      def engines
+        test_search_module
+        get("engines.json")
+      end
+      def create_engine(engine={})
+        post("engines.json", :engine => engine)
+      end
+      def destroy_engine(engine_id)
+        delete("engines/#{engine_id}")
+      end
+      def suggest(engine_id, query, options={})
+        search_params = { :q => query }.merge(parse_suggest_options(options))
+        response = get("engines/#{engine_id}/suggest.json", search_params)
+        results = {}
+        response['records'].each { |document_type, records| results[document_type] = records.map { |d| Swiftype::Document.new(d) }}
+        results
+      end
+      def search(engine_id, query, options={})
+        search_params = { :q => query }.merge(parse_search_options(options))
+        response = get("engines/#{engine_id}/search.json", search_params)
+        results = {}
+        response['records'].each { |document_type, records| results[document_type] = records.map { |d| Swiftype::Document.new(d) }}
+        results
+      end
+    end
+
+    module DocumentType
+      def document_types(engine_id)
+        get("engines/#{engine_id}/document_types.json")
+      end
+      def create_document_type(engine_id, document_type={})
+        post("engines/#{engine_id}/document_types.json", :document_type => document_type)
+      end
+      def destroy_document_type(engine_id, document_type_id)
+        delete("engines/#{engine_id}/document_types/#{document_type_id}")
+      end
+    end
+
+    module Document
+      def documents(engine_id, document_type_id)
+        get("engines/#{engine_id}/document_types/#{document_type_id}/documents.json")
+      end
+      def create_document(engine_id, document_type_id, document={})
+        post("engines/#{engine_id}/document_types/#{document_type_id}/documents.json", :document => document)
+      end
+      def create_documents(engine_id, document_type_id, documents=[])
+        post("engines/#{engine_id}/document_types/#{document_type_id}/documents/bulk_create.json", :documents => documents)
+      end
+      def destroy_document(engine_id, document_type_id, document_id)
+        delete("engines/#{engine_id}/document_types/#{document_type_id}/documents/#{document_id}")
+      end
+      def destroy_documents(engine_id, document_type_id, document_ids=[])
+        post("engines/#{engine_id}/document_types/#{document_type_id}/documents/bulk_destroy.json", :documents => document_ids)
+      end
+      def create_or_update_document(engine_id, document_type_id, document={})
+        post("engines/#{engine_id}/document_types/#{document_type_id}/documents/create_or_update.json", :document => document)
+      end
+      def create_or_update_documents(engine_id, document_type_id, documents=[])
+        post("engines/#{engine_id}/document_types/#{document_type_id}/documents/bulk_create_or_update.json", :documents => documents)
+      end
+      def update_document(engine_id, document_type_id, document_id, fields)
+        put("engines/#{engine_id}/document_types/#{document_type_id}/documents/#{document_id}/update_fields.json", { :fields => fields })
+      end
+      def update_documents(engine_id, document_type_id, documents={})
+        put("engines/#{engine_id}/document_types/#{document_type_id}/documents/bulk_update.json", { :documents => documents })
+      end
+    end
+
+    include Swiftype::Easy::Engine
+    include Swiftype::Easy::DocumentType
+    include Swiftype::Easy::Document
+  end
+end

data/lib/swiftype/engine.rb

@@ -0,0 +1,33 @@
+module Swiftype
+  class Engine < BaseModel
+    def self.find(id)
+      new Swiftype::Client.new.get("engines/#{id}.json")
+    end
+
+    def build_document_type(params={})
+      DocumentType.new({
+        :engine_id => id
+      }.merge(params))
+    end
+
+    def create_document_type(params={})
+      doc = build_document_type(params)
+      doc.create!
+      doc
+    end
+
+    def destroy_document_type(document_type_name)
+      !!delete("engines/#{slug}/document_types/#{document_type_name}")
+    rescue NonExistentRecord
+      false
+    end
+
+    def document_type(id)
+      DocumentType.new get("engines/#{slug}/document_types/#{id}.json")
+    end
+
+    def document_types
+      get("engines/#{slug}/document_types.json").map { |dt| DocumentType.new(dt) }
+    end
+  end
+end

data/lib/swiftype/exceptions.rb

@@ -0,0 +1,7 @@
+module Swiftype
+  class ClientException < StandardError; end
+  class NonExistentRecord < ClientException; end
+  class RecordAlreadyExists < ClientException; end
+  class InvalidCredentials < ClientException; end
+  class UnexpectedHTTPException < ClientException; end
+end

data/lib/swiftype/request.rb

@@ -0,0 +1,34 @@
+module Swiftype
+  module Request
+    def get(path, params={}, options={})
+      request(:get, path, params, options)
+    end
+
+    def delete(path, params={}, options={})
+      request(:delete, path, params, options)
+    end
+
+    def post(path, params={}, options={})
+      request(:post, path, params, options)
+    end
+
+    def put(path, params={}, options={})
+      request(:put, path, params, options)
+    end
+
+    private
+    def request(method, path, params, options)
+      params.merge!({:auth_token => Swiftype.api_key}) if Swiftype.api_key
+      response = connection.send(method) do |request|
+        case method.to_sym
+        when :delete, :get
+          request.url(path, params)
+        when :post, :put
+          request.path = path
+          request.body = params unless params.empty?
+        end
+      end
+      options[:raw] ? response : response.body
+    end
+  end
+end

data/lib/swiftype/search.rb

@@ -0,0 +1,37 @@
+module Swiftype
+  module Search
+    
+    VALID_SEARCH_OPTIONS = [:fetch_fields, :search_fields, :filters, :per_page, :page, :document_types, :functional_boosts]
+    VALID_SUGGEST_OPTIONS = [:fetch_fields, :search_fields, :filters, :document_types, :functional_boosts]
+
+    def parse_search_options(options)
+      parse_options(options,VALID_SEARCH_OPTIONS)
+    end
+
+    def parse_suggest_options(options)
+      parse_options(options,VALID_SUGGEST_OPTIONS)
+    end
+
+    def parse_options(options,valid_options)
+      parsed_options = {}
+      valid_options.each do |option_name|
+        next unless options[option_name]        
+        encode_single_option(parsed_options,option_name,options[option_name])
+      end
+      parsed_options
+    end
+    
+    # recursive method to encode arrays, hashes, and values the 'Rails' way, to make server-side parsing simpler
+    def encode_single_option(parsed_options,key,value,prefix='')
+      prefix = key if prefix.empty?
+      if value.instance_of?(Hash)
+        value.each { |k,v| encode_single_option(parsed_options,k,v,"#{prefix}[#{k}]") }
+      elsif value.instance_of?(Array)
+        parsed_options["#{prefix}[]"] = value
+      else
+        parsed_options["#{prefix}"] = value
+      end
+    end
+
+  end
+end

data/lib/swiftype/version.rb

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

data/lib/swiftype.rb

@@ -0,0 +1,36 @@
+require 'ostruct'
+require 'faraday'
+require 'faraday_middleware'
+require 'swiftype/exceptions'
+
+module Swiftype
+  autoload :Configuration, 'swiftype/configuration'
+  autoload :Connection, 'swiftype/connection'
+  autoload :Client, 'swiftype/client'
+  autoload :BaseModel, 'swiftype/base_model'
+  autoload :Request, 'swiftype/request'
+  autoload :Search, 'swiftype/search'
+  autoload :Engine, 'swiftype/engine'
+  autoload :DocumentType, 'swiftype/document_type'
+  autoload :Document, 'swiftype/document'
+  autoload :Easy, 'swiftype/easy'
+  
+
+  extend Configuration
+
+  class << self
+    def new(options={})
+      Swiftype::Client.new(options)
+    end
+
+    def method_missing(method, *args, &block)
+      return super unless new.respond_to?(method)
+      new.send(method, *args, &block)
+    end
+
+    def respond_to?(method, include_private=false)
+      new.respond_to?(method, include_private) || super(method, include_private)
+    end
+  end
+end
+

data/swiftype-rb.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "swiftype/version"
+
+Gem::Specification.new do |s|
+  s.name        = "swiftype-rb"
+  s.version     = Swiftype::VERSION
+  s.authors     = ["Quin Hoxie", "Matt Riley"]
+  s.email       = ["team@swiftype.com"]
+  s.homepage    = "http://swiftype.com"
+  s.summary     = %q{Swiftype API Gem}
+  s.description = %q{Official Gem for accessing the Swiftype Search API}
+
+  s.rubyforge_project = "swiftype-rb"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_runtime_dependency "json"
+  s.add_runtime_dependency "faraday", ['~> 0.7.6']
+  s.add_runtime_dependency "faraday_middleware", ['~> 0.8.4']
+  s.add_runtime_dependency "hashie", ['~> 1.2.0']
+  s.add_runtime_dependency 'activesupport', ['>= 2.3.9', '< 4']
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: swiftype-rb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Quin Hoxie
+- Matt Riley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-05 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70265771944420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70265771944420
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: &70265771943900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *70265771943900
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: &70265771943380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *70265771943380
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: &70265771942900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70265771942900
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70265771942400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.9
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70265771942400
+description: Official Gem for accessing the Swiftype Search API
+email:
+- team@swiftype.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/swiftype.rb
+- lib/swiftype/base_model.rb
+- lib/swiftype/client.rb
+- lib/swiftype/configuration.rb
+- lib/swiftype/connection.rb
+- lib/swiftype/document.rb
+- lib/swiftype/document_type.rb
+- lib/swiftype/easy.rb
+- lib/swiftype/engine.rb
+- lib/swiftype/exceptions.rb
+- lib/swiftype/request.rb
+- lib/swiftype/search.rb
+- lib/swiftype/version.rb
+- swiftype-rb.gemspec
+homepage: http://swiftype.com
+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: swiftype-rb
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Swiftype API Gem
+test_files: []