flex 0.4.2 → 1.0.1

data/lib/flex/{result/collection.rb → struct/paginable.rb}

@@ -1,16 +1,18 @@
 module Flex
-  class Result
-    module Collection
+  module Struct
+    module Paginable
 
-      attr_reader :total_entries, :variables
+      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[:params] && @variables[:params][:size] || @variables[:size] || 10).to_i
+        (@variables[:per_page] || @variables[:limit_value] ||
+            @variables[:params] && @variables[:params][:size] || 10).to_i
       end
 
       def total_pages
@@ -18,11 +20,7 @@ module Flex
       end
 
       def current_page
-        if @variables[:page]
-          @variables[:page].to_i
-        else
-          (per_page + (@variables[:from]||0).to_i) / per_page
-        end
+        (@variables[:page] || @variables[:current_page] || 1).to_i
       end
 
       def previous_page
@@ -33,6 +31,14 @@ module Flex
         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
@@ -48,4 +54,5 @@ module Flex
 
     end
   end
+
 end

data/lib/flex/struct/prunable.rb

@@ -0,0 +1,60 @@
+module Flex
+  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/flex/struct/symbolize.rb

@@ -0,0 +1,27 @@
+module Flex
+  module Struct
+    module AsIs end
+    module Symbolize
+
+      def symbolize(obj)
+        case obj
+        when Flex::Struct::Hash, Flex::Struct::Array, Flex::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/flex/tasks.rb

@@ -1,10 +1,23 @@
 module Flex
-  module Tasks
-    extend self
+  class Tasks
+
+    attr_reader :options
+
+    def initialize(overrides={})
+      options = Flex::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 ENV['FORCE']
+        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)
@@ -15,96 +28,24 @@ module Flex
       indices.each { |index| delete_index(index) }
     end
 
-    def import_models
-      Configuration.http_client_options[:timeout]   = ENV['TIMEOUT'].to_i if ENV['TIMEOUT']
-      Configuration.http_client_options[:timeout] ||= 20
-      Configuration.debug = !!ENV['FLEX_DEBUG']
-      batch_size = ENV['BATCH_SIZE'] && ENV['BATCH_SIZE'].to_i || 1000
-      options = {}
-      if ENV['IMPORT_OPTIONS']
-        ENV['IMPORT_OPTIONS'].split('&').each do |pair|
-          k, v  = pair.split('=')
-          options[k.to_sym] = v
-        end
-      end
-      deleted = []
-
-      models.each do |klass|
-        index = klass.flex.index
-
-        if ENV['FORCE']
-          unless deleted.include?(index)
-            delete_index(index)
-            deleted << index
-            puts "#{index} index deleted"
-          end
-        end
-
-        unless exist?(index)
-          create(index)
-          puts "#{index} index created"
-        end
-
-        if defined?(Mongoid::Document) && klass.ancestors.include?(Mongoid::Document)
-          def klass.find_in_batches(options={})
-            0.step(count, options[:batch_size]) do |offset|
-              yield limit(options[:batch_size]).skip(offset).to_a
-            end
-          end
-        end
-
-        unless klass.respond_to?(:find_in_batches)
-          STDERR.puts "[ERROR] Class #{klass} does not respond to :find_in_batches. Skipped."
-          next
-        end
-
-        pbar = ProgBar.new(klass.count, batch_size, "Class #{klass}: ")
-
-        klass.find_in_batches(:batch_size => batch_size) do |array|
-          opts   = {:index => index}.merge(options)
-          result = Flex.import_collection(array, opts) || next
-          pbar.process_result(result, array.size)
-        end
-
-        pbar.finish
-      end
+    def config_hash
+      @config_hash ||= ( hash = YAML.load(Utils.erb_process(config_path))
+                         Utils.delete_allcaps_keys(hash) )
     end
 
-    private
+  private
 
     def indices
