agnostic_backend 0.9.0

data/lib/agnostic_backend/indexable/content_manager.rb

@@ -0,0 +1,51 @@
+module AgnosticBackend
+  module Indexable
+
+    class ContentManager
+
+      def add_definitions &block
+        return unless block_given?
+        instance_eval &block
+      end
+
+      def contents
+        @contents ||= {}
+      end
+
+      def method_missing(sym, *args, **kwargs)
+        if FieldType.exists? sym
+          kwargs[:type] = sym
+          field(*args, **kwargs)
+        else
+          super
+        end
+      end
+
+      def respond_to?(sym, include_private=false)
+        FieldType.exists?(sym) || super
+      end
+
+      def field(field_name, value: nil, type:, from: nil, **options)
+        contents[field_name.to_s] = Field.new(value.present? ? value : field_name, type,
+                                              from: from, **options)
+      end
+
+      def extract_contents_from(object, index_name)
+        kv_pairs = contents.map do |field_name, field|
+          field_value = field.evaluate(context: object)
+          if field.type.nested?
+            if field_value.respond_to? :generate_document
+              field_value = field_value.generate_document(for_index: index_name)
+            elsif field_value.present?
+              field_name = nil
+            end
+          end
+          [field_name, field_value]
+        end
+        kv_pairs.reject! { |attr_name, _| attr_name.nil? }
+        Hash[kv_pairs]
+      end
+
+    end
+  end
+end

data/lib/agnostic_backend/indexable/field.rb

@@ -0,0 +1,26 @@
+module AgnosticBackend
+  module Indexable
+
+    class Field
+
+      attr_accessor :value, :type, :from
+
+      def initialize(value, type, from: nil, **options)
+        if type == FieldType::STRUCT && from.nil?
+          raise "A nested type requires the specification of a target class using the `from` argument"
+        end
+        @value = value.respond_to?(:call) ? value : value.to_sym
+        @from = (from.is_a?(Enumerable) ? from : [from]) unless from.nil?
+        @type = FieldType.new(type, **options)
+      end
+
+      def evaluate(context:)
+        value.respond_to?(:call) ?
+          context.instance_eval(&value) :
+          context.send(value)
+      end
+
+    end
+
+  end
+end

data/lib/agnostic_backend/indexable/field_type.rb

@@ -0,0 +1,48 @@
+module AgnosticBackend
+  module Indexable
+    class FieldType
+      INTEGER = :integer
+      DOUBLE = :double
+      STRING = :string # literal string (i.e. should be matched exactly)
+      STRING_ARRAY = :string_array
+      TEXT = :text
+      TEXT_ARRAY = :text_array
+      DATE = :date # datetime
+      BOOLEAN = :boolean
+      STRUCT = :struct # a nested structure containing other values
+
+      def self.all
+        constants.map { |constant| const_get(constant) }
+      end
+
+      def self.exists?(type)
+        all.include? type
+      end
+
+      attr_reader :type, :options
+
+      def initialize(type, **options)
+        raise "Type #{type} not supported" unless FieldType.exists? type
+        @type = type
+        @options = options
+      end
+
+      def nested?
+        type == STRUCT
+      end
+
+      def matches?(type)
+        self.type == type
+      end
+
+      def get_option(option_name)
+        @options[option_name.to_sym]
+      end
+
+      def has_option(option_name)
+        @options.has_key? option_name.to_sym
+      end
+
+    end
+  end
+end

data/lib/agnostic_backend/indexable/indexable.rb

