ssickles-tire 0.4.2

data/lib/tire/search/facet.rb

@@ -0,0 +1,70 @@
+module Tire
+  module Search
+
+    #--
+    # TODO: Implement all elastic search facets (geo, histogram, range, etc)
+    # http://elasticsearch.org/guide/reference/api/search/facets/
+    #++
+
+    class Facet
+
+      def initialize(name, options={}, &block)
+        @name    = name
+        @options = options
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+      end
+
+      def terms(field, options={})
+        size      = options.delete(:size) || 10
+        all_terms = options.delete(:all_terms) || false
+        @value = { :terms => { :field => field, :size => size, :all_terms => all_terms }.update(options) }
+        self
+      end
+
+      def date(field, options={})
+        interval = options.delete(:interval) || 'day'
+        @value = { :date_histogram => { :field => field, :interval => interval }.update(options) }
+        self
+      end
+
+      def range(field, ranges=[], options={})
+        @value = { :range => { :field => field, :ranges => ranges }.update(options) }
+        self
+      end
+
+      def histogram(field, options={})
+        @value = { :histogram => (options.delete(:histogram) || {:field => field}.update(options)) }
+        self
+      end
+
+      def statistical(field, options={})
+        @value = { :statistical => (options.delete(:statistical) || {:field => field}.update(options)) }
+        self
+      end
+
+      def terms_stats(key_field, value_field, options={})
+        @value = { :terms_stats => {:key_field => key_field, :value_field => value_field}.update(options) }
+        self
+      end
+
+      def query(&block)
+        @value = { :query => Query.new(&block).to_hash }
+      end
+
+      def filter(field, value, options={})
+        @value = { :filter => { :term => { field => value }}.update(options) }
+        self
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+
+      def to_hash
+        @value.update @options
+        { @name => @value }
+      end
+    end
+
+  end
+end

data/lib/tire/search/filter.rb

@@ -0,0 +1,28 @@
+module Tire
+  module Search
+
+    # http://www.elasticsearch.org/guide/reference/api/search/filter.html
+    # http://www.elasticsearch.org/guide/reference/query-dsl/
+    #
+    class Filter
+
+      def initialize(type, *options)
+        value = if options.size < 2
+          options.first || {}
+        else
+          options # An +or+ filter encodes multiple filters as an array
+        end
+        @hash = { type => value }
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+
+      def to_hash
+        @hash
+      end
+    end
+
+  end
+end

data/lib/tire/search/highlight.rb

@@ -0,0 +1,37 @@
+module Tire
+  module Search
+
+    # http://www.elasticsearch.org/guide/reference/api/search/highlighting.html
+    #
+    class Highlight
+
+      def initialize(*args)
+        @options  = (args.last.is_a?(Hash) && args.last.delete(:options)) || {}
+        extract_highlight_tags
+        @fields   = args.inject({}) do |result, field|
+          field.is_a?(Hash) ? result.update(field) : result[field.to_sym] = {}; result
+        end
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+
+      def to_hash
+        { :fields => @fields }.update @options
+      end
+
+      private
+
+      def extract_highlight_tags
+        if tag = @options.delete(:tag)
+          @options.update \
+            :pre_tags  => [tag],
+            :post_tags => [tag.to_s.gsub(/^<([a-z]+).*/, '</\1>')]
+        end
+      end
+
+    end
+
+  end
+end

data/lib/tire/search/query.rb

@@ -0,0 +1,151 @@
+module Tire
+  module Search
+
+    class Query
+      def initialize(&block)
+        @value = {}
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+      end
+
+      def term(field, value, options={})
+        query = { field => { :term => value }.update(options) }
+        @value = { :term => query }
+      end
+
+      def terms(field, value, options={})
+        @value = { :terms => { field => value } }
+        @value[:terms].update( { :minimum_match => options[:minimum_match] } ) if options[:minimum_match]
+        @value
+      end
+
+      def range(field, value)
+        @value = { :range => { field => value } }
+      end
+
+      def text(field, value, options={})
+        query_options = { :query => value }.update(options)
+        @value = { :text => { field => query_options } }
+        @value
+      end
+
+      def string(value, options={})
+        @value = { :query_string => { :query => value } }
+        @value[:query_string].update(options)
+        @value
+      end
+
+      def custom_score(options={}, &block)
+        @custom_score ||= Query.new(&block)
+        @value[:custom_score] = options
+        @value[:custom_score].update({:query => @custom_score.to_hash})
+        @value
+      end
+
+      def fuzzy(field, value, options={})
+        query = { field => { :term => value }.update(options) }
+        @value = { :fuzzy => query }
+      end
+
+      def boolean(options={}, &block)
+        @boolean ||= BooleanQuery.new(options)
+        block.arity < 1 ? @boolean.instance_eval(&block) : block.call(@boolean) if block_given?
+        @value[:bool] = @boolean.to_hash
+        @value
+      end
+
+      def filtered(&block)
+        @filtered = FilteredQuery.new
+        block.arity < 1 ? @filtered.instance_eval(&block) : block.call(@filtered) if block_given?
+        @value[:filtered] = @filtered.to_hash
+        @value
+      end
+
+      def all
+        @value = { :match_all => {} }
+        @value
+      end
+
+      def ids(values, type)
+        @value = { :ids => { :values => values, :type => type }  }
+      end
+
+      def to_hash
+        @value
+      end
+
+      def 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   = {}
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+      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
+        @value.update(@options)
+      end
+    end
+
+
+    class FilteredQuery
+      def initialize(&block)
+        @value = {}
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+      end
+
+      def query(options={}, &block)
+        @value[:query] = Query.new(&block).to_hash
+        @value
+      end
+
+      def filter(type, *options)
+        @value[:filter] ||= {}
+        @value[:filter][:and] ||= []
+        @value[:filter][:and] << Filter.new(type, *options).to_hash
+        @value
+      end
+
+      def to_hash
+        @value
+      end
+
+      def to_json
+        to_hash.to_json
+      end
+    end
+
+  end
+end