-      indices = ENV['INDICES'] || struct.keys
-      indices = eval(indices) if indices.is_a?(String)
-      indices = [indices] unless indices.is_a?(Array)
-      indices
+      i = options[:index] || config_hash.keys
+      i.is_a?(Array) ? i : [i]
     end
 
     def exist?(index)
       Flex.exist?(:index => index)
     end
 
-    def struct
-      @struct ||= begin
-                    @indices_yaml = ENV['CONFIG_FILE'] || Flex::Configuration.config_file
-                    raise Errno::ENOENT, "no such file or directory #{@indices_yaml.inspect}. " +
-                                         'Please, use CONFIG_FILE=/path/to/index.yml ' +
-                                         'or set the Flex::Configuration.config_file properly' \
-                          unless File.exist?(@indices_yaml)
-                    Manager.indices(@indices_yaml)
-                  end
-    end
-
-
-    def models
-      @models ||= begin
-        mods = ENV['MODELS'] || Flex::Configuration.flex_models
-        raise AgrumentError, 'no class defined. Please use MODELS=[ClassA,ClassB]' +
-                             'or set the Flex::Configuration.flex_models properly' \
-              if mods.nil? || mods.empty?
-        mods = eval(mods) if mods.is_a?(String)
-        mods = [mods] unless mods.is_a?(Array)
-        mods.map{|c| c.is_a?(String) ? eval("::#{c}") : c}
-      end
+    def config_path
+      @config_path ||= options[:config_file] || Conf.config_file
     end
 
     def delete_index(index)
@@ -112,9 +53,8 @@ module Flex
     end
 
     def create(index)
-      raise MissingIndexEntryError, "no #{index.inspect} entry defined in #@indices_yaml" \
-            unless struct.has_key?(index)
-      Flex.POST "/#{index}", struct[index]
+      config_hash[index] = {} unless config_hash.has_key?(index)
+      Flex.POST "/#{index}", config_hash[index]
     end
 
   end

data/lib/flex/template.rb

@@ -7,84 +7,85 @@ module Flex
   # For more details about templates, see the documentation.
   class Template
 
-    include Base
+    include Logger
+    include Common
 
     def self.variables
-      Variables.new
+      Vars.new
     end
 
-    attr_reader :method, :path, :data, :variables, :tags, :partials
+    attr_reader :method, :path
 
-    def initialize(method, path, data=nil, vars=nil)
+    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.data_from_source(data)
-      @instance_vars = vars
+      @data          = Utils.parse_source(data)
+      @instance_vars = Vars.new(*vars)
     end
 
-    def setup(host_flex, name=nil, source_vars=nil)
-      @host_flex   = host_flex
-      @name        = name
-      @source_vars = source_vars
-      self
-    end
-
-    def render(vars={})
-      do_render(vars) do |response, int|
-        Result.new(self, int[:vars], response)
+    def render(*vars)
+      do_render(*vars) do |response, int|
+        Result.new(self, int[:vars], response).to_flex_result
       end
     end
 
-    def to_a(vars={})
-      int = interpolate(vars)
-      a = [method, int[:path], int[:data], @instance_vars]
-      2.times { a.pop if a.last.nil? }
+    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_curl(vars={})
-      to_curl_string interpolate(vars, strict=true)
+    def to_source
+      {@name.to_s => to_a}.to_yaml
     end
 
-    def to_flex(name=nil)
-      (name ? {name.to_s => to_a} : to_a).to_yaml
-    end
 
   private
 
-    def do_render(vars={})
-      int          = interpolate(vars, strict=true)
-      path         = build_path(int, vars)
-      encoded_data = build_data(int, vars)
-      response     = Configuration.http_client.request(method, path, encoded_data)
-
-      # used in Flex.exist?
-      return response.status == 200 if method == 'HEAD'
-
-      if Configuration.raise_proc.call(response)
+    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 Flex.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)
-
-    rescue NameError => e
-      if e.name == :request
-        raise MissingHttpClientError,
-              'you should install the gem "patron" (recommended for performances) or "rest-client", ' +
-              'or provide your own http-client interface and set Flex::Configuration.http_client'
-      else
-        raise
-      end
     ensure
