elastics-client 1.0.4

data/lib/elastics/struct/hash.rb

@@ -0,0 +1,105 @@
+module Elastics
+  module Struct
+    class Hash < ::Hash
+      include Symbolize
+
+      def initialize
+        super do |hash, key|
+          if key[-1] == '!'
+            klass = (key[0] == '_' ? Array : Hash)
+            hash[clean_key(key)] = klass.new
+          end
+        end
+      end
+
+      def merge(hash)
+        super symbolize(hash)
+      end
+
+      def merge!(hash)
+        super symbolize(hash)
+      end
+
+      def store(key, val)
+        if key[-1] == '='
+          super key[0..-2].to_sym, val.extend(AsIs)
+        else
+          super clean_key(key), symbolize(val)
+        end
+      end
+      alias_method :[]=, :store
+
+      def fetch(key, *rest, &block)
+        cleaned = clean_key(key)
+        super has_key?(cleaned) ? cleaned : key.to_sym, *rest, &block
+      end
+
+      def [](key)
+        cleaned = clean_key(key)
+        super has_key?(cleaned) ? cleaned : key.to_sym
+      end
+
+      def deep_merge(*hashes)
+        dupe = deep_dup(self)
+        hashes.each {|h2| dupe.replace(deep_merge_hash(dupe,h2))}
+        dupe
+      end
+
+      def deep_merge!(*hashes)
+        replace deep_merge(*hashes)
+      end
+
+      module Nil
+        def method_missing(*)
+          self
+        end
+      end
+
+      def try(key)
+        has_key?(key) ? self[key] : nil.extend(Nil)
+      end
+
+      def try_delete(key, *rest, &block)
+        val = delete clean_key(key), *rest, &block
+        val.nil? ? nil.extend(Nil) : val
+      end
+
+
+      private
+
+      def clean_key(key)
+        key[-1] == '!' ? key[0..-2].to_sym : key.to_sym
+      end
+
+      def deep_merge_hash(h1, h2)
+        h2 ||= {}
+        h1.merge(h2) do |key, oldval, newval|
+          case
+          when oldval.is_a?(Hash) && newval.is_a?(Hash)
+            deep_merge_hash(oldval, newval)
+          when oldval.is_a?(Array) && newval.is_a?(Array)
+            oldval | newval
+          else
+            newval
+          end
+        end
+      end
+
+      def deep_dup(obj)
+        case obj
+        when ::Hash, Elastics::Struct::Hash
+          h = obj.dup
+          h.each_pair do |k,v|
+            h[k] = deep_dup(v)
+          end
+          h
+        when ::Array, Elastics::Struct::Array
+          obj.map{|i| deep_dup(i)}
+        else
+          obj
+        end
+      end
+
+    end
+  end
+end

data/lib/elastics/struct/paginable.rb

@@ -0,0 +1,58 @@
+module Elastics
+  module Struct
+    module Paginable
+
+      attr_accessor :total_entries, :variables
+
+      def setup(total_entries, variables)
+        @total_entries = total_entries
+        @variables     = variables
+        self
+      end
+
+      def per_page
+        (@variables[:per_page] || @variables[:limit_value] ||
+            @variables[:params] && @variables[:params][:size] || 10).to_i
+      end
+
+      def total_pages
+        ( @total_entries.to_f / per_page ).ceil
+      end
+
+      def current_page
+        (@variables[:page] || @variables[:current_page] || 1).to_i
+      end
+
+      def previous_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+
+      def next_page
+        current_page < total_pages ? (current_page + 1) : nil
+      end
+
+      def last_page?
+        total_pages == current_page
+      end
+
+      def first_page?
+        current_page == 1
+      end
+
+      def offset
+        per_page * (current_page - 1)
+      end
+
+      def out_of_bounds?
+        current_page > total_pages
+      end
+
+      alias_method :limit_value,   :per_page
+      alias_method :total_count,   :total_entries
+      alias_method :num_pages,     :total_pages
+      alias_method :offset_value,  :offset
+
+    end
+  end
+
+end

data/lib/elastics/struct/prunable.rb

