flex 0.1.0

data/lib/flex/model/class_proxy.rb

@@ -0,0 +1,45 @@
+module Flex
+  module Model
+    class ClassProxy < Flex::ClassProxy
+
+      include RelatedModel::ClassSync
+
+      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/model/instance_proxy.rb

@@ -0,0 +1,101 @@
+module Flex
+  module Model
+    class InstanceProxy < RelatedModel::InstanceProxy
+
+      # 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 = %w(0 1 2 3 4 5 6 7 8 9 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z)
+
+      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/model/manager.rb

@@ -0,0 +1,67 @@
+module Flex
+  module Model
+    module Manager
+
+      extend self
+
+      attr_accessor :parent_types
+      @parent_types = []
+
+      def init
+        Configuration.flex_models.each {|m| eval"::#{m}" if m.is_a?(String) }
+      end
+
+      # arrays of all the types
+      def types
+        type_class_map.keys.map{|k| k.split('/').last}
+      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 ||= begin
+          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
+      end
+
+      # maps all the index/types to the ruby class
+      def type_class_map
+        @type_class_map ||= begin
+          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
+      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
+end

data/lib/flex/rails.rb

@@ -0,0 +1,12 @@
+require 'flex'
+require 'rails'
+require 'flex/rails/helper'
+
+if Rails.version.match /^3/
+  require 'flex/rails/engine'
+else
+  Flex::Configuration.configure do |c|
+    c.config_file = Rails.root.join('config', 'flex.yml').to_s
+    c.flex_dir    = Rails.root.join('app', 'flex').to_s
+  end
+end

data/lib/flex/rails/engine.rb

@@ -0,0 +1,23 @@
+module Flex
+  module Rails
+    class Engine < ::Rails::Engine
+
+      ActiveSupport.on_load(:before_configuration) do
+        Flex::Configuration.configure do |c|
+          c.variables[:index] = [self.class.name.split('::').first.underscore, ::Rails.env].join('_')
+          c.config_file       = ::Rails.root.join('config', 'flex.yml').to_s
+          c.flex_dir          = ::Rails.root.join('app', 'flex').to_s
+        end
+      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

@@ -0,0 +1,16 @@
+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::Model::Manager.init
+      end
+
+    end
+  end
+end

data/lib/flex/related_model.rb

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

data/lib/flex/related_model/class_proxy.rb

@@ -0,0 +1,23 @@
+module Flex
+  module RelatedModel
+    class ClassProxy
+
+      attr_reader :host_class
+
+      def initialize(host_class)
+        @host_class = host_class
+      end
+
+      include RelatedModel::ClassSync
+
+      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/related_model/class_sync.rb

@@ -0,0 +1,23 @@
+module Flex
+  module RelatedModel
+    module ClassSync
+
+      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/related_model/instance_proxy.rb

@@ -0,0 +1,28 @@
+module Flex
+  module RelatedModel
+    class InstanceProxy
+      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/result.rb

@@ -0,0 +1,18 @@
+module Flex
+  class Result < ::Hash
+
+    attr_reader :template, :variables, :response
+
+    def initialize(template, variables, response, result=nil)
+      @template  = template
+      @variables = variables
+      @response  = response
+      replace result || !response.body.empty? && MultiJson.decode(response.body) || return
+      Configuration.result_extenders.each do |ext|
+        next if ext.respond_to?(:should_extend?) && !ext.should_extend?(self)
+        extend ext
+      end
+    end
+
+  end
+end

data/lib/flex/result/bulk.rb

@@ -0,0 +1,20 @@
+module Flex
+  class Result
+    module Bulk
+
+      # extend if result comes from a bulk url
+      def self.should_extend?(result)
+        result.response.url =~ /\b_bulk\b/
+      end
+
+      def failed
+        self['items'].reject{|i| i['index']['ok']}
+      end
+
+      def successful
+        self['items'].select{|i| i['index']['ok']}
+      end
+
+    end
+  end
+end

data/lib/flex/result/collection.rb

@@ -0,0 +1,51 @@
+module Flex
+  class Result
+    module Collection
+
+      attr_reader :total_entries, :variables
+
+      def setup(total_entries, variables)
+        @total_entries = total_entries
+        @variables     = variables
+      end
+
+      def per_page
+        (@variables[:per_page] || @variables[:params] && @variables[:params][:size] || @variables[:size] || 10).to_i
+      end
+
+      def total_pages
+        ( @total_entries.to_f / per_page ).ceil
+      end
+
+      def current_page
+        if @variables[:page]
+          @variables[:page].to_i
+        else
+          (per_page + (@variables[:from]||0).to_i) / per_page
+        end
+      end
+
+      def previous_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+
+      def next_page
+        current_page < total_pages ? (current_page + 1) : nil
+      end
+
+      def offset
+        per_page * (current_page - 1)
+      end
+
+      def out_of_bounds?
+        current_page > total_pages
+      end
+
+      alias_method :limit_value,   :per_page
+      alias_method :total_count,   :total_entries
+      alias_method :num_pages,     :total_pages
+      alias_method :offset_value,  :offset
+
+    end
+  end
+end