flex 0.4.2 → 1.0.1

data/lib/flex/loader.rb

@@ -1,18 +0,0 @@
-module Flex
-  module Loader
-
-    extend self
-    attr_accessor :host_classes
-    @host_classes = []
-
-    def self.included(base)
-      base.class_eval do
-        Flex::Loader.host_classes |= [base]
-        @flex ||= ClassProxy::Loader.new(base)
-        def self.flex; @flex end
-      end
-    end
-
-  end
-end
-

data/lib/flex/manager.rb

@@ -1,61 +0,0 @@
-module Flex
-  module Manager
-
-    extend self
-
-    attr_accessor :parent_types
-    @parent_types = []
-
-    def init_models
-      Configuration.flex_models.each {|m| eval"::#{m}" if m.is_a?(String) }
-    end
-
-    # arrays of all the types
-    def types
-      @types ||= Configuration.flex_models.map {|m| (m.is_a?(String) ? eval("::#{m}") : m).flex.type }.flatten
-    end
-
-    # sets the default parent/child mappings and merges with the config_file
-    # returns the indices structure used for creating the indices
-    def indices(file=Configuration.config_file)
-      @indices ||= ( default = {}.extend Structure::Mergeable
-                     Configuration.flex_models.each do |m|
-                       m = eval"::#{m}" if m.is_a?(String)
-                       next unless m.flex.is_child?
-                       index = m.flex.index
-                       m.flex.parent_child_map.each do |parent, child|
-                         default.add index => {'mappings' => {child => {'_parent' => {'type' => parent }}}}
-                       end
-                     end
-                     hash = YAML.load(Utils.erb_process(file))
-                     hash.delete('ANCHORS')
-                     default.deep_merge(hash) )
-    end
-
-    # maps all the index/types to the ruby class
-    def type_class_map
-      @type_class_map ||= ( map = {}
-                            Configuration.flex_models.each do |m|
-                              m = eval("::#{m}") if m.is_a?(String)
-                              types = m.flex.type.is_a?(Array) ? m.flex.type : [m.flex.type]
-                              types.each do |t|
-                                map["#{m.flex.index}/#{t}"] = m
-                              end
-                            end
-                            map )
-    end
-
-    def class_name_to_type(class_name)
-      type = class_name.tr(':', '_')
-      type.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
-      type.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-      type.downcase!
-      type
-    end
-
-    def type_to_class_name(type)
-      type.gsub(/__(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-    end
-
-  end
-end

data/lib/flex/model.rb

@@ -1,24 +0,0 @@
-module Flex
-  module Model
-
-    def self.included(base)
-      base.class_eval do
-        @flex ||= ClassProxy::Model.new(base)
-        def self.flex; @flex end
-      end
-    end
-
-    def flex
-      @flex ||= InstanceProxy::Model.new(self)
-    end
-
-    def flex_source
-      to_hash.reject {|k| k.to_s =~ /^_*id$/}.to_json
-    end
-
-    def flex_indexable?
-      true
-    end
-
-  end
-end

data/lib/flex/rails/engine.rb

@@ -1,23 +0,0 @@
-module Flex
-  module Rails
-    class Engine < ::Rails::Engine
-
-      ActiveSupport.on_load(:before_configuration) do
-        config.flex = Flex::Configuration
-        config.flex.variables[:index] = [self.class.name.split('::').first.underscore, ::Rails.env].join('_')
-        config.flex.config_file       = ::Rails.root.join('config', 'flex.yml').to_s
-        config.flex.flex_dir          = ::Rails.root.join('app', 'flex').to_s
-        config.flex.debug             = ::Rails.env.development?
-      end
-
-      ActiveSupport.on_load(:after_initialize) do
-        Helper.after_initialize
-      end
-
-      config.to_prepare do
-        Flex.reload!
-      end
-
-    end
-  end
-end

data/lib/flex/rails/helper.rb

@@ -1,16 +0,0 @@
-module Flex
-  module Rails
-    module Helper
-      extend self
-
-      def after_initialize
-        # use the same app logger
-        Flex::Configuration.logger = ::Rails.logger
-        # we need to reload the flex API methods with the new variables
-        Flex.reload!
-        Flex::Manager.init_models
-      end
-
-    end
-  end
-end

data/lib/flex/related_model.rb

@@ -1,16 +0,0 @@
-module Flex
-  module RelatedModel
-
-    def self.included(base)
-      base.class_eval do
-        @flex ||= ClassProxy::RelatedModel.new(base)
-        def self.flex; @flex end
-      end
-    end
-
-    def flex
-      @flex ||= InstanceProxy::RelatedModel.new(self)
-    end
-
-  end
-end

data/lib/flex/result/indifferent_access.rb

@@ -1,11 +0,0 @@
-module Flex
-  module Result
-    module IndifferentAccess
-
-      def self.extended(result)
-        result.extend Structure::IndifferentAccess
-      end
-
-    end
-  end
-end

data/lib/flex/result/source_document.rb

@@ -1,63 +0,0 @@
-module Flex
-  class Result
-
-    #  adds sugar to documents with the following structure:
-    #
-    #    {
-    #        "_index" : "twitter",
-    #        "_type" : "tweet",
-    #        "_id" : "1",
-    #        "_source" : {
-    #            "user" : "kimchy",
-    #            "postDate" : "2009-11-15T14:12:12",
-    #            "message" : "trying out Elastic Search"
-    #        }
-    #    }
-
-    module SourceDocument
-
-      # extend if result has a structure like a document
-      def self.should_extend?(obj)
-        %w[_index _type _id _source].all? {|k| obj.has_key?(k)}
-      end
-
-      # exposes _source: automatically supply object-like reader access
-      # also expose meta fields like _id, _source, etc, also for methods without the leading '_'
-      def method_missing(meth, *args, &block)
-        case
-        when meth.to_s =~ /^_/ && has_key?(meth.to_s) then self[meth.to_s]
-        when self['_source'].has_key?(meth.to_s)      then self['_source'][meth.to_s]
-        when has_key?("_#{meth.to_s}")                then self["_#{meth.to_s}"]
-        else super
-        end
-      end
-
-      # returns the _source hash with an added id (if missing))
-      def to_attributes
-        {'id' => _id}.merge(_source)
-      end
-
-      # creates an instance of a mapped or computed class, falling back to OpenStruct
-      def to_mapped
-        to(mapped_class || OpenStruct)
-      end
-
-      # experimental: creates an instance of klass out of to_attributes
-      # we should probably reset the id to the original document _id
-      # but be sure the record is read-only
-      def to(klass)
-        obj = klass.new(to_attributes)
-        case
-        when defined?(ActiveRecord::Base) && obj.is_a?(ActiveRecord::Base)
-          obj.readonly!
-        when defined?(Mongoid::Document)  && obj.is_a?(Mongoid::Document)
-          # TODO: make it readonly
-        when obj.is_a?(OpenStruct)
-          # TODO: anythig to extend?
-        end
-        obj
-      end
-
-    end
-  end
-end

data/lib/flex/result/source_search.rb

@@ -1,32 +0,0 @@
-module Flex
-  class Result
-    module SourceSearch
-
-      # extend if result comes from a search url and does not contain an empty fields param (no _source))
-      def self.should_extend?(result)
-        result.response.url =~ /\b_m?search\b/ &&
-            !result['hits']['hits'].empty? && result['hits']['hits'].first.has_key?('_source')
-      end
-
-      # extend the hits results on extended
-      def self.extended(result)
-        result['hits']['hits'].each { |h| h.extend(SourceDocument) }
-      end
-
-      # experimental
-      # returns an array of document mapped objects
-      def mapped_collection
-        @mapped_collection ||= begin
-                               docs = self['hits']['hits'].map do |h|
-                                        raise NameError, "no '_source' found in hit #{h.inspect} " \
-                                              unless h.respond_to(:to_mapped)
-                                        h.to_mapped
-                                      end
-                               docs.extend Collection
-                               docs.setup(self['hits']['total'], variables)
-                             end
-      end
-
-    end
-  end
-end

data/lib/flex/structure/indifferent_access.rb

@@ -1,44 +0,0 @@
-module Flex
-  module Structure
-    # allows to use both Symbol or String keys to access the same values in a Hash
-    module IndifferentAccess
-
-      def [](k)
-        get_value(k)
-      end
-
-      def []=(k,v)
-        # default to_s for storing new keys
-        has_key?(k) ? super : super(k.to_s, v)
-      end
-
-      def to_hash
-        self
-      end
-
-    private
-
-      def get_value(k)
-        val = fetch_val(k)
-        case val
-        when Hash
-          val.extend IndifferentAccess
-        when Array
-          val.each {|v| v.extend IndifferentAccess if v.is_a?(Hash)}
-        end
-        val
-      end
-
-      def fetch_val(k)
-        v = fetch(k, nil)
-        return v unless v.nil?
-        if k.is_a?(String)
-          v = fetch(k.to_sym, nil)
-          return v unless v.nil?
-        end
-        fetch(k.to_s, nil) if k.is_a?(Symbol)
-      end
-
-    end
-  end
-end

data/lib/flex/structure/mergeable.rb

@@ -1,21 +0,0 @@
-module Flex
-  module Structure
-    # allows deep merge between Hashes
-    module Mergeable
-
-      def deep_merge(*hashes)
-        Utils.deep_merge_hashes(self, *hashes)
-      end
-
-      def deep_merge!(*hashes)
-        replace deep_merge(*hashes)
-      end
-      alias_method :add, :deep_merge!
-
-      def deep_dup
-        Marshal.load(Marshal.dump(self))
-      end
-
-    end
-  end
-end

data/lib/flex/template/base.rb

@@ -1,41 +0,0 @@
-module Flex
-  class Template
-
-    module PrunableObject end
-
-    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] ||= {}
-          vars[:params][:size] ||= vars[:size] || 10
-          page = vars[:page].to_i
-          page = 1 unless page > 0
-          vars[:params][:from] = ((page - 1) * vars[:params][:size]).ceil
-        end
-        vars
-      end
-
-      # extend obj with PrunableObject if it is nil or it is an empty Array or Hash
-      # called from stringified
-      def prunable(name, vars)
-        obj = vars[name]
-        return obj if vars[:no_pruning].include?(name)
-        (obj.nil? || obj == [] || obj == {}) ? obj.extend(PrunableObject) : obj
-      end
-
-    end
-  end
-end

data/lib/flex/template/info.rb

@@ -1,68 +0,0 @@
-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
-########## #{meth_call} ##########
-
-#{'-' * temp.class.to_s.length}
-#{temp.class}
-#{temp.to_flex(name)}
-meth_call
-          temp.partials.each do |par_name|
-            par = partials[par_name]
-            block << <<-partial
-#{'-' * par.class.to_s.length}
-#{par.class}
-#{par.to_flex(par_name)}
-partial
-          end
-          block << "\nUsage:\n"
-          block << usage(meth_call, temp)
-          block << "\n "
-          info  << block.split("\n").map{|l| '#  ' + l}.join("\n")
-          info  <<  <<-meth
-
-def #{meth_call}(vars={})
-  ## this is a stub, used for reference
-end
-
-
-meth
-        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