elastics-client 1.0.4

data/lib/elastics/class_proxy/base.rb

@@ -0,0 +1,29 @@
+module Elastics
+  module ClassProxy
+    class Base
+
+      attr_accessor :variables
+
+      def initialize(context, vars={})
+        @variables = Vars.new({:context => context,
+                               :index   => Conf.variables[:index]}.merge(vars))
+      end
+
+      def init; end
+
+      [:context, :index, :type].each do |meth|
+        define_method meth do
+          variables[meth]
+        end
+        define_method :"#{meth}=" do |val|
+          variables[meth] = val
+        end
+      end
+
+      def refresh_index
+        Elastics.refresh_index :index => index
+      end
+
+    end
+  end
+end

data/lib/elastics/class_proxy/templates.rb

@@ -0,0 +1,97 @@
+module Elastics
+  module ClassProxy
+    module Templates
+
+      attr_reader :templates, :partials
+      include Doc
+      include Search
+
+      def init
+        @sources   = []
+        @templates = {}
+        @partials  = {}
+      end
+
+      # accepts a path to a file or YAML string
+      def load_source_for(klass, source, source_vars)
+        if source.nil? || source !~ /\n/m
+          paths = [ "#{Conf.elastics_dir}/#{source}.yml",
+                    "#{Conf.elastics_dir}/#{Utils.class_name_to_type(context.name)}.yml",
+                    source.to_s ]
+          source = paths.find {|p| File.exist?(p)}
+        end
+        raise ArgumentError, "expected a string, got #{source.inspect}" \
+            unless source.is_a?(String)
+        @sources << [klass, source, source_vars]
+        do_load_source(klass, source, source_vars)
+        # fixes the legacy empty stubs, which should call super instead
+        @templates.keys.each do |name|
+          meta_context.send(:define_method, name){|*vars| super *vars }
+        end
+      end
+
+      # loads a Generic Template source
+      def load_source(source=nil, source_vars=nil)
+        load_source_for(Template, source, source_vars)
+      end
+
+      # loads a Search Template source
+      def load_search_source(source=nil, source_vars=nil)
+        load_source_for(Template::Search, source, source_vars)
+      end
+
+      # loads a SlimSearch Template source
+      def load_slim_search_source(source=nil, source_vars=nil)
+        load_source_for(Template::SlimSearch, source, source_vars)
+      end
+
+      # reloads the sources (useful in the console and used internally)
+      def reload!
+        @sources.each {|k,s,v| do_load_source(k,s,v)}
+      end
+
+      def wrap(*methods, &block)
+        methods = templates.keys if methods.empty?
+        methods.each do |name|
+          raise MissingTemplateMethodError, "#{name} is not a template method" \
+                unless templates.include?(name)
+          meta_context.send(:define_method, name, &block)
+        end
+      end
+
+      def render(name, *vars)
+        templates[name].render(*vars)
+      end
+
+      private
+
+      def do_load_source(klass, source, source_vars)
+        source = Utils.erb_process(source) unless source.match("\n") # skips non-path
+        hash   = Utils.parse_source(source)
+        Utils.delete_allcaps_keys(hash).each do |name, args|
+          define_template klass, name, args, source_vars
+        end
+      end
+
+      def define_template(klass, name, args, source_vars)
+        name = name.to_sym
+        args = [args] unless args.is_a?(Array)
+        if name.to_s[0] == '_' # partial
+          partials[name] = Template::Partial.new(*args).setup(self, name)
+        else
+          templates[name] = klass.new(*args).setup(self, name, source_vars)
+          context::ElasticsTemplateMethods.send(:define_method, name) do |*vars|
+            raise ArgumentError, "#{elastics.context}.#{name} expects a list of Hashes, got #{vars.map(&:inspect).join(', ')}" \
+                  unless vars.all?{|i| i.nil? || i.is_a?(Hash)}
+            elastics.render(name,*vars)
+          end
+        end
+      end
+
+      def meta_context
+        class << context; self end
+      end
+
+    end
+  end
+end

data/lib/elastics/class_proxy/templates/doc.rb

