flex 0.1.0

data/lib/flex/template/base.rb

@@ -0,0 +1,29 @@
+module Flex
+  class Template
+    module Base
+
+      def process_vars(vars)
+        missing = @tags - vars.keys
+        raise ArgumentError, "required variables #{missing.inspect} missing." \
+              unless missing.empty?
+        @partials.each do |k|
+          raise MissingPartialError, "undefined #{k} partial template" \
+                unless @host_flex.partials.has_key?(k)
+          next if vars[k].nil?
+          vars[k] = [vars[k]] unless vars[k].is_a?(Array)
+          vars[k] = vars[k].map {|v| @host_flex.partials[k].interpolate(@variables.deep_dup, v)}
+        end
+        vars[:index] = vars[:index].join(',') if vars[:index].is_a?(Array)
+        vars[:type]  = vars[:type].join(',')  if vars[:type].is_a?(Array)
+        if vars[:page]
+          vars[:params] ||= {}
+          page = vars[:page].to_i
+          page = 1 unless page > 0
+          vars[:params][:from] = ((page - 1) * vars[:params][:size] || vars[:size] || 10).ceil
+        end
+        vars
+      end
+
+    end
+  end
+end

data/lib/flex/template/info.rb

@@ -0,0 +1,50 @@
+module Flex
+  class Template
+    module Info
+
+      def info(*names)
+        names = templates.keys if names.empty?
+        info = "\n"
+        names.each do |name|
+          next unless templates.include?(name)
+          block = ''
+          temp = templates[name]
+          meth_call = [host_class, name].join('.')
+          block << "########## #{meth_call} ##########\n\n#{'-' * temp.class.to_s.length}\n#{temp.class}\n#{temp.to_flex(name)}\n"
+          temp.partials.each do |par_name|
+            par = partials[par_name]
+            block << "#{'-' * par.class.to_s.length}\n#{par.class}\n#{par.to_flex(par_name)}\n"
+          end
+          block << "\nUsage:\n"
+          block << usage(meth_call, temp)
+          block << "\n "
+          info  << block.split("\n").map{|l| '#  ' + l}.join("\n")
+          info  <<  "\ndef #{meth_call}(vars={})\n  # this is a stub, used for reference\nend\n\n\n"
+        end
+        info
+      end
+
+    private
+
+      def usage(meth_call, temp)
+        all_tags = temp.tags + temp.partials
+        lines = all_tags.map do |t|
+          comments = 'partial' if t.to_s.match(/^_/)
+          ['', t.to_s] + (temp.variables.has_key?(t) ? ["#{temp.variables[t].inspect},", comments_to_s(comments)] : ["#{t},", comments_to_s(comments, 'required')])
+        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
+
+    end
+  end
+end

data/lib/flex/template/partial.rb

@@ -0,0 +1,31 @@
+module Flex
+  class Template
+    class Partial
+
+      include Base
+
+      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
+        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)
+            #{stringified}
+          end
+        ruby
+      end
+
+      def to_flex(name=nil)
+        {name.to_s => @data}.to_yaml
+      end
+
+    end
+  end
+end

data/lib/flex/template/search.rb