@@ -0,0 +1,125 @@
+module AgnosticBackend
+  module Indexable
+
+    class << self
+      attr_reader :includers
+
+      def indexable_class(index_name)
+        includers.find { |klass| klass.index_name == index_name }
+      end
+    end
+
+    def self.included(base)
+      @includers ||= []
+      @includers << base unless @includers.include? base
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+
+      def create_index
+        AgnosticBackend::Indexable::Config.create_index_for(self)
+      end
+
+      # establishes the convention for determining the index name from the class name
+      def index_name(source=nil)
+        (source.nil? ? name : source.to_s).split('::').last.underscore.pluralize
+      end
+
+      def _index_content_managers
+        @__index_content_managers ||= {}
+      end
+
+      def index_content_manager(index_name)
+        _index_content_managers[index_name.to_s]
+      end
+
+      def _index_root_notifiers
+        @__index_root_notifiers ||= {}
+      end
+
+      def index_root_notifier(index_name)
+        _index_root_notifiers[index_name.to_s]
+      end
+
+      def schema(for_index: nil, &block)
+        index_name = for_index.nil? ? self.index_name : for_index
+        manager = index_content_manager(index_name)
+        raise "Index #{index_name} has not been defined for #{name}" if manager.nil?
+        kv_pairs = manager.contents.map do |field_name, field|
+          schema =
+              if field.type.nested?
+                field.from.map { |klass| klass.schema(for_index: index_name, &block) }.reduce(&:merge)
+              elsif block_given?
+                yield field.type
+              else
+                field.type.type
+              end
+          [field_name, schema]
+        end
+        Hash[kv_pairs]
+      end
+
+      # specifies which fields should be indexed for a given index_name
+      # also sets up the manager for the specified index_name
+      def define_index_fields(owner: nil, &block)
+        return unless block_given?
+        _index_content_managers[index_name(owner)] ||= ContentManager.new
+        _index_content_managers[index_name(owner)].add_definitions &block
+        unless instance_methods(false).include? :_index_content_managers
+          define_method(:_index_content_managers) { self.class._index_content_managers }
+        end
+      end
+
+      # specifies who should be notified when this object is saved
+      def define_index_notifier(target: nil, &block)
+        return unless block_given?
+        _index_root_notifiers[index_name(target)] = block
+        unless instance_methods(false).include? :_index_root_notifiers
+          define_method(:_index_root_notifiers) { self.class._index_root_notifiers }
+        end
+      end
+    end
+
+    module InstanceMethods
+
+      def index_name(source=nil)
+        self.class.index_name(source)
+      end
+
+      def generate_document(for_index: nil)
+        index_name = for_index.nil? ? self.index_name : for_index.to_s
+        return unless respond_to? :_index_content_managers
+        manager = _index_content_managers[index_name.to_s]
+        raise "Index #{index_name} does not exist" if manager.nil?
+        manager.extract_contents_from self, index_name
+      end
+
+      def put_to_index(index_name=nil)
+        indexable_class = index_name.nil? ?
+                            self.class :
+                            AgnosticBackend::Indexable.indexable_class(index_name)
+
+        index = indexable_class.create_index
+        indexer = index.indexer
+        indexer.put(self)
+      end
+
+      def index_object(index_name)
+        put_to_index(index_name)
+      end
+
+      private
+
+      def trigger_index_notification
+        return unless respond_to? :_index_root_notifiers
+        _index_root_notifiers.each do |index_name, block|
+          obj = instance_eval &block
+          obj = [obj] unless obj.is_a? Enumerable
+          obj.each { |o| o.index_object(index_name) if o.present? }
+        end
+      end
+    end
+  end
+end

data/lib/agnostic_backend/indexer.rb

@@ -0,0 +1,48 @@
+module AgnosticBackend
+  class Indexer
+
+    attr_reader :index
+
+    def initialize(index)
+      @index = index
+    end
+
+    # Sends the specified document to the remote backend.
+    # This is a template method.
+    # @param [Indexable] an Indexable object
+    # @returns [boolean] true if success, false if failure
+    # returns nil if no indexing attempt is made (e.g. generated document is empty)
+    def put(indexable)
+      document = indexable.generate_document
+      return if document.blank?
+      begin
+        publish(transform(prepare(document)))
+        true
+      rescue => e
+        false
+      end
+    end
+
+    # Deletes the specified document from the index, This is an abstract
+    # method which concrete index classes must implement in order to provide
+    # its functionality.
+    # @param [document_id] the document id of the indexed document
+    def delete(document_id)
+      raise NotImplementedError
+    end
+
+    private
+
+    def publish(document)
+      raise NotImplementedError
+    end
+
+    def transform(document)
+      raise NotImplementedError
+    end
+
+    def prepare(document)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/agnostic_backend/queryable/attribute.rb

@@ -0,0 +1,22 @@
+module AgnosticBackend
+  module Queryable
+    class Attribute < TreeNode
+      include AgnosticBackend::Utilities
+
+      attr_reader :name, :parent
+
+      def initialize(name, parent:, context:)
+        super([], context)
+        @name, @parent = name, parent
+      end
+
+      def ==(o)
+        super && o.name == name
+      end
+
+      def type
+        value_for_key(context.index.schema, name).try(:type)
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/cloudsearch/executor.rb