@@ -0,0 +1,91 @@
+module Elastics
+  module ClassProxy
+    module Templates
+      module Doc
+
+        def doc(*names)
+          names = templates.keys if names.empty?
+          doc = "\n"
+          names.each do |name|
+            next unless templates.include?(name)
+            block = ''
+            temp = templates[name]
+            meth_call = [context, name].join('.')
+            block << <<-meth_call
+########## #{meth_call} ##########
+#{'-' * temp.class.to_s.length}
+#{temp.class}
+#{temp.to_source}
+meth_call
+            temp.partials.each do |par_name|
+              par = partials[par_name]
+              block << <<-partial
+#{'-' * par.class.to_s.length}
+#{par.class}
+#{par.to_source}
+partial
+            end
+            block << "\nUsage:\n"
+            block << build_usage(meth_call, temp)
+            block << "\n "
+            doc << block.split("\n").map{|l| '#  ' + l}.join("\n")
+            doc << <<-meth.gsub(/^ {14}/m,'')
+
+def #{meth_call}(*vars)
+  ## this is a stub, used for reference
+  super
+end
+
+meth
+          end
+          puts doc
+        end
+
+        def usage(name)
+          meth_call = [context, name].join('.')
+          puts build_usage(meth_call, templates[name])
+        end
+
+      private
+
+        def build_usage(meth_call, temp)
+          variables = temp.instance_eval do
+                        interpolate
+                        @base_variables.deep_merge @host_elastics && @host_elastics.variables, @temp_variables
+                      end
+          all_tags  = temp.tags + temp.partials
+          return meth_call if all_tags.size == 0
+          lines = all_tags.map do |t|
+                    comments = 'partial' if t.to_s[0] == '_'
+                    line = ['', t.inspect]
+                    line + if variables.has_key?(t)
+                             ["#{variables[t].inspect},", comments_to_s(comments)]
+                           else
+                             ["#{to_code(t)},", comments_to_s(comments, 'required')]
+                           end
+                  end
+          lines.sort! { |a,b| b[3] <=> a[3] }
+          lines.first[0] = meth_call
+          lines.last[2].chop!
+          max = lines.transpose.map { |c| c.map(&:length).max }
+          lines.map { |line| "%-#{max[0]}s %-#{max[1]}s => %-#{max[2]}s  %s" % line }.join("\n")
+        end
+
+        def comments_to_s(*comments)
+          comments = comments.compact
+          return '' if comments == []
+          "# #{comments.join(' ')}"
+        end
+
+        def to_code(name)
+          keys = name.to_s.split('.').map{|s| s =~ /^[0..9]+$/ ? s.to_i : s.to_sym}
+          code = keys.shift.to_s
+          return code if keys.empty?
+          keys.each{|k| code << "[#{k.inspect}]"}
+          code
+        end
+
+      end
+    end
+  end
+end

data/lib/elastics/class_proxy/templates/search.rb

