flex 0.4.2 → 1.0.1

data/lib/flex/api_methods.yml

@@ -1,108 +0,0 @@
-# These methods are available as Flex.<method>(variable_hash)
-# you can get the updated full reference and usage example of these methods
-# by just doing in the console:
-# >> puts Flex.info
-
-# http://www.elasticsearch.org/guide/reference/api/admin-indices-indices-exists.html
-indices_exists: &exist
-  - HEAD
-  - /<<index>>
-
-# aliased
-exist?: *exist
-
-# http://www.elasticsearch.org/guide/reference/api/admin-indices-create-index.html
-create_index: &create
-  - PUT
-  - /<<index>>
-  - settings:
-      number_of_shards: <<number_of_shards= 5 >>
-      number_of_replicas: <<number_of_replicas= 1 >>
-
-# aliased
-put_index: *create
-
-post_index:
-  - POST
-  - /<<index>>
-  - settings:
-      number_of_shards: <<number_of_shards= 5 >>
-      number_of_replicas: <<number_of_replicas= 1 >>
-
-# http://www.elasticsearch.org/guide/reference/api/admin-indices-get-settings.html
-get_settings:
-  - GET
-  - /<<index>>/_settings
-
-# http://www.elasticsearch.org/guide/reference/api/admin-indices-put-mapping.html
-put_mapping:
-  - PUT
-  - /<<index>>/<<type>>/_mapping
-  - <<type>>:
-      properties: <<properties>>
-
-# http://www.elasticsearch.org/guide/reference/api/admin-indices-get-mapping.html
-get_mapping:
-  - GET
-  - /<<index>>/<<type>>/_mapping
-
-# http://www.elasticsearch.org/guide/reference/api/admin-indices-delete-mapping.html
-delete_mapping:
-  - DELETE
-  - /<<index>>/<<type>>
-
-# http://www.elasticsearch.org/guide/reference/api/delete.html
-delete_index:
-  - DELETE
-  - /<<index>>
-
-# http://www.elasticsearch.org/guide/reference/api/delete-by-query.html
-delete_by_query:
-  - DELETE
-  - /<<index>>/<<type>>/_query
-  # pass :data variable query if you need
-
-# http://www.elasticsearch.org/guide/reference/api/bulk.html
-bulk:
-  - POST
-  - /_bulk
-  - << lines >>
-
-# http://www.elasticsearch.org/guide/reference/api/count.html
-count:
-  - GET
-  - /<<index>>/<<type>>/_count
-  # pass :data structure if you need
-
-# http://www.elasticsearch.org/guide/reference/api/admin-indices-stats.html
-stats:
-  - GET
-  - /<<index>>/_stats/<<end_point= ~ >>
-
-# You must pass the :data variable
-store: &store
-  - PUT
-  - /<<index>>/<<type>>/<<id>>
-
-# alias for symmetry with post_store
-put_store: *store
-
-# id is assigned by ES; you must pass :data
-post_store:
-  - POST
-  - /<<index>>/<<type>>
-
-remove:
-  - DELETE
-  - /<<index>>/<<type>>/<<id>>
-
-# http://www.elasticsearch.org/guide/reference/api/get.html
-get:
-  - GET
-  - /<<index>>/<<type>>/<<id>>
-
-# http://www.elasticsearch.org/guide/reference/api/multi-get.html
-multi_get:
-  - GET
-  - /<<index>>/<<type>>/_mget
-  - ids: << ids >>

data/lib/flex/class_proxy/loader.rb