@@ -0,0 +1,60 @@
+module Elastics
+  module Struct
+    module Prunable
+
+      extend self
+
+      VALUES = [ nil, '', {}, [], false ]
+
+      class Value
+        class << self
+          def to_s; '' end
+          alias_method :===, :==
+        end
+      end
+
+      def prune_blanks(obj)
+        prune(obj, *VALUES) || {}
+      end
+
+      # prunes the branch when the leaf is Prunable
+      # and compact.flatten the Array values
+      # values are the prunable values, like VALUES or Prunable::Value,
+      # or any arbitrary value
+      def prune(obj, *values)
+        case
+        when values.include?(obj)
+          obj
+        when obj.is_a?(::Array)
+          return obj if obj.empty?
+          ar = []
+          obj.each do |i|
+            pruned = prune(i, *values)
+            next if values.include?(pruned)
+            ar << pruned
+          end
+          a = ar.compact.flatten
+          a.empty? ? values.first : a
+        when obj.is_a?(::Hash)
+          return obj if obj.empty?
+          h = {}
+          obj.each do |k, v|
+            pruned = prune(v, *values)
+            next if values.include?(pruned)
+            # when a key is prunable merges the value if it is a hash (allows merging of partials)
+            if VALUES.include?(k)
+              h.merge!(pruned) if pruned.is_a?(::Hash)
+            else
+              h[k] = pruned
+            end
+          end
+          h.empty? ? values.first : h
+        else
+          obj
+        end
+      end
+
+    end
+  end
+  Prunable = Struct::Prunable
+end

data/lib/elastics/struct/symbolize.rb

@@ -0,0 +1,27 @@
+module Elastics
+  module Struct
+    module AsIs end
+    module Symbolize
+
+      def symbolize(obj)
+        case obj
+        when Elastics::Struct::Hash, Elastics::Struct::Array, Elastics::Struct::AsIs
+          obj
+        when ::Hash
+          h = Struct::Hash.new
+          obj.each do |k,v|
+            h[k.to_sym] = symbolize(v)
+          end
+          h
+        when ::Array
+          a = Struct::Array.new
+          obj.each{|i| a << i}
+          a
+        else
+          obj
+        end
+      end
+
+    end
+  end
+end

data/lib/elastics/tasks.rb

@@ -0,0 +1,62 @@
+module Elastics
+  class Tasks
+
+    attr_reader :options
+
+    def initialize(overrides={})
+      options = Elastics::Utils.env2options *default_options.keys
+      options[:index] = options[:index].split(',') if options[:index]
+      @options = default_options.merge(options).merge(overrides)
+    end
+
+    def default_options
+      @default_options ||= { :force          => false,
+                             :index          => Conf.variables[:index],
+                             :config_file    => Conf.config_file }
+    end
+
+    def create_indices
+      indices.each do |index|
+        delete_index(index) if options[:force]
+        raise ExistingIndexError, "#{index.inspect} already exists. Please use FORCE=1 if you want to delete it first." \
+              if exist?(index)
+        create(index)
+      end
+    end
+
+    def delete_indices
+      indices.each { |index| delete_index(index) }
+    end
+
+    def config_hash
+      @config_hash ||= ( hash = YAML.load(Utils.erb_process(config_path))
+                         Utils.delete_allcaps_keys(hash) )
+    end
+
+  private
+
+    def indices
+      i = options[:index] || config_hash.keys
+      i.is_a?(Array) ? i : [i]
+    end
+
+    def exist?(index)
+      Elastics.exist?(:index => index)
+    end
+
+    def config_path
+      @config_path ||= options[:config_file] || Conf.config_file
+    end
+
+    def delete_index(index)
+      Elastics.delete_index(:index => index) if exist?(index)
+    end
+
+    def create(index)
+      config_hash[index] = {} unless config_hash.has_key?(index)
+      Elastics.POST "/#{index}", config_hash[index]
+    end
+
+  end
+
+end

data/lib/elastics/template.rb