@@ -0,0 +1,100 @@
+require 'aws-sdk'
+
+module AgnosticBackend
+  module Queryable
+    module Cloudsearch
+      class Executor < AgnosticBackend::Queryable::Executor
+        include AgnosticBackend::Utilities
+
+        def execute
+          with_exponential_backoff Aws::CloudSearch::Errors::Throttling do
+            response = client.search(params)
+            ResultSet.new(response, query)
+          end
+        end
+
+        def to_s
+          result = ''
+          result += "search?q=#{query_expression}" if query_expression
+          result += " return=#{return_expression}" if return_expression
+          result += " sort=#{sort}" if sort
+          result += " size=#{size}" if size
+          result += " offset=#{start}" if start
+          result += " cursor=#{scroll_cursor}" if scroll_cursor
+          result
+        end
+
+        def params
+          {
+            cursor: scroll_cursor,
+            expr: expr,
+            facet: facet,
+            filter_query: filter_query,
+            highlight: highlight,
+            partial: partial,
+            query: query_expression,
+            query_options: query_options,
+            query_parser: query_parser,
+            return: return_expression,
+            size: size,
+            sort: sort,
+            start: start
+          }
+        end
+
+        private
+
+        def client
+          query.context.index.cloudsearch_domain_client
+        end
+
+        def filter_query
+        end
+
+        def query_expression
+          where_expression ? where_expression.accept(visitor) : 'matchall'
+        end
+
+        def scroll_cursor
+          scroll_cursor_expression.accept(visitor) if scroll_cursor_expression
+        end
+
+        def start
+          offset_expression.accept(visitor) if offset_expression
+        end
+
+        def expr
+        end
+
+        def facet
+        end
+
+        def highlight
+        end
+
+        def partial
+          false
+        end
+
+        def query_options
+        end
+
+        def query_parser
+          'structured'
+        end
+
+        def return_expression
+          select_expression.accept(visitor) if select_expression
+        end
+
+        def size
+          limit_expression.accept(visitor) if limit_expression
+        end
+
+        def sort
+          order_expression.accept(visitor) if order_expression
+        end
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/cloudsearch/query.rb

@@ -0,0 +1,29 @@
+module AgnosticBackend
+  module Queryable
+    module Cloudsearch
+      class Query < AgnosticBackend::Queryable::Query
+
+        def initialize(base)
+          super
+          @executor = Executor.new(self, Visitor.new)
+        end
+
+        def execute
+          @executor.execute if valid?
+        end
+
+        def execute!
+          if valid?
+            @executor.execute
+          else
+            raise StandardError, errors
+          end
+        end
+
+        def to_s
+          @executor.to_s
+        end
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/cloudsearch/query_builder.rb

@@ -0,0 +1,13 @@
+module AgnosticBackend
+  module Queryable
+    module Cloudsearch
+      class QueryBuilder < AgnosticBackend::Queryable::QueryBuilder
+        private
+
+        def create_query(context)
+          AgnosticBackend::Queryable::Cloudsearch::Query.new(context)
+        end
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/cloudsearch/result_set.rb

@@ -0,0 +1,27 @@
+module AgnosticBackend
+  module Queryable
+    module Cloudsearch
+      class ResultSet < AgnosticBackend::Queryable::ResultSet
+        include AgnosticBackend::Utilities
+
+        def total_count
+          raw_results.hits.found
+        end
+
+        def cursor
+          raw_results.hits.cursor
+        end
+
+        private
+
+        def filtered_results
+          raw_results.hits.hit.map(&:fields)
+        end
+
+        def transform(result)
+          transform_nested_values(unflatten(result), Proc.new{|value| value.size > 1 ? value.split.join('|') : value.first})
+        end
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/cloudsearch/visitor.rb

