elastics-client 1.0.4

data/lib/elastics/template/logger.rb

@@ -0,0 +1,66 @@
+module Elastics
+  class Template
+    module Logger
+
+    def caller_line
+      caller.find{|l| l !~ /(#{LIB_PATHS.join('|')})/}
+    end
+
+    private
+
+      def template_name
+        @host_elastics && @name && "#{@host_elastics.context}.#@name" || 'template'
+      end
+
+      def log_render(int, path, encoded_data, result)
+        logger = Conf.logger
+        return unless logger.is_a?(Elastics::Logger)
+        logger.info Dye.dye("Rendered #{template_name} from: #{caller_line}", :blue, :bold)
+        return unless logger.level == ::Logger::DEBUG
+
+        h = {}
+        if logger.debug_variables
+          h[:variables] = int[:vars] if int
+        end
+        if logger.debug_request
+          h[:request] = {}
+          h[:request][:method] = method
+          h[:request][:path]   = path
+          h[:request][:data]   = begin
+                                   MultiJson.decode(encoded_data) unless encoded_data.nil?
+                                 rescue MultiJson::DecodeError
+                                   encoded_data
+                                 end
+          h[:request].delete(:data) if h[:request][:data].nil?
+        end
+        if logger.debug_result
+          h[:result] = result if result
+        end
+        logger.debug logger.curl_format ? curl_format(h[:request]) : yaml_format(h)
+      end
+
+      def curl_format(h)
+        pretty = h[:path] =~ /\?/ ? '&pretty=1' : '?pretty=1'
+        curl =  %(curl -X#{method} "#{Conf.base_uri}#{h[:path]}#{pretty}")
+        if h[:data]
+          data = h[:data].is_a?(String) ? h[:data] : MultiJson.encode(h[:data], :pretty => true)
+          curl << %( -d '\n#{data}\n')
+        end
+        curl
+      end
+
+      def yaml_format(hash)
+        hash.to_yaml.split("\n").map do |l|
+          case l
+          when /^---$/
+          when /^( |-)/
+            Dye.dye(l, :blue)
+          when  /^:(variables|request|result)/
+            Dye.dye(l, :magenta, :bold) + (Dye.color ? Dye.sgr(:blue) : '')
+          end
+        end.compact.join("\n") + "\n"
+      end
+
+    end
+  end
+end

data/lib/elastics/template/partial.rb

@@ -0,0 +1,28 @@
+module Elastics
+  class Template
+    class Partial
+
+      include Common
+
+      def initialize(data)
+        @data            = data
+        tags             = Tags.new
+        stringified      = tags.stringify(data)
+        @partials, @tags = tags.partial_and_tag_names
+        @tags_variables  = tags.variables
+        instance_eval <<-ruby, __FILE__, __LINE__
+          def interpolate(vars={}, partial_assigned_vars={})
+            vars = Vars.new(vars, @tags_variables, partial_assigned_vars)
+            vars = interpolate_partials(vars)
+            #{stringified}
+          end
+        ruby
+      end
+
+      def to_source
+        {@name.to_s => @data}.to_yaml
+      end
+
+    end
+  end
+end

data/lib/elastics/template/search.rb

@@ -0,0 +1,30 @@
+module Elastics
+  class Template
+    class Search < Template
+
+      def initialize(data, vars=nil)
+        super('GET', '/<<index>>/<<type>>/_search', data, vars)
+      end
+
+      def to_a(*vars)
+        a = super
+        2.times{ a.delete_at 0 }
+        a
+      end
+
+      def to_msearch(*vars)
+        vars   = Vars.new(*vars)
+        int    = interpolate(vars, strict=true)
+        header = {}
+        header[:index] = int[:vars][:index] if int[:vars][:index]
+        header[:type]  = int[:vars][:type]  if int[:vars][:type]
+        [:search_type, :preferences, :routing].each do |k|
+          header[k] = int[:vars][k] if int[:vars][k] || int[:vars][:params] && int[:vars][:params][k]
+        end
+        data, encoded = build_data(int, vars)
+        "#{MultiJson.encode(header)}\n#{encoded}\n"
+      end
+
+    end
+  end
+end

data/lib/elastics/template/slim_search.rb

@@ -0,0 +1,13 @@
+module Elastics
+  class Template
+    class SlimSearch < Search
+
+      # removes the fields param (no _source returned)
+      # the result.loaded_collection, will load the records from the db
+      def self.variables
+        super.deep_merge!(:params => {:fields => ''})
+      end
+
+    end
+  end
+end

data/lib/elastics/template/tags.rb

@@ -0,0 +1,56 @@
+module Elastics
+  class Template
+    class Tags < Array
+
+      TAG_REGEXP = /<<\s*([\w\.]+)\s*(?:=([^>]*))*>>/
+
+      # tag variables are the defaults defined with the tag
+      # a variable could be optional, and the default could be nil
+      def variables
+        tag_variables = Vars.new
+        each do |t|
+          if t.default || t.optional
+            if t.name =~ /\./ # set default for nested var
+              tag_variables.store_nested(t.name, t.default)
+            else
+              tag_variables[t.name] = t.default
+            end
+          end
+        end
+        tag_variables
+      end
+
+      def stringify(structure)
+        structure.inspect.gsub(/(?:"#{TAG_REGEXP}"|#{TAG_REGEXP})/) do
+          match = $&
+          match =~ TAG_REGEXP
+          t = Tag.new($1, $2)
+          push t unless find{|i| i.name == t.name}
+          (match !~ /^"/) ? "\#{vars.get_prunable(:'#{t.name}')}" : "vars.get_prunable(:'#{t.name}')"
+        end
+      end
+
+      def partial_and_tag_names
+        map(&:name).partition{|n| n.to_s =~ /^_/}
+      end
+
+    end
+
+    class Tag
+
+      RESERVED = [:context, :path, :data, :params, :no_pruning, :raw_result, :raise]
+
+      attr_reader :optional, :name, :default
+
+      def initialize(name, default)
+        raise SourceError, ":#{name} is a reserved symbol and cannot be used as a tag name" \
+              if RESERVED.include?(name)
+        @name     = name.to_sym
+        @optional = !!default
+        @default  = YAML.load(default) unless default.nil?
+      end
+
+    end
+
+  end
+end

data/lib/elastics/templates.rb

@@ -0,0 +1,20 @@
+module Elastics
+  module Templates
+
+    extend self
+    attr_accessor :contexts
+    @contexts = []
+
+    def self.included(context)
+      context.class_eval do
+        Elastics::Templates.contexts |= [context]
+        @elastics ||= ClassProxy::Base.new(context)
+        @elastics.extend(ClassProxy::Templates).init
+        def self.elastics; @elastics end
+        def self.template_methods; elastics.templates.keys end
+        eval "extend module #{context}::ElasticsTemplateMethods; self end"
+      end
+    end
+
+  end
+end

data/lib/elastics/utility_methods.rb

@@ -0,0 +1,131 @@
+module Elastics
+  module UtilityMethods
+
+    def search(data, vars={})
+      Template::Search.new(data).setup(Elastics.elastics).render(vars)
+    end
+
+    # like Elastics.search, but it will use the Elastics::Template::SlimSearch instead
+    def slim_search(data, vars={})
+      Template::SlimSearch.new(data).setup(Elastics.elastics).render(vars)
+    end
+
+    %w[HEAD GET PUT POST DELETE].each do |m|
+      class_eval <<-ruby, __FILE__, __LINE__
+        def #{m}(*args)
+          perform '#{m}', *args
+        end
+      ruby
+    end
+
+    def json2yaml(json)
+      YAML.dump(MultiJson.decode(json))
+    end
+
+    def yaml2json(yaml)
+      MultiJson.encode(YAML.load(yaml))
+    end
+
+    def reload!
+      elastics.variables.deep_merge! Conf.variables
+      Templates.contexts.each {|c| c.elastics.reload!}
+      true
+    end
+
+    def doc(*args)
+      elastics.doc(*args)
+    end
+
+    def scan_search(*args, &block)
+      elastics.scan_search(*args, &block)
+    end
+
+    def scan_all(*vars, &block)
+      elastics.scan_search(:match_all, *vars) do |raw_result|
+        batch = raw_result['hits']['hits']
+        block.call(batch)
+      end
+    end
+
+    def dump_all(*vars, &block)
+      refresh_index(*vars)
+      scan_all({:params => {:fields => '*,_source'}}, *vars) do |batch|
+        batch.map!{|document| document.delete('_score'); document}
+        block.call(batch)
+      end
+    end
+
+    # refresh and pull the full document from the index
+    def dump_one(*vars)
+      refresh_index(*vars)
+      document = search_by_id({:params => {:fields => '*,_source'}}, *vars)
+      document.delete('_score')
+      document
+    end
+
+    # You should use Elastics.post_bulk_string if you have an already formatted bulk data-string
+    def post_bulk_collection(collection, options={})
+      raise ArgumentError, "Array expected as :collection, got #{collection.inspect}" \
+            unless collection.is_a?(Array)
+      bulk_string = ''
+      collection.each do |d|
+        bulk_string << build_bulk_string(d, options)
+      end
+      post_bulk_string(:bulk_string => bulk_string) unless bulk_string.empty?
+    end
+
+    def build_bulk_string(document, options={})
+      case document
+      when Hash
+        bulk_string_from_hash(document, options)
+      when Elastics::ModelIndexer, Elastics::ActiveModel
+        bulk_string_from_elastics(document, options)
+      else
+        raise NotImplementedError, "Unable to convert the document #{document.inspect} to a bulk string."
+      end
+    end
+
+  private
+
+    def perform(*args)
+      Template.new(*args).setup(Elastics.elastics).render
+    end
+
+    def bulk_string_from_hash(document, options)
+      meta = Utils.slice_hash(document, '_index', '_type', '_id')
+      if document.has_key?('fields')
+        document['fields'].each do |k, v|
+          meta[k] = v if k[0] == '_'
+        end
+      end
+      source = document['_source'] unless options[:action] == 'delete'
+      to_bulk_string(meta, source, options)
+    end
+
+    def bulk_string_from_elastics(document, options)
+      elastics = document.elastics
+      return '' unless document.elastics_indexable?
+      meta = { '_index' => elastics.index,
+               '_type'  => elastics.type,
+               '_id'    => elastics.id }
+      meta['_parent']  = elastics.parent  if elastics.parent
+      meta['_routing'] = elastics.routing if elastics.routing
+      source           = document.elastics_source unless options[:action] == 'delete'
+      to_bulk_string(meta, source, options)
+    end
+
+    def to_bulk_string(meta, source, options)
+      action = options[:action] || 'index'
+      return '' if source.nil? || source.empty? &&! (action == 'delete')
+      meta['_index'] = LiveReindex.prefix_index(meta['_index']) if LiveReindex.should_prefix_index?
+      bulk_string = MultiJson.encode(action => meta) + "\n"
+      unless action == 'delete'
+        source_line = source.is_a?(String) ? source : MultiJson.encode(source)
+        return '' if source.nil? || source.empty?
+        bulk_string << source_line + "\n"
+      end
+      bulk_string
+    end
+
+  end
+end

data/lib/elastics/utils.rb

@@ -0,0 +1,103 @@
+module Elastics
+  module Utils
+    extend self
+
+    def parse_source(source)
+      return unless source
+      parsed = case source
+               when Hash              then keyfy(:to_s, source)
+               when /^\s*\{.+\}\s*$/m then source
+               when String            then YAML.load(source)
+               else raise ArgumentError, "expected a String or Hash instance, got #{source.inspect}"
+               end
+      raise ArgumentError, "the source does not decode to an Array, Hash or String, got #{parsed.inspect}" \
+            unless parsed.is_a?(Hash) || parsed.is_a?(Array) || parsed.is_a?(String)
+      parsed
+    end
+
+    def erb_process(source)
+      varname = "_elastics_#{source.hash.to_s.tr('-', '_')}"
+      ERB.new(File.read(source), nil, nil, varname).result
+    end
+
+    def group_array_by(ary)
+      h = {}
+      ary.each do |i|
+        k = yield i
+        if h.has_key?(k)
+          h[k] << i
+        else
+          h[k] = [i]
+        end
+      end
+      h
+    end
+
+    def delete_allcaps_keys(hash)
+      hash.keys.each { |k| hash.delete(k) if k =~ /^[A-Z_]+$/ }
+      hash
+    end
+
+    def keyfy(to_what, obj)
+      case obj
+      when Hash
+        h = {}
+        obj.each do |k,v|
+          h[k.send(to_what)] = keyfy(to_what, v)
+        end
+        h
+      when Array
+        obj.map{|i| keyfy(to_what, i)}
+      else
+        obj
+      end
+    end
+
+    def slice_hash(hash, *keys)
+      h = {}
+      keys.each{|k| h[k] = hash[k] if hash.has_key?(k)}
+      h
+    end
+
+    def env2options(*keys)
+      options = {}
+      ENV.keys.map do |k|
+        key = k.downcase.to_sym
+        options[key] = ENV[k] if keys.include?(key)
+      end
+      options
+    end
+
+    def define_delegation(opts)
+      file, line = caller.first.split(':', 2)
+      line = line.to_i
+
+      obj, meth, methods, to = opts[:in], opts[:by], opts[:for], opts[:to]
+
+      methods.each do |method|
+        obj.send meth, <<-method, file, line - 1
+          def #{method}(*args, &block)                        # def method_name(*args, &block)
+            if #{to} || #{to}.respond_to?(:#{method})         #   if client || client.respond_to?(:name)
+              #{to}.__send__(:#{method}, *args, &block)       #     client.__send__(:name, *args, &block)
+            end                                               #   end
+          end                                                 # end
+        method
+      end
+
+    end
+
+    def class_name_to_type(class_name)
+      type = class_name.tr(':', '_')
+      type.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      type.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      type.downcase!
+      type
+    end
+
+    def type_to_class_name(type)
+      type.gsub(/__(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+
+  end
+end