tire 0.1.4 → 0.1.5

data/.gitignore

@@ -7,3 +7,4 @@ coverage/
 scratch/
 examples/*.html
 *.log
+.rvmrc

data/.travis.yml

@@ -0,0 +1,12 @@
+# ---------------------------------------------------------
+# Configuration file for http://travis-ci.org/#!/karmi/tire
+# ---------------------------------------------------------
+
+script: "bundle exec rake test:unit"
+
+rvm:
+  - 1.8.7
+  - 1.9.2
+
+notifications:
+  disable: true

data/README.markdown

@@ -44,14 +44,26 @@ classes for convenient usage in Rails applications.
 
 To test-drive the core _ElasticSearch_ functionality, let's require the gem:
 
+```ruby
     require 'rubygems'
     require 'tire'
+```
 
 Please note that you can copy these snippets from the much more extensive and heavily annotated file
 in [examples/tire-dsl.rb](http://karmi.github.com/tire/).
 
+Also, note that we're doing some heavy JSON lifting here. _Tire_ uses the
+[_multi_json_](https://github.com/intridea/multi_json) gem as a generic JSON wrapper,
+which allows you to use your preferred JSON library. We'll use the
+[_yajl-ruby_](https://github.com/brianmario/yajl-ruby) gem in the full on mode here:
+
+```ruby
+    require 'yajl/json_gem'
+```
+
 OK. Let's create an index named `articles` and store/index some documents:
 
+```ruby
     Tire.index 'articles' do
       delete
       create
@@ -63,11 +75,13 @@ OK. Let's create an index named `articles` and store/index some documents:
 
       refresh
     end
+```
 
 We can also create the index with custom
 [mapping](http://www.elasticsearch.org/guide/reference/api/admin-indices-create-index.html)
 for a specific document type:
 
+```ruby
     Tire.index 'articles' do
       create :mappings => {
         :article => {
@@ -80,10 +94,12 @@ for a specific document type:
         }
       }
     end
+```
 
 Of course, we may have large amounts of data, and it may be impossible or impractical to add them to the index
 one by one. We can use _ElasticSearch's_ [bulk storage](http://www.elasticsearch.org/guide/reference/api/bulk.html):
 
+```ruby
     articles = [
       { :id => '1', :title => 'one'   },
       { :id => '2', :title => 'two'   },
@@ -93,16 +109,19 @@ one by one. We can use _ElasticSearch's_ [bulk storage](http://www.elasticsearch
     Tire.index 'bulk' do
       import articles
     end
+```
 
 We can also easily manipulate the documents before storing them in the index, by passing a block to the
 `import` method:
 
+```ruby
     Tire.index 'bulk' do
       import articles do |documents|
 
         documents.each { |document| document[:title].capitalize! }
       end
     end
+```
 
 OK. Now, let's go search all the data.
 
@@ -110,6 +129,7 @@ We will be searching for articles whose `title` begins with letter “T”, sort
 filtering them for ones tagged “ruby”, and also retrieving some [_facets_](http://www.elasticsearch.org/guide/reference/api/search/facets/)
 from the database:
 
+```ruby
     s = Tire.search 'articles' do
       query do
         string 'title:T*'
@@ -127,20 +147,24 @@ from the database:
         terms :tags
       end
     end
+```
 
 (Of course, we may also page the results with `from` and `size` query options, retrieve only specific fields
 or highlight content matching our query, etc.)
 
 Let's display the results:
 
+```ruby
     s.results.each do |document|
       puts "* #{ document.title } [tags: #{document.tags.join(', ')}]"
     end
 
     # * Two [tags: ruby, python]
+```
 
 Let's display the global facets (distribution of tags across the whole database):
 
+```ruby
     s.results.facets['global-tags']['terms'].each do |f|
       puts "#{f['term'].ljust(10)} #{f['count']}"
     end
@@ -149,11 +173,13 @@ Let's display the global facets (distribution of tags across the whole database)
     # python     1
     # php        1
     # java       1
+```
 
 Now, let's display the facets based on current query (notice that count for articles
 tagged with 'java' is included, even though it's not returned by our query;
 count for articles tagged 'php' is excluded, since they don't match the current query):
 
+```ruby
     s.results.facets['current-tags']['terms'].each do |f|
       puts "#{f['term'].ljust(10)} #{f['count']}"
     end
@@ -161,32 +187,43 @@ count for articles tagged 'php' is excluded, since they don't match the current
     # ruby       1
     # python     1
     # java       1
+```
 
 If configuring the search payload with a block somehow feels too weak for you, you can simply pass
 a Ruby `Hash` (or JSON string) with the query declaration to the `search` method:
 
+```ruby
     Tire.search 'articles', :query => { :fuzzy => { :title => 'Sour' } }
+```
 
 If this sounds like a great idea to you, you are probably able to write your application
 using just `curl`, `sed` and `awk`.
 
 We can display the full query JSON for close inspection:
 
+```ruby
     puts s.to_json
     # {"facets":{"current-tags":{"terms":{"field":"tags"}},"global-tags":{"global":true,"terms":{"field":"tags"}}},"query":{"query_string":{"query":"title:T*"}},"filter":{"terms":{"tags":["ruby"]}},"sort":[{"title":"desc"}]}
+```
 
 Or, better, we can display the corresponding `curl` command to recreate and debug the request in the terminal:
 
+```ruby
     puts s.to_curl
     # curl -X POST "http://localhost:9200/articles/_search?pretty=true" -d '{"facets":{"current-tags":{"terms":{"field":"tags"}},"global-tags":{"global":true,"terms":{"field":"tags"}}},"query":{"query_string":{"query":"title:T*"}},"filter":{"terms":{"tags":["ruby"]}},"sort":[{"title":"desc"}]}'
+```
 
 However, we can simply log every search query (and other requests) in this `curl`-friendly format:
 
+```ruby
     Tire.configure { logger 'elasticsearch.log' }
+```
 
 When you set the log level to _debug_:
 
+```ruby
     Tire.configure { logger 'elasticsearch.log', :level => 'debug' }
+```
 
 the JSON responses are logged as well. This is not a great idea for production environment,
 but it's priceless when you want to paste a complicated transaction to the mailing list or IRC channel.
@@ -217,17 +254,21 @@ example Rails application, with an `ActiveRecord` model and a search form, to pl
 For the rest, let's suppose you have an `Article` class in your Rails application.
 To make it searchable with _Tire_, you just `include` it:
 
+```ruby
     class Article < ActiveRecord::Base
       include Tire::Model::Search
       include Tire::Model::Callbacks
     end
+```
 
 When you now save a record:
 
+```ruby
     Article.create :title =>   "I Love ElasticSearch",
                    :content => "...",
                    :author =>  "Captain Nemo",
                    :published_on => Time.now
+```
 
 it is automatically added into the index, because of the included callbacks.
 (You may want to skip them in special cases, like when your records are indexed via some external
@@ -238,23 +279,28 @@ The document attributes are indexed exactly as when you call the `Article#to_jso
 
 Now you can search the records:
 
+```ruby
     Article.search 'love'
+```
 
 OK. This is where the game stops, often. Not here.
 
 First of all, you may use the full query DSL, as explained above, with filters, sorting,
 advanced facet aggregation, highlighting, etc:
 
+```ruby
     q = 'love'
     Article.search do
       query { string q }
       facet('timeline') { date :published_on, :interval => 'month' }
       sort  { published_on 'desc' }
     end
+```
 
 Dynamic mapping is a godsend when you're prototyping.
 For serious usage, though, you'll definitely want to define a custom mapping for your model:
 
+```ruby
     class Article < ActiveRecord::Base
       include Tire::Model::Search
       include Tire::Model::Callbacks
@@ -267,12 +313,14 @@ For serious usage, though, you'll definitely want to define a custom mapping for
         indexes :published_on, :type => 'date',    :include_in_all => false
       end
     end
+```
 
 In this case, _only_ the defined model attributes are indexed when adding to the index.
 
 When you want tight grip on how your model attributes are added to the index, just
 provide the `to_indexed_json` method yourself:
 
+```ruby
     class Article < ActiveRecord::Base
       include Tire::Model::Search
       include Tire::Model::Callbacks
@@ -293,15 +341,20 @@ provide the `to_indexed_json` method yourself:
       end
 
     end
+```
 
 Note that _Tire_-enhanced models are fully compatible with [`will_paginate`](https://github.com/mislav/will_paginate),
 so you can pass any parameters to the `search` method in the controller, as usual:
 
+```ruby
     @articles = Article.search params[:q], :page => (params[:page] || 1)
+```
 
 OK. Chances are, you have lots of records stored in the underlying database. How will you get them to _ElasticSearch_? Easy:
 
+```ruby
     Article.elasticsearch_index.import Article.all
+```
 
 However, this way, all your records are loaded into memory, serialized into JSON,
 and sent down the wire to _ElasticSearch_. Not practical, you say? You're right.
@@ -309,12 +362,16 @@ and sent down the wire to _ElasticSearch_. Not practical, you say? You're right.
 Provided your model implements some sort of _pagination_ — and it probably does, for so much data —,
 you can just run:
 
+```ruby
     Article.import
+```
 
 In this case, the `Article.paginate` method is called, and your records are sent to the index
 in chunks of 1000. If that number doesn't suit you, just provide a better one:
 
+```ruby
     Article.import :per_page => 100
+```
 
 Any other parameters you provide to the `import` method are passed down to the `paginate` method.
 
@@ -343,6 +400,7 @@ another object mapping library, such as [Mongoid](http://mongoid.org/)?
 
 Well, things stay mostly the same:
 
+```ruby
     class Article
       include Mongoid::Document
       field :title, :type => String
@@ -367,6 +425,7 @@ Well, things stay mostly the same:
     Article.create :title => 'I Love ElasticSearch'
 
     Article.search 'love'
+```
 
 That's kinda nice. But there's more.
 
@@ -387,6 +446,7 @@ advanced distributed features.
 To use the persistence features, you have to include the `Tire::Persistence` module
 in your class and define the properties (analogous to the way you do with CouchDB- or MongoDB-based models):
 
+```ruby
     class Article
       include Tire::Model::Persistence
       include Tire::Model::Search
@@ -398,8 +458,8 @@ in your class and define the properties (analogous to the way you do with CouchD
       property :author
       property :content
       property :published_on
-
     end
+```
 
 Of course, not all validations or `ActionPack` helpers will be available to your models,
 but if you can live with that, you've just got a schema-free, highly-scalable storage

data/examples/tire-dsl.rb

@@ -26,6 +26,14 @@
 #     gem install tire
 #
 require 'rubygems'
+
+# _Tire_ uses the [_multi_json_](https://github.com/intridea/multi_json) gem as a generic JSON library.
+# We want to use the [_yajl-ruby_](https://github.com/brianmario/yajl-ruby) gem in its full on mode here.
+#
+require 'yajl/json_gem'
+
+# Now, let's require the _Tire_ gem itself, and we're ready to go.
+#
 require 'tire'
 
 #### Prerequisites

data/lib/tire/configuration.rb

@@ -20,8 +20,9 @@ module Tire
     end
 
     def self.reset(*properties)
-      reset_variables = properties.empty? ? instance_variables : instance_variables & properties.map { |p| "@#{p}" }
-      reset_variables.each { |v| instance_variable_set(v, nil) }
+      reset_variables = properties.empty? ? instance_variables : instance_variables.map { |p| p.to_s} & \
+                                                                 properties.map         { |p| "@#{p}" }
+      reset_variables.each { |v| instance_variable_set(v.to_sym, nil) }
     end
 
   end

data/lib/tire/dsl.rb

@@ -16,7 +16,7 @@ module Tire
         end
 
         response = Configuration.client.post( "#{Configuration.url}/#{indices}/_search", payload)
-        json     = Yajl::Parser.parse(response.body)
+        json     = MultiJson.decode(response.body)
         results  = Results::Collection.new(json, options)
       end
     rescue Exception => error

data/lib/tire/index.rb

@@ -27,17 +27,17 @@ module Tire
 
     def create(options={})
       @options = options
-      @response = Configuration.client.post "#{Configuration.url}/#{@name}", Yajl::Encoder.encode(options)
+      @response = Configuration.client.post "#{Configuration.url}/#{@name}", MultiJson.encode(options)
     rescue Exception => error
       false
     ensure
-      curl = %Q|curl -X POST "#{Configuration.url}/#{@name}" -d '#{Yajl::Encoder.encode(options, :pretty => true)}'|
+      curl = %Q|curl -X POST "#{Configuration.url}/#{@name}" -d '#{MultiJson.encode(options)}'|
       logged(error, 'CREATE', curl)
     end
 
     def mapping
       @response = Configuration.client.get("#{Configuration.url}/#{@name}/_mapping")
-      JSON.parse(@response.body)[@name]
+      MultiJson.decode(@response.body)[@name]
     end
 
     def store(*args)
@@ -65,7 +65,7 @@ module Tire
       url = id ? "#{Configuration.url}/#{@name}/#{type}/#{id}" : "#{Configuration.url}/#{@name}/#{type}/"
 
       @response = Configuration.client.post url, document
-      JSON.parse(@response.body)
+      MultiJson.decode(@response.body)
 
     rescue Exception => error
       raise
@@ -163,17 +163,17 @@ module Tire
       $VERBOSE = old_verbose
 
       result = Configuration.client.delete "#{Configuration.url}/#{@name}/#{type}/#{id}"
-      JSON.parse(result) if result
+      MultiJson.decode(result) if result
     end
 
     def retrieve(type, id)
       @response = Configuration.client.get "#{Configuration.url}/#{@name}/#{type}/#{id}"
-      h = JSON.parse(@response.body)
+      h = MultiJson.decode(@response.body)
       if Configuration.wrapper == Hash then h
       else
         document = {}
         document = h['_source'] ? document.update( h['_source'] ) : document.update( h['fields'] )
-        document.update('id' => h['_id'], '_version' => h['_version'])
+        document.update('id' => h['_id'], '_type' => h['_type'], '_index' => h['_index'], '_version' => h['_version'])
         Configuration.wrapper.new(document)
       end
     end
@@ -187,6 +187,28 @@ module Tire
       logged(error, '_refresh', curl)
     end
 
+    def open(options={})
+      # TODO: Remove the duplication in the execute > rescue > ensure chain
+      @response = Configuration.client.post "#{Configuration.url}/#{@name}/_open", MultiJson.encode(options)
+      MultiJson.decode(@response.body)['ok']
+    rescue Exception => error
+      raise
+    ensure
+      curl = %Q|curl -X POST "#{Configuration.url}/#{@name}/open"|
+      logged(error, '_open', curl)
+    end
+
+    def close(options={})
+      # TODO: Remove the duplication in the execute > rescue > ensure chain
+      @response = Configuration.client.post "#{Configuration.url}/#{@name}/_close", MultiJson.encode(options)
+      MultiJson.decode(@response.body)['ok']
+    rescue Exception => error
+      raise
+    ensure
+      curl = %Q|curl -X POST "#{Configuration.url}/#{@name}/_close"|
+      logged(error, '_close', curl)
+    end
+
     def logged(error=nil, endpoint='/', curl='')
       if Configuration.logger
 
@@ -196,7 +218,7 @@ module Tire
 
         if Configuration.logger.level.to_s == 'debug'
           # FIXME: Depends on RestClient implementation
-          body = @response ? Yajl::Encoder.encode(@response.body, :pretty => true) : error.http_body rescue ''
+          body = @response ? MultiJson.encode(@response.body, :pretty => true) : error.http_body rescue ''
         else
           body = ''
         end

data/lib/tire/results/collection.rb

@@ -46,6 +46,10 @@ module Tire
         @results.size
       end
 
+      def [](index)
+        @results[index]
+      end
+
       def to_ary
         self
       end

data/lib/tire/results/item.rb

@@ -9,7 +9,7 @@ module Tire
       def initialize(args={})
         raise ArgumentError, "Please pass a Hash-like object" unless args.respond_to?(:each_pair)
         args.each_pair do |key, value|
-          self[key.to_sym] = value.respond_to?(:to_hash) ? self.class.new(value) : value
+          self[key.to_sym] = value.is_a?(Hash) ? self.class.new(value.to_hash) : value
         end
       end
 

data/lib/tire/rubyext/hash.rb

@@ -1,3 +1,8 @@
 class Hash
+
+  def to_json
+    MultiJson.encode(self)
+  end unless respond_to?(:to_json)
+
   alias_method :to_indexed_json, :to_json
 end

data/lib/tire/search/facet.rb

@@ -27,6 +27,10 @@ module Tire
         self
       end
 
+      def range(field, ranges=[], options={})
+        @value = { :range => { :field => field, :ranges => ranges }.update(options) }
+      end
+
       def to_json
         to_hash.to_json
       end

data/lib/tire/search/query.rb

@@ -3,6 +3,7 @@ module Tire
 
     class Query
       def initialize(&block)
+        @value = {}
         self.instance_eval(&block) if block_given?
       end
 
@@ -18,11 +19,17 @@ module Tire
 
       def string(value, options={})
         @value = { :query_string => { :query => value } }
-        @value[:query_string].update( { :default_field => options[:default_field] } ) if options[:default_field]
+        @value[:query_string].update(options)
         # TODO: https://github.com/elasticsearch/elasticsearch/wiki/Query-String-Query
         @value
       end
 
+      def boolean(options={}, &block)
+        # TODO: Try to get rid of the `boolean` method
+        raise ArgumentError, "Please pass a block to boolean query" unless block_given?
+        @value = BooleanQuery.new(options, &block).to_hash
+      end
+
       def all
         @value = { :match_all => {} }
         @value
@@ -32,10 +39,54 @@ module Tire
         @value = { :ids => { :values => values, :type => type }  }
       end
 
+      def to_hash
+        @value
+      end
+
       def to_json
-        @value.to_json
+        to_hash.to_json
+      end
+
+    end
+
+    class BooleanQuery
+
+      # TODO: Try to get rid of multiple `should`, `must`, etc invocations, and wrap queries directly:
+      #
+      #       boolean do
+      #         should do
+      #           string 'foo'
+      #           string 'bar'
+      #         end
+      #       end
+      #
+      # Inherit from Query, implement `encode` method there, and overload it here, so it puts
+      # queries in an Array instead of hash.
+
+      def initialize(options={}, &block)
+        @options = options
+        @value   = {}
+        self.instance_eval(&block)
       end
 
+      def must(&block)
+        (@value[:must] ||= []) << Query.new(&block).to_hash
+        @value
+      end
+
+      def must_not(&block)
+        (@value[:must_not] ||= []) << Query.new(&block).to_hash
+        @value
+      end
+
+      def should(&block)
+        (@value[:should] ||= []) << Query.new(&block).to_hash
+        @value
+      end
+
+      def to_hash
+        { :bool => @value.update(@options) }
+      end
     end
 
   end

data/lib/tire/search.rb

@@ -67,7 +67,7 @@ module Tire
       def perform
         @url      = "#{Configuration.url}/#{indices.join(',')}/_search"
         @response = Configuration.client.post(@url, self.to_json)
-        @json     = Yajl::Parser.parse(@response.body)
+        @json     = MultiJson.decode(@response.body)
         @results  = Results::Collection.new(@json, @options)
         self
       rescue Exception => error
@@ -91,7 +91,7 @@ module Tire
         request.update( { :size => @size } )       if @size
         request.update( { :from => @from } )       if @from
         request.update( { :fields => @fields } )   if @fields
-        Yajl::Encoder.encode(request)
+        MultiJson.encode(request)
       end
 
       def logged(error=nil)
@@ -104,7 +104,7 @@ module Tire
 
           if Configuration.logger.level.to_s == 'debug'
             # FIXME: Depends on RestClient implementation
-            body = @response ? Yajl::Encoder.encode(@json, :pretty => true) : body = error.http_body
+            body = @response ? MultiJson.encode(@json, :pretty => true) : body = error.http_body
           else
             body = ''
           end

data/lib/tire/tasks.rb

@@ -53,7 +53,7 @@ namespace :tire do
 
     unless index.exists?
       puts "[IMPORT] Creating index '#{index.name}' with mapping:",
-           Yajl::Encoder.encode(klass.mapping_to_hash, :pretty => true)
+           MultiJson.encode(klass.mapping_to_hash, :pretty => true)
       index.create :mappings => klass.mapping_to_hash
     end
 

data/lib/tire/version.rb

@@ -1,3 +1,3 @@
 module Tire
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/tire.rb

@@ -1,5 +1,5 @@
 require 'rest_client'
-require 'yajl/json_gem'
+require 'multi_json'
 require 'active_model'
 
 require 'tire/rubyext/hash'

data/test/integration/active_record_searchable_test.rb

@@ -7,9 +7,7 @@ module Tire
 
     def setup
       super
-      File.delete fixtures_path.join('articles.db') rescue nil
-
-      ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => fixtures_path.join('articles.db') )
+      ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" )
 
       ActiveRecord::Migration.verbose = false
       ActiveRecord::Schema.define(:version => 1) do
@@ -67,7 +65,7 @@ module Tire
 
         a.index.refresh
         results = ActiveRecordArticle.search 'test'
-        
+      
         assert_equal 0, results.count
       end