flex 0.4.2 → 1.0.1

data/lib/flex/class_proxy/base.rb

@@ -1,15 +1,29 @@
 module Flex
   module ClassProxy
-
     class Base
-      attr_reader :host_class
+
       attr_accessor :variables
 
-      def initialize(host_class)
-        @host_class = host_class
-        @variables  = Variables.new
+      def initialize(context, vars={})
+        @variables = Vars.new({:context => context,
+                               :index   => Conf.variables[:index]}.merge(vars))
       end
-    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
+        Flex.refresh_index :index => index
+      end
+
+    end
   end
 end

data/lib/flex/class_proxy/templates.rb

@@ -0,0 +1,97 @@
+module Flex
+  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.flex_dir}/#{source}.yml",
+                    "#{Conf.flex_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::FlexTemplateMethods.send(:define_method, name) do |*vars|
+            raise ArgumentError, "#{flex.context}.#{name} expects a list of Hashes, got #{vars.map(&:inspect).join(', ')}" \
+                  unless vars.all?{|i| i.nil? || i.is_a?(Hash)}
+            flex.render(name,*vars)
+          end
+        end
+      end
+
+      def meta_context
+        class << context; self end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module Flex
+  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_flex && @host_flex.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/flex/class_proxy/templates/search.rb

@@ -0,0 +1,72 @@
+module Flex
+  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 = Template.new('GET', '/<<index>>/<<type>>/_msearch') # no setup flex 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_flex_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?(Flex::Template) ? template : templates[template]
+
+          scroll_vars = Vars.new({:params     => { :scroll => scroll },
+                                  :raw_result => true}, variables, *vars)
+          scroll_temp = Flex::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_flex_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?(Flex::Template) ? template : templates[template]
+          template.render Vars.new({:params => {:search_type => 'count'}, :raw_result => true}, *vars)
+        end
+
+      end
+    end
+  end
+end

data/lib/flex/configuration.rb

@@ -1,57 +1,25 @@
 module Flex
-  class Struct < OpenStruct
 
-    def configure
-      yield self
-    end
+  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/flex.yml',
+                                 :flex_dir         => './flex',
+                                 :http_client      => HttpClients::Loader.new_http_client
 
-  end
+  # shorter alias
+  Conf = Configuration
 
-  extend self
-
-  def load_http_client
-    if Gem::Specification.respond_to?(:find_all_by_name)
-      case
-        # terrible way to check whether a gem is available.
-        # Gem.available? was just perfect: that's probably the reason it has been deprecated!
-        # https://github.com/rubygems/rubygems/issues/176
-      when Gem::Specification::find_all_by_name('patron').any?
-        require 'patron'
-        Flex::HttpClients::Patron
-      when Gem::Specification::find_all_by_name('rest-client').any?
-        require 'rest-client'
-        Flex::HttpClients::RestClient
-      end
-    else
-      case
-      when Gem.available?('patron')
-        require 'patron'
-        Flex::HttpClients::Patron
-      when Gem.available?('rest-client')
-        require 'rest-client'
-        Flex::HttpClients::RestClient
-      end
+  Conf.instance_eval do
+    def configure
+      yield self
     end
   end
-  private :load_http_client
 
-  Configuration = Struct.new :base_uri            => 'http://localhost:9200',
-                             :result_extenders    => [ Flex::Result::Document,
-                                                       Flex::Result::SourceDocument,
-                                                       Flex::Result::Search,
-                                                       Flex::Result::SourceSearch,
-                                                       Flex::Result::Bulk ],
-                             :logger              => Logger.new(STDERR),
-                             :variables           => Variables.new( :index      => nil,
-                                                                    :type       => nil,
-                                                                    :no_pruning => [] ),
-                             :flex_models         => [],
-                             :config_file         => './config/flex.yml',
-                             :flex_dir            => './flex',
-                             :http_client         => load_http_client,
-                             :http_client_options => {},
-                             :debug               => false,
-                             :debug_result        => true,
-                             :debug_to_curl       => false,
-                             :raise_proc          => proc{|response| response.status >= 400}
 end

data/lib/flex/deprecation.rb

@@ -0,0 +1,153 @@
+module Flex
+
+  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 "
+      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', 'Flex.doc'
+    doc *names
+  end
+
+  def process_bulk(options={})
+    Deprecation.warn 'Flex.process_bulk(:collection => collection)', 'Flex.post_bulk_collection(collection, options)'
+    post_bulk_collection(options.delete(:collection), options)
+  end
+
+  def import_collection(collection, options={})
+    Deprecation.warn 'Flex.import_collection', 'Flex.post_bulk_collection'
+    post_bulk_collection(collection, options.merge(:action => 'index'))
+  end
+
+  def delete_collection(collection, options={})
+    Deprecation.warn 'Flex.delete_collection(collection)', 'Flex.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)', 'Flex.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', 'Flex::Configuration.http_client.base_uri'
+      http_client.base_uri
+    end
+    def base_uri=(val)
+      Deprecation.warn 'Flex::Configuration.base_uri=', 'Flex::Configuration.http_client.base_uri='
+      http_client.base_uri = val
+    end
+    def http_client_options
+      Deprecation.warn 'Flex::Configuration.http_client_options', 'Flex::Configuration.http_client.options'
+      http_client.options
+    end
+    def http_client_options=(val)
+      Deprecation.warn 'Flex::Configuration.http_client_options=', 'Flex::Configuration.http_client.options='
+      http_client.options = val
+    end
+    def raise_proc
+      Deprecation.warn 'Flex::Configuration.raise_proc', 'Flex::Configuration.http_client.raise_proc'
+      http_client.raise_proc
+    end
+    def raise_proc=(val)
+      Deprecation.warn 'Flex::Configuration.raise_proc=', 'Flex::Configuration.http_client.raise_proc='
+      http_client.raise_proc = val
+    end
+  end
+
+
+  class Variables
+    def add(*hashes)
+      Deprecation.warn 'Flex::Variables#add', 'Flex::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', 'flex.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', 'Flex::ModelIndexer'
+        base.send :include, Flex::ModelIndexer
+      else
+        raise NotImplementedError,  %(Flex does not include "Flex::Model" anymore. Please, require the "flex-models" gem, and include "Flex::ModelIndexer" instead.)
+      end
+    end
+  end
+
+
+  module RelatedModel
+    def self.included(base)
+      if defined?(Flex::ModelSyncer)
+        Deprecation.warn 'Flex::RelatedModel', 'Flex::ModelSyncer'
+        base.send :include, Flex::ModelSyncer
+      else
+        raise NotImplementedError, %(Flex does not include "Flex::RelatedModel" anymore. Please, require the "flex-models" gem, and include "Flex::ModelSyncer" instead.)
+      end
+    end
+  end
+
+end