flex 0.4.2 → 1.0.1

data/lib/flex/template/common.rb

@@ -0,0 +1,42 @@
+module Flex
+  class Template
+    module Common
+
+      attr_reader :name, :partials, :tags, :data
+
+      def setup(host_flex, name=nil, *vars)
+        @host_flex   = host_flex
+        @name        = name
+        @source_vars = Vars.new(*vars) if is_a?(Flex::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_flex.partials[name].interpolate(vars, v)}
+                       # other partial name (usable as a case output)
+                       when Symbol
+                         @host_flex.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_flex.partials[name].interpolate(vars, vars)
+                       else
+                         @host_flex.partials[name].interpolate(vars, partial_assigned_vars)
+                       end
+        end
+        vars
+      end
+
+    end
+  end
+end

data/lib/flex/template/logger.rb

@@ -0,0 +1,66 @@
+module Flex
+  class Template
+    module Logger
+
+    def caller_line
+      caller.find{|l| l !~ /(#{LIB_PATHS.join('|')})/}
+    end
+
+    private
+
+      def template_name
+        @host_flex && @name && "#{@host_flex.context}.#@name" || 'template'
+      end
+
+      def log_render(int, path, encoded_data, result)
+        logger = Conf.logger
+        return unless logger.is_a?(Flex::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/flex/template/partial.rb

@@ -2,28 +2,25 @@ module Flex
   class Template
     class Partial
 
-      include Base
+      include Common
 
-      def initialize(data, parent)
-        @data       = data
-        @parent     = parent
-        tags        = Tags.new
-        stringified = tags.stringify(data)
-        @partials, @tags = tags.map(&:name).partition{|n| n.to_s =~ /^_/}
-        @variables  = tags.variables
+      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(main_vars=Variables.new, vars={})
-            sym_vars = {}
-            vars.each{|k,v| sym_vars[k.to_sym] = v} # so you can pass the rails params hash
-            main_vars.add(@variables, sym_vars)
-            vars = process_vars(main_vars)
+          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_flex(name=nil)
-        {name.to_s => @data}.to_yaml
+      def to_source
+        {@name.to_s => @data}.to_yaml
       end
 
     end

data/lib/flex/template/search.rb

@@ -3,17 +3,17 @@ module Flex
     class Search < Template
 
       def initialize(data, vars=nil)
-        super('GET', "/<<index>>/<<type>>/_search", data, vars)
+        super('GET', '/<<index>>/<<type>>/_search', data, vars)
       end
 
-      def to_a(vars={})
-        int = interpolate(vars)
-        a = [int[:data]]
-        a << @instance_vars unless @instance_vars.nil?
+      def to_a(*vars)
+        a = super
+        2.times{ a.delete_at 0 }
         a
       end
 
-      def to_msearch(vars={})
+      def to_msearch(*vars)
+        vars   = Vars.new(*vars)
         int    = interpolate(vars, strict=true)
         header = {}
         header[:index] = int[:vars][:index] if int[:vars][:index]

data/lib/flex/template/slim_search.rb

@@ -5,7 +5,7 @@ module Flex
       # removes the fields param (no _source returned)
       # the result.loaded_collection, will load the records from the db
       def self.variables
-        super.add(:params => {:fields => ''})
+        super.deep_merge!(:params => {:fields => ''})
       end
 
     end

data/lib/flex/template/tags.rb

@@ -2,11 +2,21 @@ module Flex
   class Template
     class Tags < Array
 
-      TAG_REGEXP = /<<\s*(\w+)\s*(?:=([^>]*))*>>/
+      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 = {}
-        each { |t| tag_variables[t.name] = t.default if t.default || t.optional  }
+        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
 
@@ -16,15 +26,19 @@ module Flex
           match =~ TAG_REGEXP
           t = Tag.new($1, $2)
           push t unless find{|i| i.name == t.name}
-          t.stringify(match !~ /^"/)
+          (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 = [:path, :data, :params, :page, :no_pruning, :raise]
+      RESERVED = [:context, :path, :data, :params, :no_pruning, :raw_result, :raise]
 
       attr_reader :optional, :name, :default
 
@@ -36,10 +50,6 @@ module Flex
         @default  = YAML.load(default) unless default.nil?
       end
 
-      def stringify(in_string)
-        in_string ? "\#{prunable(:#{name}, vars)}" : "prunable(:#{name}, vars)"
-      end
-
     end
 
   end

data/lib/flex/templates.rb

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

data/lib/flex/utility_methods.rb

@@ -1,18 +1,13 @@
 module Flex
   module UtilityMethods
 
-    # Anonymous search query: please, consider to use named templates for better performances and programming style
-    # data can be a JSON string that will be passed as is, or a YAML string (that will be converted into a ruby hash)
-    # or a hash. It can contain interpolation tags as usual.
-    # You can pass an optional hash of interpolation arguments (or query string :params).
-    # See also the Flex::Template::Search documentation
-    def search(data, args={})
-      Template::Search.new(data).render(args)
+    def search(data, vars={})
+      Template::Search.new(data).setup(Flex.flex).render(vars)
     end
 
     # like Flex.search, but it will use the Flex::Template::SlimSearch instead
-    def slim_search(data, args={})
-      Template::SlimSearch.new(data).render(args)
+    def slim_search(data, vars={})
+      Template::SlimSearch.new(data).setup(Flex.flex).render(vars)
     end
 
     %w[HEAD GET PUT POST DELETE].each do |m|
@@ -31,109 +26,105 @@ module Flex
       MultiJson.encode(YAML.load(yaml))
     end
 
-    # Flex.process_bulk accepts a :collection of objects, that can be hashes or Models
-    # you can pass also a :action set to 'index' (default) or 'delete'
-    # in order to bulk-index or bulk-delete the whole collection
-    # you can use Flex.bulk if you have an already formatted bulk data-string
-    def process_bulk(args)
-      raise ArgumentError, "Array expected as :collection (got #{args[:collection].inspect})" \
-            unless args[:collection].is_a?(Array)
-
-      index  = args[:index]  || Configuration.variables[:index]
-      type   = args[:type]   || Configuration.variables[:type]
-      action = args[:action] || 'index'
-
-      meta = {}
-      [:version, :routing, :percolate, :parent, :timestamp, :ttl].each do |opt|
-        meta["_#{opt}"] = args[opt] if args[opt]
-      end
-      lines = args[:collection].map do |d|
-                # skips indexing for objects that return nil as the indexed_json or are not flex_indexable?
-                unless action == 'delete'
-                  next if d.respond_to?(:flex_indexable?) && !d.flex_indexable?
-                  json = get_json(d) || next
-                end
-                m = {}
-                m['_index']   = get_index(d) || index
-                m['_type']    = get_type(d)  || type
-                m['_id']      = get_id(d)    || d       # we could pass an array of ids to delete
-                parent        = get_parent(d)
-                m['_parent']  = parent if parent
-                routing       = get_routing(d)
-                m['_routing'] = routing if routing
-                line = MultiJson.encode({action => meta.merge(m)})
-                line << "\n#{json}" unless action == 'delete'
-                line
-              end.compact
-
-      bulk(args.merge(:lines => lines.join("\n") + "\n")) if lines.size > 0
+    def reload!
+      flex.variables.deep_merge! Conf.variables
+      Templates.contexts.each {|c| c.flex.reload!}
+      true
     end
 
-    def import_collection(collection, options={})
-      process_bulk( {:collection => collection,
-                     :action     => 'index'}.merge(options) )
-
+    def doc(*args)
+      flex.doc(*args)
     end
 
-    def delete_collection(collection, options={})
-      process_bulk( {:collection => collection,
-                     :action     => 'delete'}.merge(options) )
+    def scan_search(*args, &block)
+      flex.scan_search(*args, &block)
     end
 
-  private
+    def scan_all(*vars, &block)
+      flex.scan_search(:match_all, *vars) do |raw_result|
+        batch = raw_result['hits']['hits']
+        block.call(batch)
+      end
+    end
 
-    def perform(*args)
-      Template.new(*args).render
+    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
 
-    def get_index(d)
-       d.class.flex.index if d.class.respond_to?(:flex)
+    # 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
 
-    def get_type(d)
-      case
-      when d.respond_to?(:flex)  then d.flex.type
-      when d.respond_to?(:_type) then d._type
-      when d.is_a?(Hash)         then d.delete(:_type) || d.delete('_type') ||
-                                      d.delete(:type)  || d.delete('type')
-      when d.respond_to?(:type)  then d.type
+    # You should use Flex.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 get_parent(d)
-      case
-      when d.respond_to?(:flex) && d.flex.parent_instance(false) then d.flex.parent_instance.id
-      when d.respond_to?(:_parent) then d._parent
-      when d.respond_to?(:parent)  then d.parent
-      when d.is_a?(Hash)           then d.delete(:_parent) || d.delete('_parent') ||
-                                        d.delete(:parent)  || d.delete('parent')
+    def build_bulk_string(document, options={})
+      case document
+      when Hash
+        bulk_string_from_hash(document, options)
+      when Flex::ModelIndexer, Flex::ActiveModel
+        bulk_string_from_flex(document, options)
+      else
+        raise NotImplementedError, "Unable to convert the document #{document.inspect} to a bulk string."
       end
     end
 
-    def get_routing(d)
-      case
-      when d.respond_to?(:flex) && d.flex.routing(false) then d.flex.routing
-      when d.respond_to?(:_routing) then d._routing
-      when d.respond_to?(:routing)  then d.routing
-      when d.is_a?(Hash)            then d.delete(:_routing) || d.delete('_routing') ||
-                                         d.delete(:routing)  || d.delete('routing')
-      end
+  private
+
+    def perform(*args)
+      Template.new(*args).setup(Flex.flex).render
     end
 
-    def get_id(d)
-      case
-      when d.is_a?(Hash)      then  d.delete(:_id) || d.delete('_id') ||
-                                    d.delete(:id)  || d.delete('id')
-      when d.respond_to?(:id) then  d.id
+    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_flex(document, options)
+      flex = document.flex
+      return '' unless document.flex_indexable?
+      meta = { '_index' => flex.index,
+               '_type'  => flex.type,
+               '_id'    => flex.id }
+      meta['_parent']  = flex.parent  if flex.parent
+      meta['_routing'] = flex.routing if flex.routing
+      source           = document.flex_source unless options[:action] == 'delete'
+      to_bulk_string(meta, source, options)
     end
 
-    def get_json(d)
-      case
-      when d.respond_to?(:flex_source) then d.flex_source
-      when d.respond_to?(:to_json)     then d.to_json
-      else MultiJson.encode(d)
+    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