data/lib/tire/search/scan.rb

@@ -0,0 +1,114 @@
+module Tire
+  module Search
+
+
+    # Performs a "scan/scroll" search request, which obtains a `scroll_id`
+    # and keeps returning documents matching the passed query (or all documents) in batches.
+    #
+    # You may want to iterate over the batches being returned:
+    #
+    #     search = Tire::Search::Scan.new('articles')
+    #     search.each do |results|
+    #       puts results.map(&:title)
+    #     end
+    #
+    # The scan object has a fully Enumerable-compatible interface, so you may
+    # call methods like `map` or `each_with_index` on it.
+    #
+    # To iterate over individual documents, use the `each_document` method:
+    #
+    #     search.each_document do |document|
+    #       puts document.title
+    #     end
+    #
+    # You may limit the result set being returned by a regular Tire DSL query
+    # (or a hash, if you prefer), passed as a second argument:
+    #
+    #     search = Tire::Search::Scan.new('articles') do
+    #       query { term 'author.exact', 'John Smith' }
+    #     end
+    #
+    # The feature is also exposed in the Tire top-level DSL:
+    #
+    #     search = Tire.scan 'articles' do
+    #       query { term 'author.exact', 'John Smith' }
+    #     end
+    #
+    # See ElasticSearch documentation for further reference:
+    #
+    # * http://www.elasticsearch.org/guide/reference/api/search/search-type.html
+    # * http://www.elasticsearch.org/guide/reference/api/search/scroll.html
+    #
+    class Scan
+      include Enumerable
+
+      attr_reader :indices, :options, :search
+
+      def initialize(indices=nil, options={}, &block)
+        @indices = Array(indices)
+        @options = options.update(:search_type => 'scan', :scroll => '10m')
+        @seen    = 0
+        @search  = Search.new(@indices, @options, &block)
+      end
+
+      def url;                Configuration.url + "/_search/scroll";                           end
+      def params;             @options.empty? ? '' : '?' + @options.to_param;                  end
+      def results;            @results  || (__perform; @results);                              end
+      def response;           @response || (__perform; @response);                             end
+      def json;               @json     || (__perform; @json);                                 end
+      def total;              @total    || (__perform; @total);                                end
+      def seen;               @seen     || (__perform; @seen);                                 end
+
+      def scroll_id
+        @scroll_id ||= @search.perform.json['_scroll_id']
+      end
+
+      def each
+        until results.empty?
+          yield results.results
+          __perform
+        end
+      end
+
+      def each_document
+        until results.empty?
+          results.each { |item| yield item }
+          __perform
+        end
+      end
+
+      def size
+        results.size
+      end
+
+      def __perform
+        @response  = Configuration.client.get [url, params].join, scroll_id
+        @json      = MultiJson.decode @response.body
+        @results   = Results::Collection.new @json, @options
+        @total     = @json['hits']['total'].to_i
+        @seen     += @results.size
+        @scroll_id = @json['_scroll_id']
+        return self
+      ensure
+        __logged
+      end
+
+      def to_a;        results; end; alias :to_ary :to_a
+      def to_curl;     %Q|curl -X GET "#{url}?pretty=true" -d '#{@scroll_id}'|; end
+
+      def __logged(error=nil)
+        if Configuration.logger
+          Configuration.logger.log_request 'scroll', nil, to_curl
+
+          took = @json['took']        rescue nil
+          code = @response.code       rescue nil
+          body = "#{@seen}/#{@total} (#{@seen/@total.to_f*100}%)" rescue nil
+
+          Configuration.logger.log_response code || 'N/A', took || 'N/A', body
+        end
+      end
+
+    end
+
+  end
+end

data/lib/tire/search/sort.rb

@@ -0,0 +1,25 @@
+module Tire
+  module Search
+
+    class Sort
+      def initialize(&block)
+        @value = []
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+      end
+
+      def by(name, direction=nil)
+        @value << ( direction ? { name => direction } : name )
+        self
+      end
+
+      def to_ary
+        @value
+      end
+
+      def to_json
+        @value.to_json
+      end
+    end
+
+  end
+end