-      to_logger(path, encoded_data, result) if int && Configuration.debug && Configuration.logger.level == 0
+      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]
-      if params
+      unless params.empty?
         path << ((path =~ /\?/) ? '&' : '?')
         path << params.map { |p| p.join('=') }.join('&')
       end
@@ -92,60 +93,25 @@ module Flex
     end
 
     def build_data(int, vars)
-      data = vars[:data] && Utils.data_from_source(vars[:data]) || int[:data]
+      data = vars[:data] && Utils.parse_source(vars[:data]) || int[:data]
       (data.nil? || data.is_a?(String)) ? data : MultiJson.encode(data)
     end
 
-    def to_logger(path, encoded_data, result)
-      h = {}
-      h[:method] = method
-      h[:path]   = path
-      h[:data]   = MultiJson.decode(encoded_data) unless encoded_data.nil?
-      h[:result] = result if result && Configuration.debug_result
-      log        = Configuration.debug_to_curl ? to_curl_string(h) : Utils.stringified_hash(h).to_yaml
-      Configuration.logger.debug "[FLEX] Rendered #{caller_line}\n#{log}"
-    end
-
-    def caller_line
-      method_name = @host_flex && @name && "#{@host_flex.host_class}.#@name"
-      line = caller.find{|l| l !~ /#{LIB_PATH}/}
-      ll = ''
-      ll << "#{method_name} from " if method_name
-      ll << "#{line}"
-      ll
-    end
-
-    def to_curl_string(h)
-      pretty = h[:path] =~ /\?/ ? '&pretty=1' : '?pretty=1'
-      curl =  %(curl -X#{method} "#{Configuration.base_uri}#{h[:path]}#{pretty}")
-      if h[:data]
-        data = if h[:data].is_a?(String)
-                 h[:data].length > 1024 ? h[:data][0,1024] + '...(truncated display)' : h[:data]
-               else
-                 MultiJson.encode(h[:data], :pretty => true)
-               end
-        curl << %( -d '\n#{data}\n')
-      end
-      curl
-    end
-
     def interpolate(*args)
-      tags        = Tags.new
-      stringified = tags.stringify(:path => @path, :data => @data)
-      @partials, @tags = tags.map(&:name).partition{|n| n.to_s =~ /^_/}
-      @variables = Configuration.variables.deep_dup
-      @variables.add(self.class.variables)
-      @variables.add(@host_flex.variables) if @host_flex
-      @variables.add(@source_vars, @instance_vars, tags.variables)
+      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?(Flex::Vars)
           return {:path => path, :data => data, :vars => vars} if vars.empty? && !strict
-          sym_vars = {}
-          vars.each{|k,v| sym_vars[k.to_sym] = v} # so you can pass the rails params hash
-          merged = @variables.deep_merge sym_vars
-          vars   = process_vars(merged)
-          obj    = #{stringified}
-          obj    = prune(obj)
+          context_variables = vars[:context] ? vars[:context].flex.variables : (@host_flex && @host_flex.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
@@ -154,31 +120,5 @@ module Flex
       interpolate(*args)
     end
 
-    # prunes the branch when the leaf is a PrunableObject
-    # and compact.flatten the Array values
-    def prune(obj)
-      case obj
-      when Array
-        return if obj.is_a?(PrunableObject)
-        a = obj.map do |i|
-              next if i.is_a?(PrunableObject)
-              prune(i)
-            end.compact.flatten
-        a unless a.empty?
-      when Hash
-        return if obj.is_a?(PrunableObject)
-        return obj if obj.empty?
-        h = {}
-        obj.each do |k, v|
-          pruned = prune(v)
-          next if pruned.is_a?(PrunableObject)
-          h[k] = pruned
-        end
-        h unless h.empty?
-      else
-        obj
-      end
-    end
-
   end
 end