@@ -0,0 +1,124 @@
+module Elastics
+
+  # Generic Elastics::Template object.
+  # This class represents a generic Elastics::Template object.
+  # It is used as the base class by all the more specific Elastics::Template::* classes.
+  # You  usually don't need to instantiate this class manually, since it is usually used internally.
+  # For more details about templates, see the documentation.
+  class Template
+
+    include Logger
+    include Common
+
+    def self.variables
+      Vars.new
+    end
+
+    attr_reader :method, :path
+
+    def initialize(method, path, data=nil, *vars)
+      @method = method.to_s.upcase
+      raise ArgumentError, "#@method method not supported" \
+            unless %w[HEAD GET PUT POST DELETE].include?(@method)
+      @path          = path =~ /^\// ? path : "/#{path}"
+      @data          = Utils.parse_source(data)
+      @instance_vars = Vars.new(*vars)
+    end
+
+    def render(*vars)
+      do_render(*vars) do |response, int|
+        Result.new(self, int[:vars], response).to_elastics_result
+      end
+    end
+
+    def to_a(*vars)
+      vars = Vars.new(*vars)
+      int  = interpolate(vars)
+      a    = [method, int[:path], Utils.keyfy(:to_s, int[:data]), Utils.keyfy(:to_s, @instance_vars)]
+      2.times { a.pop if a.last.nil? || a.last.empty? }
+      a
+    end
+
+    def to_source
+      {@name.to_s => to_a}.to_yaml
+    end
+
+
+  private
+
+    def do_render(*vars)
+      vars = Vars.new(*vars)
+      int, path, encoded_data, response = try_clean_and_retry(vars)
+      return response.status == 200 if method == 'HEAD' # used in Elastics.exist?
+      if Conf.http_client.raise_proc.call(response)
+        int[:vars][:raise].is_a?(FalseClass) ? return : raise(HttpError.new(response, caller_line))
+      end
+      result = yield(response, int)
+    ensure
+      log_render(int, path, encoded_data, result)
+      result
+    end
+
+    # This allows to use Lucene style search language in the :cleanable_query declared variable and
+    # in case of a syntax error it will remove all the problematic characters and retry with a cleaned query_string
+    # http://lucene.apache.org/core/old_versioned_docs/versions/3_5_0/queryparsersyntax.html
+    def try_clean_and_retry(vars)
+     response_vars = request(vars)
+     if !Prunable::VALUES.include?(vars[:cleanable_query]) && Conf.http_client.raise_proc.call(response_vars[3])
+       e = HttpError.new(response_vars[3], caller_line)
+       e.to_hash['error'] =~ /^SearchPhaseExecutionException/
+       (vars[:cleanable_query].is_a?(String) ? vars[:cleanable_query] : vars[:cleanable_query][:query]).tr!('"&|!(){}[]~^:+-\\', '')
+       request vars
+     else
+       response_vars
+     end
+    end
+
+    def request(vars)
+      int          = interpolate(vars, strict=true)
+      path         = build_path(int, vars)
+      encoded_data = build_data(int, vars)
+      response     = Conf.http_client.request(method, path, encoded_data)
+      return int, path, encoded_data, response
+    end
+
+    def build_path(int, vars)
+      params = int[:vars][:params]
+      path   = vars[:path] || int[:path]
+      unless params.empty?
+        path << ((path =~ /\?/) ? '&' : '?')
+        path << params.map { |p| p.join('=') }.join('&')
+      end
+      path
+    end
+
+    def build_data(int, vars)
+      data = vars[:data] && Utils.parse_source(vars[:data]) || int[:data]
+      (data.nil? || data.is_a?(String)) ? data : MultiJson.encode(data)
+    end
+
+    def interpolate(*args)
+      tags             = Tags.new
+      stringified      = tags.stringify(:path => @path, :data => @data)
+      @partials, @tags = tags.partial_and_tag_names
+      @base_variables  = Conf.variables.deep_merge(self.class.variables)
+      @temp_variables  = Vars.new(@source_vars, @instance_vars, tags.variables)
+      instance_eval <<-ruby, __FILE__, __LINE__
+        def interpolate(vars={}, strict=false)
+          vars = Vars.new(vars) unless vars.is_a?(Elastics::Vars)
+          return {:path => path, :data => data, :vars => vars} if vars.empty? && !strict
+          context_variables = vars[:context] ? vars[:context].elastics.variables : (@host_elastics && @host_elastics.variables)
+          vars = @base_variables.deep_merge(context_variables, @temp_variables, vars).finalize
+          vars = interpolate_partials(vars)
+          obj  = #{stringified}
+          obj  = Prunable.prune(obj, Prunable::Value)
+          obj[:path].tr_s!('/', '/')     # removes empty path segments
+          obj[:vars] = vars
+          obj
+        end
+      ruby
+      interpolate(*args)
+    end
+
+  end
+end

data/lib/elastics/template/common.rb

@@ -0,0 +1,42 @@
+module Elastics
+  class Template
+    module Common
+
+      attr_reader :name, :partials, :tags, :data
+
+      def setup(host_elastics, name=nil, *vars)
+        @host_elastics = host_elastics
+        @name         = name
+        @source_vars  = Vars.new(*vars) if is_a?(Elastics::Template)
+        self
+      end
+
+      def interpolate_partials(vars)
+        @partials.each do |name|
+          partial_assigned_vars = vars[name]
+          next if Prunable::VALUES.include?(partial_assigned_vars)
+          vars[name] = case partial_assigned_vars
+                       when Array
+                         partial_assigned_vars.map {|v| @host_elastics.partials[name].interpolate(vars, v)}
+                       # other partial name (usable as a case output)
+                       when Symbol
+                         @host_elastics.partials[partial_assigned_vars].interpolate(vars, vars[partial_assigned_vars])
+                       # a partial object
+                       when Template::Partial
+                         partial_assigned_vars.interpolate(vars, vars)
+                       # on-the-fly partial creation (an empty string would prune it before)
+                       when String
+                         Template::Partial.new(partial_assigned_vars).interpolate(vars, vars)
+                       # switch to include the partial (a false value would prune it before)
+                       when TrueClass
+                         @host_elastics.partials[name].interpolate(vars, vars)
+                       else
+                         @host_elastics.partials[name].interpolate(vars, partial_assigned_vars)
+                       end
+        end
+        vars
+      end
+
+    end
+  end
+end