data/lib/tire/tasks.rb

@@ -0,0 +1,135 @@
+require 'rake'
+require 'benchmark'
+
+namespace :tire do
+
+  full_comment = <<-DESC.gsub(/    /, '')
+    Import data from your model using paginate: rake environment tire:import CLASS='MyModel'.
+
+    Pass params for the `paginate` method:
+      $ rake environment tire:import CLASS='Article' PARAMS='{:page => 1}'
+
+    Force rebuilding the index (delete and create):
+      $ rake environment tire:import CLASS='Article' PARAMS='{:page => 1}' FORCE=1
+
+    Set target index name:
+      $ rake environment tire:import CLASS='Article' INDEX='articles-new'
+  DESC
+  desc full_comment
+  task :import do |t|
+
+    def elapsed_to_human(elapsed)
+      hour = 60*60
+      day  = hour*24
+
+      case elapsed
+      when 0..59
+        "#{sprintf("%1.5f", elapsed)} seconds"
+      when 60..hour-1
+        "#{elapsed/60} minutes and #{elapsed % 60} seconds"
+      when hour..day
+        "#{elapsed/hour} hours and #{elapsed % hour} minutes"
+      else
+        "#{elapsed/hour} hours"
+      end
+    end
+
+    if ENV['CLASS'].to_s == ''
+      puts '='*90, 'USAGE', '='*90, full_comment, ""
+      exit(1)
+    end
+
+    klass  = eval(ENV['CLASS'].to_s)
+    params = eval(ENV['PARAMS'].to_s) || {}
+
+    params.update :method => 'paginate'
+
+    index = Tire::Index.new( ENV['INDEX'] || klass.tire.index.name )
+
+    if ENV['FORCE']
+      puts "[IMPORT] Deleting index '#{index.name}'"
+      index.delete
+    end
+
+    unless index.exists?
+      mapping = defined?(Yajl) ? Yajl::Encoder.encode(klass.tire.mapping_to_hash, :pretty => true) :
+                                 MultiJson.encode(klass.tire.mapping_to_hash)
+      puts "[IMPORT] Creating index '#{index.name}' with mapping:", mapping
+      index.create :mappings => klass.tire.mapping_to_hash, :settings => klass.tire.settings
+    end
+
+    STDOUT.sync = true
+    puts "[IMPORT] Starting import for the '#{ENV['CLASS']}' class"
+    tty_cols = 80
+    total    = klass.count rescue nil
+    offset   = (total.to_s.size*2)+8
+    done     = 0
+
+    STDOUT.puts '-'*tty_cols
+    elapsed = Benchmark.realtime do
+
+      # Add Kaminari-powered "paginate" method
+      #
+      if defined?(Kaminari) && klass.respond_to?(:page)
+        klass.instance_eval do
+          def paginate(options = {})
+            page(options[:page]).per(options[:per_page]).to_a
+          end
+        end
+      end unless klass.respond_to?(:paginate)
+
+      # Import the documents
+      #
+      index.import(klass, params) do |documents|
+
+        if total
+          done += documents.to_a.size
+          # I CAN HAZ PROGREZ BAR LIEK HOMEBRU!
+          percent  = ( (done.to_f / total) * 100 ).to_i
+          glyphs   = ( percent * ( (tty_cols-offset).to_f/100 ) ).to_i
+          STDOUT.print( "#" * glyphs )
+          STDOUT.print( "\r"*tty_cols+"#{done}/#{total} | \e[1m#{percent}%\e[0m " )
+        end
+
+        # Don't forget to return the documents collection back!
+        documents
+      end
+    end
+
+    puts "", '='*80, "Import finished in #{elapsed_to_human(elapsed)}"
+  end
+
+  namespace :index do
+
+    full_comment = <<-DESC.gsub(/      /, '')
+      Delete indices passed in the INDEX environment variable; separate multiple indices by comma.
+
+      Pass name of a single index to drop in the INDEX environmnet variable:
+        $ rake environment tire:index:drop INDEX=articles
+
+      Pass names of multiple indices to drop in the INDEX or INDICES environmnet variable:
+        $ rake environment tire:index:drop INDICES=articles-2011-01,articles-2011-02
+
+    DESC
+    desc full_comment
+    task :drop do
+      index_names = (ENV['INDEX'] || ENV['INDICES']).to_s.split(/,\s*/)
+
+      if index_names.empty?
+        puts '='*90, 'USAGE', '='*90, full_comment, ""
+        exit(1)
+      end
+
+      index_names.each do |name|
+        index = Tire::Index.new(name)
+        print "* Deleting index \e[1m#{index.name}\e[0m... "
+        puts  index.delete ? "\e[32mOK\e[0m" : "\e[31mFAILED\e[0m  | #{index.response.body}"
+      end
+
+      puts ""
+
+    end
+
+  end
+
+end