tire 0.1.0

data/lib/tire/results/item.rb

@@ -0,0 +1,39 @@
+module Tire
+  module Results
+
+    class Item < Hash
+
+      # Create new instance, recursively converting all Hashes to Item
+      # and leaving everything else alone.
+      #
+      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
+        end
+      end
+
+      # Delegate method to a key in underlying hash, if present,
+      # otherwise return +nil+.
+      #
+      def method_missing(method_name, *arguments)
+        self.has_key?(method_name.to_sym) ? self[method_name.to_sym] : nil
+      end
+
+      # Get ID
+      #
+      def id
+        self[:id]
+      end
+
+      def inspect
+        s = []; self.each { |k,v| s << "#{k}: #{v.inspect}" }
+        %Q|<Item #{s.join(', ')}>|
+      end
+
+      alias_method :to_indexed_json, :to_json
+
+    end
+
+  end
+end

data/lib/tire/results/pagination.rb

@@ -0,0 +1,30 @@
+module Tire
+  module Results
+
+    module Pagination
+
+      def total_entries
+        @total
+      end
+
+      def total_pages
+        result = @total.to_f / (@options[:per_page] ? @options[:per_page].to_i : 10 )
+        result < 1 ? 1 : result.round
+      end
+
+      def current_page
+        @options[:page].to_i
+      end
+
+      def previous_page
+        @options[:page].to_i - 1
+      end
+
+      def next_page
+        @options[:page].to_i + 1
+      end
+
+    end
+
+  end
+end

data/lib/tire/rubyext/hash.rb

@@ -0,0 +1,3 @@
+class Hash
+  alias_method :to_indexed_json, :to_json
+end

data/lib/tire/rubyext/symbol.rb

@@ -0,0 +1,11 @@
+# ActiveModel::Serialization Ruby < 1.9.x compatibility
+
+class Symbol
+  def <=> other
+    self.to_s <=> other.to_s
+  end unless method_defined?(:'<=>')
+
+  def capitalize
+    to_s.capitalize
+  end unless method_defined?(:capitalize)
+end

data/lib/tire/search.rb

@@ -0,0 +1,117 @@
+module Tire
+  module Search
+  
+    class Search
+
+      attr_reader :indices, :url, :results, :response, :json, :query, :facets, :filters
+
+      def initialize(*indices, &block)
+        @options = indices.pop if indices.last.is_a?(Hash)
+        @indices = indices
+        raise ArgumentError, 'Please pass index or indices to search' if @indices.empty?
+        if @options
+          Configuration.wrapper @options[:wrapper] if @options[:wrapper]
+        end
+        instance_eval(&block) if block_given?
+      end
+
+      def query(&block)
+        @query = Query.new
+        block.arity < 1 ? @query.instance_eval(&block) : block.call(@query)
+        self
+      end
+
+      def sort(&block)
+        @sort = Sort.new(&block)
+        self
+      end
+
+      def facet(name, options={}, &block)
+        @facets ||= {}
+        @facets.update Facet.new(name, options, &block).to_hash
+        self
+      end
+
+      def filter(type, *options)
+        @filters ||= []
+        @filters << Filter.new(type, *options).to_hash
+        self
+      end
+
+      def highlight(*args)
+        unless args.empty?
+          @highlight = Highlight.new(*args)
+          self
+        else
+          @highlight
+        end
+      end
+
+      def from(value)
+        @from = value
+        self
+      end
+
+      def size(value)
+        @size = value
+        self
+      end
+
+      def fields(fields=[])
+        @fields = fields
+        self
+      end
+
+      def perform
+        @url      = "#{Configuration.url}/#{indices.join(',')}/_search"
+        @response = Configuration.client.post(@url, self.to_json)
+        @json     = Yajl::Parser.parse(@response.body)
+        @results  = Results::Collection.new(@json, @options)
+        self
+      rescue Exception => error
+        STDERR.puts "[REQUEST FAILED] #{self.to_curl}\n"
+        raise
+      ensure
+        logged(error)
+      end
+
+      def to_curl
+        %Q|curl -X POST "#{Configuration.url}/#{indices.join(',')}/_search?pretty=true" -d '#{self.to_json}'|
+      end
+
+      def to_json
+        request = {}
+        request.update( { :query  => @query } )
+        request.update( { :sort   => @sort } )     if @sort
+        request.update( { :facets => @facets } )   if @facets
+        @filters.each { |filter| request.update( { :filter => filter } ) } if @filters
+        request.update( { :highlight => @highlight } ) if @highlight
+        request.update( { :size => @size } )       if @size
+        request.update( { :from => @from } )       if @from
+        request.update( { :fields => @fields } )   if @fields
+        Yajl::Encoder.encode(request)
+      end
+
+      def logged(error=nil)
+        if Configuration.logger
+
+          Configuration.logger.log_request '_search', indices, to_curl
+
+          code = @response ? @response.code : error.message
+          took = @json['took'] rescue nil
+
+          if Configuration.logger.level.to_s == 'debug'
+            # FIXME: Depends on RestClient implementation
+            body = @response ? Yajl::Encoder.encode(@json, :pretty => true) : body = error.http_body
+          else
+            body = ''
+          end
+
+          Configuration.logger.log_response code, took, body
+        end
+      end
+
+    end
+
+  end
+end