@@ -0,0 +1,72 @@
+module Elastics
+  module ClassProxy
+    module Templates
+      module Search
+
+        def define_search(name, source, source_vars=nil)
+          args = Utils.parse_source(source)
+          send :define_template, Template::Search, name, args, source_vars
+        end
+
+        # http://www.elasticsearch.org/guide/reference/api/multi-search.html
+        # requests can be an array of arrays: [[:template1, variable_hash1], [template2, variable_hash2]]
+        # or a hash {:template1 => variable_hash1, template2 => variable_hash2}
+        # The variables are an hash of variables that will be used to render the msearch template
+        # the array of result is at <result>.responses
+        def multi_search(requests, *variables)
+          requests = requests.map { |name, vars| [name, vars] } if requests.is_a?(Hash)
+          lines    = requests.map { |name, vars| templates[name].to_msearch(vars) }.join()
+          template = Elastics::Template.new('GET', '/<<index>>/<<type>>/_msearch') # no setup elastics so raw_result
+          template.send(:do_render, *variables, :data => lines) do |http_response|
+            responses   = []
+            es_response = MultiJson.decode(http_response.body)
+            es_response['responses'].each_with_index do |raw_result, i|
+              name, vars = requests[i]
+              int = templates[name].interpolate(vars, strict=true)
+              result = Result.new(templates[name], int[:vars], http_response, raw_result)
+              responses << result.to_elastics_result
+            end
+            es_response['responses'] = responses
+            def es_response.responses
+              self['responses']
+            end
+            es_response
+          end
+        end
+
+        # implements search_type=scan (http://www.elasticsearch.org/guide/reference/api/search/search-type.html)
+        def scan_search(template, *vars, &block)
+          user_raw_result = vars.any?{|v| v[:raw_result]}
+          scroll      = '5m'
+          search_vars = Vars.new({:params     => { :search_type => 'scan',
+                                                   :scroll      => scroll,
+                                                   :size        => 50 },
+                                  :raw_result => true}, *vars)
+          search_temp = template.is_a?(Elastics::Template) ? template : templates[template]
+
+          scroll_vars = Vars.new({:params     => { :scroll => scroll },
+                                  :raw_result => true}, variables, *vars)
+          scroll_temp = Elastics::Template.new( :get,
+                                            '/_search/scroll',
+                                            nil,
+                                            scroll_vars )
+          search_res  = search_temp.render search_vars
+          scroll_id   = search_res['_scroll_id']
+          while (result = scroll_temp.render(:data => scroll_id)) do
+            break if result['hits']['hits'].empty?
+            scroll_id = result['_scroll_id']
+            result.variables[:raw_result] = user_raw_result
+            block.call result.to_elastics_result(force=true)
+          end
+        end
+
+        # implements search_type=count (http://www.elasticsearch.org/guide/reference/api/search/search-type.html)
+        def count_search(template, *vars)
+          template = template.is_a?(Elastics::Template) ? template : templates[template]
+          template.render Vars.new({:params => {:search_type => 'count'}, :raw_result => true}, *vars)
+        end
+
+      end
+    end
+  end
+end

data/lib/elastics/configuration.rb

@@ -0,0 +1,25 @@
+module Elastics
+
+  Configuration = OpenStruct.new :result_extenders => [ Result::Document,
+                                                        Result::Search,
+                                                        Result::MultiGet,
+                                                        Result::Bulk ],
+                                 :logger           => Logger.new(STDERR),
+                                 :variables        => Vars.new( :index      => nil,
+                                                                :type       => nil,
+                                                                :params     => {},
+                                                                :no_pruning => [] ),
+                                 :config_file      => './config/elastics.yml',
+                                 :elastics_dir         => './elastics',
+                                 :http_client      => HttpClients::Loader.new_http_client
+
+  # shorter alias
+  Conf = Configuration
+
+  Conf.instance_eval do
+    def configure
+      yield self
+    end
+  end
+
+end

data/lib/elastics/deprecation.rb