@@ -0,0 +1,30 @@
+module Flex
+  class Template
+    class Search < Template
+
+      def initialize(data, vars=nil)
+        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?
+        a
+      end
+
+      def to_msearch(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/flex/template/slim_search.rb

@@ -0,0 +1,13 @@
+module Flex
+  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.add(:params => {:fields => ''})
+      end
+
+    end
+  end
+end

data/lib/flex/template/tags.rb

@@ -0,0 +1,46 @@
+module Flex
+  class Template
+    class Tags < Array
+
+      TAG_REGEXP = /<<\s*(\w+)\s*(?:=([^>]*))*>>/
+
+      def variables
+        tag_variables = {}
+        each { |t| tag_variables[t.name] = t.default if t.default || t.optional  }
+        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}
+          t.stringify(match !~ /^"/)
+        end
+      end
+
+    end
+
+    class Tag
+
+      RESERVED = [:path, :data, :params, :page, :no_pruning, :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
+
+      def stringify(in_string)
+        in_string ? "\#{vars[:#{name}]}" : "vars[:#{name}]"
+      end
+
+    end
+
+  end
+end

data/lib/flex/utility_methods.rb

@@ -0,0 +1,140 @@
+module Flex
+  module UtilityMethods
+
+    def configuration
+      Configuration
+    end
+    alias_method :config, :configuration
+
+    # 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)
+    end
+
+    # like Flex.search, but it will use the Flex::Template::SlimSearch instead
+    def slim_search(data, args={})
+      Template::SlimSearch.new(data).render(args)
+    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
+
+    # 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_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 = {action => meta.merge(m)}.to_json
+                line << "\n#{json}" unless action == 'delete'
+                line
+              end.compact
+
+      bulk(args.merge(:lines => lines.join("\n") + "\n")) if lines.size > 0
+    end
+
+    def import_collection(collection, options={})
+      process_bulk( {:collection => collection,
+                     :action     => 'index'}.merge(options) )
+
+    end
+
+    def delete_collection(collection, options={})
+      process_bulk( {:collection => collection,
+                     :action     => 'delete'}.merge(options) )
+    end
+
+  private
+
+    def perform(*args)
+      Template.new(*args).render
+    end
+
+    def get_index(d)
+       d.class.flex.index if d.class.respond_to?(:flex)
+    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
+      end
+    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')
+      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
+    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
+      end
+    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
+      end
+    end
+
+  end
+end

data/lib/flex/utils.rb

@@ -0,0 +1,59 @@
+module Flex
+  module Utils
+    extend self
+
+    def data_from_source(source)
+      return unless source
+      data = case source
+             when Hash              then stringified_hash(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 a Hash or String (got #{data.inspect})" \
+            unless data.is_a?(Hash) || data.is_a?(String)
+      data
+    end
+
+    def deep_merge_hashes(h1, *hashes)
+      merged = h1.dup
+      hashes.each {|h2| merged.replace(deep_merge_hash(merged,h2))}
+      merged
+    end
+
+    def erb_process(source)
+      ERB.new(File.read(source)).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 stringified_hash(hash)
+      h = {}
+      hash.each do |k,v|
+        h[k.to_s] = v.is_a?(Hash) ? stringified_hash(v) : v
+      end
+      h
+    end
+
+  private
+
+    def deep_merge_hash(h1, h2)
+      h2 ||= {}
+      h1.merge(h2) do |key, oldval, newval|
+        oldval.is_a?(Hash) && newval.is_a?(Hash) ? deep_merge_hash(oldval, newval) : newval
+      end
+    end
+
+  end
+end

data/lib/flex/variables.rb

@@ -0,0 +1,11 @@
+module Flex
+  class Variables < Hash
+
+    include Structure::Mergeable
+
+    def initialize(hash={})
+      replace hash
+    end
+
+  end
+end

data/lib/generators/flex/setup/setup_generator.rb

@@ -0,0 +1,51 @@
+require 'prompter'
+
+class Flex::SetupGenerator < Rails::Generators::Base
+
+  # more funny than vanilla thor
+  include Prompter::Methods
+
+  source_root File.expand_path('../templates', __FILE__)
+
+  def self.banner
+    "rails generate flex:setup"
+  end
+
+  def ask_base_name
+    @class_name = ask('Please, enter a class name for your Search class. Choose a name not defined in your app.',
+                      :default => 'FlexSearch', :hint => '[<enter>=FlexSearch]')
+    @extender_name = "#{@class_name}Extender"
+  end
+
+  def add_config_flex_file
+    template 'flex_config.yml', Rails.root.join('config', 'flex.yml')
+  end
+
+  def create_initializer_file
+    template 'flex_initializer.rb.erb', Rails.root.join('config', 'initializers', 'flex.rb')
+  end
+
+  def create_flex_dir
+    template 'flex_dir/es.rb.erb',          Rails.root.join('app', 'flex', "#{@class_name.underscore}.rb")
+    template 'flex_dir/es.yml.erb',         Rails.root.join('app', 'flex', "#{@class_name.underscore}.yml")
+    template 'flex_dir/es_extender.rb.erb', Rails.root.join('app', 'flex', "#{@extender_name.underscore}.rb")
+  end
+
+
+  def show_setup_message
+    say <<-text, :style => :green
+
+    Setup done!
+
+    During prototyping, remember also:
+
+    1. each time you add a `Flex::Model` you should add its name to the "config/initializers/flex.rb"
+    2. each time you add/change a flex.parent relation you should reindex your DB(s) with rake `flex:import FORCE=true`
+
+    The complete documentation is available at https://github.com/ddnexus/flex/wiki
+    If you have any problem with Flex, please report the issue at https://github.com/ddnexus/flex/issues.
+    text
+  end
+
+end
+