data/lib/tire/search/facet.rb

@@ -0,0 +1,41 @@
+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
+        self.instance_eval(&block) 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 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,42 @@
+module Tire
+  module Search
+
+    class Query
+      def initialize(&block)
+        self.instance_eval(&block) if block_given?
+      end
+
+      def term(field, value)
+        @value = { :term => { field => value } }
+      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 string(value, options={})
+        @value = { :query_string => { :query => value } }
+        @value[:query_string].update( { :default_field => options[:default_field] } ) if options[:default_field]
+        # TODO: https://github.com/elasticsearch/elasticsearch/wiki/Query-String-Query
+        @value
+      end
+
+      def all
+        @value = { :match_all => {} }
+        @value
+      end
+
+      def ids(values, type)
+        @value = { :ids => { :values => values, :type => type }  }
+      end
+
+      def to_json
+        @value.to_json
+      end
+
+    end
+
+  end
+end

data/lib/tire/search/sort.rb

@@ -0,0 +1,29 @@
+module Tire
+  module Search
+
+    class Sort
+      def initialize(&block)
+        @value = []
+        self.instance_eval(&block) if block_given?
+      end
+
+      def field(name, direction=nil)
+        @value << ( direction ? { name => direction } : name )
+        self
+      end
+
+      def method_missing(id, *args, &block)
+        case arg = args.shift
+          when String, Symbol, Hash then @value << { id => arg }
+          else @value << id
+        end
+        self
+      end
+
+      def to_json
+        @value.to_json
+      end
+    end
+
+  end
+end

data/lib/tire/tasks.rb

@@ -0,0 +1,88 @@
+require 'rake'
+require 'benchmark'
+
+namespace :tire do
+
+  usage = <<-DESC
+          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 usage.split("\n").first.to_s
+  task :import do
+
+    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 '='*80, 'USAGE', '='*80, usage.gsub(/          /, '')
+      exit(1)
+    end
+
+    klass  = eval(ENV['CLASS'].to_s)
+    params = eval(ENV['PARAMS'].to_s) || {}
+
+    index = Tire::Index.new( ENV['INDEX'] || klass.index.name )
+
+    if ENV['FORCE']
+      puts "[IMPORT] Deleting index '#{index.name}'"
+      index.delete
+    end
+
+    unless index.exists?
+      puts "[IMPORT] Creating index '#{index.name}' with mapping:",
+           Yajl::Encoder.encode(klass.mapping_to_hash, :pretty => true)
+      index.create :mappings => klass.mapping_to_hash
+    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
+      index.import(klass, 'paginate', params) do |documents|
+
+        if total
+          done += documents.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
+end