@@ -1,102 +0,0 @@
-module Flex
-  module ClassProxy
-    class Loader < Base
-      attr_reader :templates, :partials
-
-      include Template::Info
-
-      def initialize(base)
-        super
-        @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/
-          paths = [ "#{Configuration.flex_dir}/#{source}.yml",
-                    "#{Configuration.flex_dir}/#{Manager.class_name_to_type(host_class.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)
-      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
-
-      # adds a template instance and defines the template method in the host class
-      def add_template(name, template)
-        templates[name] = template
-        # no define_singleton_method in 1.8.7
-        host_class.instance_eval <<-ruby, __FILE__, __LINE__ + 1
-          def #{name}(vars={})
-            raise ArgumentError, "#{host_class}.#{name} expects a Hash (got \#{vars.inspect})" unless vars.is_a?(Hash)
-            #{host_class.respond_to?(:preprocess_variables) && 'preprocess_variables(vars)'}
-            flex.templates[:#{name}].render(vars)
-          end
-        ruby
-      end
-
-      # http://www.elasticsearch.org/guide/reference/api/multi-search.html
-      # request may be a hash with the templates names as keys and the variable hash as value
-      # or you can also use an array of arrays.
-      # The variables are an hash of variables that will be used to render the msearch template
-      def multi_search(requests, variables={})
-        lines    = requests.map { |name, vars| templates[name].to_msearch(vars) }.join()
-        template = Template.new('GET', '/<<index>>/<<type>>/_msearch')
-        template.send(:do_render, variables.merge(:data => lines)) do |http_response|
-          responses   = []
-          es_response = MultiJson.decode(http_response.body)
-          es_response['responses'].each_with_index do |result, i|
-            responses << Result.new(templates[requests[i].first], requests[i].last, http_response, result)
-          end
-          es_response['responses'] = responses
-          def es_response.responses
-            self['responses']
-          end
-          es_response
-        end
-      end
-
-      private
-
-      def do_load_source(klass, source, source_vars)
-        source = Utils.erb_process(source) unless source.match("\n") # skips non-path
-        hash   = Utils.data_from_source(source)
-        hash.delete('ANCHORS')
-        hash.each do |name, structure|
-          if name.to_s =~ /^_/ # partial
-            partial = Template::Partial.new(structure, self)
-            partials[name.to_sym] = partial
-          else
-            template = klass.new(*structure).setup(self, name, source_vars)
-            add_template(name.to_sym, template)
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/flex/class_proxy/model.rb

@@ -1,45 +0,0 @@
-module Flex
-  module ClassProxy
-    class Model < Base
-
-      include ModelSync
-
-      attr_reader :parent_association, :parent_child_map
-
-      def initialize(base)
-        super
-        variables.add :index => Configuration.variables[:index],
-                      :type  => Manager.class_name_to_type(host_class.name)
-      end
-
-      def index
-        variables[:index]
-      end
-
-      def index=(val)
-        variables[:index] = val
-      end
-
-      def type
-        variables[:type]
-      end
-
-      def type=(val)
-        variables[:type] = val
-      end
-
-      def parent(parent_association, map)
-        @parent_association = parent_association
-        Manager.parent_types |= map.keys.map(&:to_s)
-        self.type = map.values.map(&:to_s)
-        @parent_child_map = map
-        @is_child         = true
-      end
-
-      def is_child?
-        !!@is_child
-      end
-
-    end
-  end
-end

data/lib/flex/class_proxy/model_sync.rb

@@ -1,23 +0,0 @@
-module Flex
-  module ClassProxy
-    module ModelSync
-
-      def self.included(base)
-        base.class_eval do
-          attr_accessor :synced
-        end
-      end
-
-      def sync(*synced)
-        @synced = synced
-        host_class.class_eval do
-          raise NotImplementedError, "the class #{self} must implement :after_save and :after_destroy callbacks" \
-                unless respond_to?(:after_save) && respond_to?(:after_destroy)
-          after_save    { flex.sync }
-          after_destroy { flex.sync }
-        end
-      end
-
-    end
-  end
-end

data/lib/flex/class_proxy/related_model.rb

@@ -1,23 +0,0 @@
-module Flex
-  module ClassProxy
-    class RelatedModel
-
-      attr_reader :host_class
-
-      def initialize(host_class)
-        @host_class = host_class
-      end
-
-      include ModelSync
-
-      alias_method :full_sync, :sync
-
-      def sync(*synced)
-        raise ArgumentError, 'You cannot flex.sync(self) a Flex::RelatedModel.' \
-              if synced.any?{|s| s == host_class}
-        full_sync
-      end
-
-    end
-  end
-end

data/lib/flex/instance_proxy/base.rb

@@ -1,29 +0,0 @@
-module Flex
-  module InstanceProxy
-
-    class Base
-      attr_reader :instance, :class_flex
-
-      def initialize(instance)
-        @instance   = instance
-        @class_flex = instance.class.flex
-      end
-
-      def sync
-        class_flex.synced.each do |s|
-          case
-          when s == instance.class               # only called for Flex::Model
-            instance.destroyed? ? remove : store
-          when s.is_a?(Symbol)
-            instance.send(s).flex.sync
-          when s.is_a?(String)
-            parent_instance.flex.sync if s == parent_instance.flex.type
-          else
-            raise ArgumentError, "self, string or symbol expected, got #{s.inspect}"
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/flex/instance_proxy/model.rb

@@ -1,102 +0,0 @@
-module Flex
-  module InstanceProxy
-    class Model < Base
-
-      # indexes the document
-      # usually called from after_save, you can eventually call it explicitly for example from another callback
-      # or whenever the DB doesn't get updated by the model
-      # you can also pass the :data=>flex_source explicitly (useful for example to override the flex_source in the model)
-      def store(vars={})
-        if instance.flex_indexable?
-          Flex.store metainfo.merge(:data => instance.flex_source).merge(vars)
-        else
-          Flex.remove(metainfo.merge(vars)) if Flex.get(metainfo.merge(vars.merge(:raise => false)))
-        end
-      end
-
-      # removes the document from the index (called from after_destroy)
-      def remove(vars={})
-        return unless instance.flex_indexable?
-        Flex.remove metainfo.merge(vars)
-      end
-
-      # gets the document from ES
-      def get(vars={})
-        return unless instance.flex_indexable?
-        Flex.get metainfo.merge(vars)
-      end
-
-      def parent_instance(raise=true)
-        return unless is_child?
-        @parent_instance ||= instance.send(class_flex.parent_association) || raise &&
-                               raise(MissingParentError, "missing parent instance for document #{instance.inspect}.")
-      end
-
-      # helper that iterates through the parent record chain
-      # record.flex.each_parent{|p| p.do_smething }
-      def each_parent
-        pi = parent_instance
-        while pi do
-          yield pi
-          pi = pi.flex.parent_instance
-        end
-      end
-
-      def type
-        @type ||= is_child? ? class_flex.parent_child_map[parent_instance.flex.type] : class_flex.type
-      end
-
-      def index
-        class_flex.index
-      end
-
-      def id
-        instance.id
-      end
-
-      def routing(raise=true)
-        @routing ||= case
-                     when is_child?  then parent_instance(raise).flex.routing
-                     when is_parent? then create_routing
-                     end
-      end
-
-      def is_child?
-        @is_child ||= class_flex.is_child?
-      end
-
-      def is_parent?
-        @is_parent ||= Manager.parent_types.include?(type)
-      end
-
-      def metainfo
-        @metainfo ||= begin
-          meta = { :index => index, :type => type, :id => id }
-          params = {}
-          params[:routing] = routing if routing
-          params[:parent]  = parent_instance.id if is_child?
-          meta.merge!(:params => params) unless params.empty?
-          meta
-        end
-      end
-
-      private
-
-      BASE62_DIGITS = ('0'..'9').to_a + ('A'..'Z').to_a + ('a'..'z').to_a
-
-      def create_routing
-        string    = [index, type, id].join
-        remainder = Digest::MD5.hexdigest(string).to_i(16)
-        result    = []
-        max_power = ( Math.log(remainder) / Math.log(62) ).floor
-        max_power.downto(0) do |power|
-          digit, remainder = remainder.divmod(62**power)
-          result << digit
-        end
-        result << remainder if remainder > 0
-        result.map{|digit| BASE62_DIGITS[digit]}.join
-      end
-
-    end
-  end
-end

data/lib/flex/instance_proxy/related_model.rb

@@ -1,7 +0,0 @@
-module Flex
-  module InstanceProxy
-    class RelatedModel < Base
-
-    end
-  end
-end