@@ -0,0 +1,153 @@
+module Elastics
+
+  module Deprecation
+
+    extend self
+
+    def warn(old, new, called=1)
+      message = "#{old} is deprecated in favour of #{new}, and will be removed in a next version. Please, read the upgrade notes at http://elastics.github.io/elastics/doc/7-Tutorials/2-Migrate-from-0.x.html. "
+      message << "(called at: #{caller[called]})" if called
+      Conf.logger.warn message
+    end
+
+    module Module
+      def extended(obj)
+        Deprecation.warn(self, self::NEW_MODULE, 2)
+        obj.extend self::NEW_MODULE
+      end
+      def included(base)
+        Deprecation.warn(self, self::NEW_MODULE, 2)
+        base.send :include, self::NEW_MODULE
+      end
+    end
+
+  end
+
+  ### Deprecation of Flex methods ###
+
+  def info(*names)
+    Deprecation.warn 'Flex.info', 'Elastics.doc'
+    doc *names
+  end
+
+  def process_bulk(options={})
+    Deprecation.warn 'Flex.process_bulk(:collection => collection)', 'Elastics.post_bulk_collection(collection, options)'
+    post_bulk_collection(options.delete(:collection), options)
+  end
+
+  def import_collection(collection, options={})
+    Deprecation.warn 'Flex.import_collection', 'Elastics.post_bulk_collection'
+    post_bulk_collection(collection, options.merge(:action => 'index'))
+  end
+
+  def delete_collection(collection, options={})
+    Deprecation.warn 'Flex.delete_collection(collection)', 'Elastics.post_bulk_collection(collection, :action => "delete")'
+    post_bulk_collection(collection, options.merge(:action => 'delete'))
+  end
+
+  def bulk(*vars)
+    Deprecation.warn 'Flex.bulk(:lines => lines_bulk_string)', 'Elastics.post_bulk_string(:bulk_string => lines_bulk_string)'
+    vars = Vars.new(*vars)
+    post_bulk_string(:bulk_string => vars[:lines])
+  end
+
+
+  ### Deprecation of Configuration methods ###
+
+  Configuration.instance_eval do
+    # temprary deprecation warnings
+    def base_uri
+      Deprecation.warn 'Flex::Configuration.base_uri', 'Elastics::Configuration.http_client.base_uri'
+      http_client.base_uri
+    end
+    def base_uri=(val)
+      Deprecation.warn 'Flex::Configuration.base_uri=', 'Elastics::Configuration.http_client.base_uri='
+      http_client.base_uri = val
+    end
+    def http_client_options
+      Deprecation.warn 'Flex::Configuration.http_client_options', 'Elastics::Configuration.http_client.options'
+      http_client.options
+    end
+    def http_client_options=(val)
+      Deprecation.warn 'Flex::Configuration.http_client_options=', 'Elastics::Configuration.http_client.options='
+      http_client.options = val
+    end
+    def raise_proc
+      Deprecation.warn 'Flex::Configuration.raise_proc', 'Elastics::Configuration.http_client.raise_proc'
+      http_client.raise_proc
+    end
+    def raise_proc=(val)
+      Deprecation.warn 'Flex::Configuration.raise_proc=', 'Elastics::Configuration.http_client.raise_proc='
+      http_client.raise_proc = val
+    end
+  end
+
+
+  class Variables
+    def add(*hashes)
+      Deprecation.warn 'Flex::Variables#add', 'Elastics::Variables#deep_merge!'
+      replace deep_merge(*hashes)
+    end
+  end
+
+
+  module Struct::Mergeable
+    def add(*hashes)
+      Deprecation.warn 'Flex::Variables#add', 'Variables#deep_merge!'
+      replace deep_merge(*hashes)
+    end
+  end
+
+
+  module Loader
+    NEW_MODULE = Templates
+    extend Deprecation::Module
+  end
+
+
+  module ClassProxy::Loader
+    NEW_MODULE = ClassProxy::Templates
+    extend Deprecation::Module
+  end
+
+
+  module ClassProxy::Templates
+    module Doc
+      def info(*names)
+        Deprecation.warn 'flex.info', 'elastics.doc'
+        doc *names
+      end
+    end
+  end
+
+
+  module Result::Collection
+    NEW_MODULE = Struct::Paginable
+    extend Deprecation::Module
+  end
+
+
+  module Model
+    def self.included(base)
+      if defined?(Flex::ModelIndexer)
+        Deprecation.warn 'Flex::Model', 'Elastics::ModelIndexer'
+        base.send :include, Elastics::ModelIndexer
+      else
+        raise NotImplementedError,  %(Elastics does not include "Flex::Model" anymore. Please, require the "elastics-models" gem, and include "Elastics::ModelIndexer" instead.)
+      end
+    end
+  end
+
+
+  module RelatedModel
+    def self.included(base)
+      if defined?(Flex::ModelSyncer)
+        Deprecation.warn 'Flex::RelatedModel', 'Elastics::ModelSyncer'
+        base.send :include, Elastics::ModelSyncer
+      else
+        raise NotImplementedError, %(Elastics does not include "Flex::RelatedModel" anymore. Please, require the "elastics-models" gem, and include "Elastics::ModelSyncer" instead.)
+      end
+    end
+  end
+
+end