@@ -0,0 +1,127 @@
+module AgnosticBackend
+  module Queryable
+    module Cloudsearch
+      class Visitor < AgnosticBackend::Queryable::Visitor
+
+        private
+
+        def visit_criteria_equal(subject)
+          "(term field=#{visit(subject.attribute)} #{visit(subject.value)})"
+        end
+
+        def visit_criteria_not_equal(subject)
+          "(not term field=#{visit(subject.attribute)} #{visit(subject.value)})"
+        end
+
+        def visit_criteria_greater(subject)
+          "(range field=#{visit(subject.attribute)} {#{visit(subject.value)},})"
+        end
+
+        def visit_criteria_less(subject)
+          "(range field=#{visit(subject.attribute)} {,#{visit(subject.value)}})"
+        end
+
+        def visit_criteria_greater_equal(subject)
+          "(range field=#{visit(subject.attribute)} [#{visit(subject.value)},})"
+        end
+
+        def visit_criteria_less_equal(subject)
+          "(range field=#{visit(subject.attribute)} {,#{visit(subject.value)}])"
+        end
+
+        def visit_criteria_greater_and_less(subject)
+          "(range field=#{visit(subject.attribute)} {#{visit(subject.left_value)},#{visit(subject.right_value)}})"
+        end
+
+        def visit_criteria_greater_equal_and_less(subject)
+          "(range field=#{visit(subject.attribute)} [#{visit(subject.left_value)},#{visit(subject.right_value)}})"
+        end
+
+        def visit_criteria_greater_and_less_equal(subject)
+          "(range field=#{visit(subject.attribute)} {#{visit(subject.left_value)},#{visit(subject.right_value)}])"
+        end
+
+        def visit_criteria_greater_equal_and_less_equal(subject)
+          "(range field=#{visit(subject.attribute)} [#{visit(subject.left_value)},#{visit(subject.right_value)}])"
+        end
+
+        def visit_criteria_contains(subject)
+          "(phrase field=#{visit(subject.attribute)} #{visit(subject.value)})"
+        end
+
+        def visit_criteria_starts(subject)
+          "(prefix field=#{visit(subject.attribute)} #{visit(subject.value)})"
+        end
+
+        def visit_operations_not(subject)
+          "(not #{visit(subject.operand)})"
+        end
+
+        def visit_operations_and(subject)
+          "(and #{subject.operands.map{|o| visit(o)}.join(' ')})"
+        end
+
+        def visit_operations_or(subject)
+          "(or #{subject.operands.map{|o| visit(o)}.join(' ')})"
+        end
+
+        def visit_operations_ascending(subject)
+          "#{visit(subject.attribute)} asc"
+        end
+
+        def visit_operations_descending(subject)
+          "#{visit(subject.attribute)} desc"
+        end
+
+        def visit_query(subject)
+          "#{subject.children.map{|c| visit(c)}.join(' ')}"
+        end
+
+        def visit_expressions_where(subject)
+          visit(subject.criterion) #search?q=
+        end
+
+        def visit_expressions_select(subject)
+          "#{subject.projections.map{|c| visit(c)}.join(',')}" #return=
+        end
+
+        def visit_expressions_order(subject)
+          "#{subject.qualifiers.map{|c| visit(c)}.join(',')}" #sort=
+        end
+
+        def visit_expressions_limit(subject)
+          visit(subject.limit) #size=
+        end
+
+        def visit_expressions_offset(subject)
+          visit(subject.offset) #offset=
+        end
+
+        def visit_expressions_scroll_cursor(subject)
+          visit(subject.scroll_cursor)  #cursor=
+        end
+
+        def visit_attribute(subject)
+          subject.name.split('.').join('__')
+        end
+
+        def visit_value(subject)
+          case subject.type
+          when :integer
+            subject.value
+          when :date
+            "'#{subject.value.utc.strftime("%Y-%m-%dT%H:%M:%SZ")}'"
+          when :double
+            subject.value
+          when :boolean
+            "'#{subject.value}'"
+          when :string,:string_array,:text,:text_array
+            "'#{subject.value}'"
+          else
+            subject.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/criteria/binary.rb

@@ -0,0 +1,47 @@
+module AgnosticBackend
+  module Queryable
+    module Criteria
+      class Binary < Criterion
+        attr_reader :attribute, :value
+
+        def initialize(attribute:, value:, context: nil)
+          @attribute, @value = attribute, value
+          super([attribute, value], context)
+        end
+      end
+
+      class Relational < Binary
+
+        def initialize(attribute:, value:, context: nil)
+          attribute = attribute_component(attribute: attribute, context: context)
+          value = value_component(value: value, context: context, type: attribute.type)
+          super(attribute: attribute, value: value, context: context)
+        end
+      end
+
+      class Equal < Relational;
+      end
+
+      class NotEqual < Relational;
+      end
+
+      class Greater < Relational;
+      end
+
+      class Less < Relational;
+      end
+
+      class GreaterEqual < Relational;
+      end
+
+      class LessEqual < Relational;
+      end
+
+      class Contains < Relational;
+      end
+
+      class Starts < Relational;
+      end
+    end
+  end
+end

data/lib/agnostic_backend/queryable/criteria/criterion.rb

@@ -0,0 +1,13 @@
+module AgnosticBackend
+  module Queryable
+    module Criteria
+      class Criterion < TreeNode
+        def initialize(components = [], context = nil)
+          super
+        end
+
+        alias_method :components, :children
+      end
+    end
+  end
+end