ansr 0.0.1 → 0.0.3

data/lib/ansr/arel/visitors.rb

@@ -0,0 +1,7 @@
+module Ansr::Arel
+  module Visitors
+    require 'ansr/arel/visitors/context'
+    require 'ansr/arel/visitors/query_builder'
+    require 'ansr/arel/visitors/to_no_sql'
+  end
+end

data/lib/ansr/arel/visitors/context.rb

@@ -0,0 +1,13 @@
+module Ansr::Arel::Visitors
+  class Context
+    attr_reader :attribute
+    def initialize(attribute)
+      @attribute = attribute
+    end
+  end
+
+  # create some thin subclasses in this module
+  %W(Facet Filter From Order).each do |name|
+    const_set(name, Class.new(Context))
+  end
+end

data/lib/ansr/arel/visitors/query_builder.rb

@@ -0,0 +1,47 @@
+module Ansr::Arel::Visitors  
+  class QueryBuilder  < Arel::Visitors::Visitor
+    attr_reader :table
+    def initialize(table)
+      @table = table
+    end
+
+    def visit(object, attribute=nil)
+      super(object, attribute)
+    end
+
+    def visit_Ansr_Arel_BigTable(object, attribute)
+      visit object.name, attribute if Ansr::Arel::Visitors::From === attribute
+      @table = object if Ansr::Arel::BigTable === object and Ansr::Arel::Visitors::From === attribute
+    end
+
+    def visit_Arel_Nodes_SelectCore(object, attribute)
+      visit(object.froms, From.new(attribute)) if object.froms
+      object.projections.each { |x| visit(x, attribute) }
+      object.wheres.each { |x| visit(x, attribute) }
+      object.groups.each {|x| visit(x, attribute) if x}
+      self
+    end
+
+    def visit_Symbol o, a
+      visit o.to_s, a
+    end
+
+    def visit_Array o, a
+      o.map { |x| visit x, a }
+    end
+
+    def visit_Arel_Nodes_And(object, attribute)
+      visit(object.children, attribute)
+    end
+
+    def field_key_from_node(node)
+      table.model.field_name(node)
+    end
+
+    # determines whether multiple values should accumulate or overwrite in merges
+    def multiple?(field_key)
+      false
+    end
+
+  end
+end

data/lib/ansr/arel/visitors/to_no_sql.rb

@@ -0,0 +1,41 @@
+module Ansr::Arel::Visitors
+  class ToNoSql < Arel::Visitors::Visitor
+    attr_reader :table
+
+    def initialize(big_table)
+      super()
+      @table = big_table
+    end
+
+    def query_builder(opts = nil)
+      Ansr::Arel::Visitors::QueryBuilder.new(table, opts)
+    end
+
+    # the object generated by this method will be passed to the NoSqlAdapter#execute
+    def visit_Arel_Nodes_SelectStatement(object, attribute)
+      builder = query_builder
+
+      if object.with
+        builder.visit(object.with, attribute)
+      end
+
+      object.cores.each { |x| builder.visit_Arel_Nodes_SelectCore(x, attribute) }
+
+      unless object.orders.empty?
+
+        object.orders.each do |x|
+          oa = Ansr::Arel::Visitors::Order.new(attribute)
+          builder.visit x, oa
+        end
+      end
+
+      builder.visit(object.limit, attribute) if object.limit
+      builder.visit(object.offset, attribute) if object.offset
+      # not relevant
+
+      builder.query_opts
+    end
+
+  end
+
+end

data/lib/ansr/base.rb

@@ -1,10 +1,13 @@
+require 'active_record'
 module Ansr
   class Base < ActiveRecord::Base
-    extend Ansr::Model::Methods
+    include Ansr::Model
     extend Ansr::Configurable
     extend Ansr::QueryMethods
     extend Ansr::ArelMethods
     include Ansr::Sanitization
+    #TODO remove the dummy associations
+    include Ansr::DummyAssociations
 
     self.abstract_class = true
     
@@ -13,6 +16,27 @@ module Ansr
       @source_doc = doc
     end
 
+    def core_initialize(attributes = nil, options = {})
+      defaults = self.class.column_defaults.dup
+      defaults.each { |k, v| defaults[k] = v.dup if v.duplicable? }
+
+      @attributes   = self.class.initialize_attributes(defaults)
+      @column_types_override = nil
+      @column_types = self.class.column_types
+
+      init_internals
+      init_changed_attributes
+      ensure_proper_type
+      populate_with_current_scope_attributes
+
+      # +options+ argument is only needed to make protected_attributes gem easier to hook.
+      # Remove it when we drop support to this gem.
+      init_attributes(attributes, options) if attributes
+
+      yield self if block_given?
+      run_callbacks :initialize unless _initialize_callbacks.empty?
+    end
+
     def filter_source_hash(doc)
       fields = self.class.model().table().fields()
       filtered = doc.select do |k,v|
@@ -21,6 +45,10 @@ module Ansr
       filtered.with_indifferent_access
     end
 
+    def columns(name=self.name)
+      super(name)
+    end
+
     def [](key)
       @source_doc[key]
     end

data/lib/ansr/configurable.rb

@@ -1,17 +1,11 @@
 module Ansr
   module Configurable
-    def config(yaml=nil)
-      yaml ? @config ||= begin
-        y = begin
-          case yaml
-          when String
-            File.open(yaml) {|blob| YAML.load(blob)}
-          else
-            yaml
-          end
-        end
-        y
-      end : @config
+    def config
+      @config ||= {}
+      if block_given?
+        yield @config
+      end
+      @config
     end
 
     alias_method :configure, :config

data/lib/ansr/connection_adapters.rb

@@ -0,0 +1,5 @@
+module Ansr
+	module ConnectionAdapters
+    require 'ansr/connection_adapters/no_sql_adapter'
+  end
+end

data/lib/ansr/connection_adapters/no_sql_adapter.rb

@@ -0,0 +1,80 @@
+require 'active_record'
+require 'arel/visitors/bind_visitor'
+module Ansr
+	module ConnectionAdapters
+    class NoSqlAdapter < ActiveRecord::ConnectionAdapters::AbstractAdapter
+      attr_reader :table
+      def initialize(klass, connection, logger = nil, pool = nil)
+        super(connection, logger, pool)
+        @table = klass.table
+        @visitor = nil
+      end
+
+      # Converts an arel AST to NOSQL Query
+      def to_nosql(arel, binds = [])
+        arel = arel.ast if arel.respond_to?(:ast)
+        if arel.is_a? ::Arel::Nodes::Node
+          binds = binds.dup
+          visitor.accept(arel) do
+            quote(*binds.shift.reverse)
+          end
+        else # assume it is already serialized
+          arel
+        end
+      end
+
+      # attr_accessor :visitor is a self.class::BindSubstitution in unprepared contexts
+      class BindSubstitution < ::Arel::Visitors::MySQL # :nodoc:
+        include ::Arel::Visitors::BindVisitor
+      end
+
+      # Executes +query+ statement in the context of this connection using
+      # +binds+ as the bind substitutes. +name+ is logged along with
+      # the executed +query+ statement.
+      def execute(query, name = 'ANSR-NOSQL')
+      end
+
+      # called back from ::Arel::Table
+      def primary_key(table_name)
+        'id' # table.primary_key || 'id'
+      end
+
+      def table_exists?(name)
+        true
+      end
+
+      def schema_cache
+        ActiveRecord::ConnectionAdapters::SchemaCache.new(self)
+      end
+
+      # this is called by the BigTable impl
+      # should it be retired in favor of the more domain-appropriate 'fields'? Not usually seen by clients anyway.
+      def columns(table_name, *rest)
+        @table.fields.map {|s| ::ActiveRecord::ConnectionAdapters::Column.new(s.to_s, nil, String)}
+      end
+
+      def sanitize_limit(limit_value)
+        if limit_value.to_s.to_i >= 0
+          limit_value
+        else
+          Ansr::Relation::DEFAULT_PAGE_SIZE
+        end
+      end
+
+      def sanitize_filter_name(filter_value)
+        if filter_value.is_a? Array
+          return filter_value.collect {|x| sanitize_filter_name(x)}.compact
+        else
+          if @table.facets.include? filter_value.to_sym
+            return filter_value
+          else
+            raise "#{filter_value} is not a filterable field"
+            #Rails.logger.warn "Ignoring #{filter_value} (not a filterable field)" if Rails.logger
+            #return nil
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ansr/dummy_associations.rb

@@ -0,0 +1,105 @@
+module Ansr
+  module DummyAssociations
+    extend ActiveSupport::Concern
+    module ClassMethods
+      def create_reflection(macro, name, scope, options, active_record)
+        case macro
+        when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
+          klass = options[:through] ? DummyThroughReflection : DummyAssociationReflection
+          reflection = klass.new(macro, name, scope, options, active_record)
+        when :composed_of
+          reflection = DummyAggregateReflection.new(macro, name, scope, options, active_record)
+        end
+
+        self.reflections = self.reflections.merge(name => reflection)
+        reflection
+      end
+
+      # Returns an array of AggregateReflection objects for all the aggregations in the class.
+      def reflect_on_all_aggregations
+        reflections.values.grep(DummyAggregateReflection)
+      end
+
+      # Returns the AggregateReflection object for the named +aggregation+ (use the symbol).
+      #
+      #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
+      #
+      def reflect_on_aggregation(aggregation)
+        reflection = reflections[aggregation]
+        reflection if reflection.is_a?(DummyAggregateReflection)
+      end
+
+      # Returns an array of DummyAssociationReflection objects for all the
+      # associations in the class. If you only want to reflect on a certain
+      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>,
+      # <tt>:belongs_to</tt>) as the first parameter.
+      #
+      # Example:
+      #
+      #   Account.reflect_on_all_associations             # returns an array of all associations
+      #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
+      #
+      def reflect_on_all_associations(macro = nil)
+        association_reflections = reflections.values.grep(DummyAssociationReflection)
+        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
+      end
+
+      # Returns the DummyAssociationReflection object for the +association+ (use the symbol).
+      #
+      #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
+      #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
+      #
+      def reflect_on_association(association)
+        reflection = reflections[association]
+        reflection if reflection.is_a?(DummyAssociationReflection)
+      end
+
+      # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
+      def reflect_on_all_autosave_associations
+        reflections.values.select { |reflection| reflection.options[:autosave] }
+      end
+    end
+    class DummyReflection < ActiveRecord::Reflection::AggregateReflection
+      def initialize(macro, name, scope, options, active_record)
+        super(macro, name, scope, options, active_record)
+        @symbol = name
+      end
+
+      def polymorphic?
+        false
+      end
+
+      def foreign_key
+        @symbol # ??
+      end
+      def collection?
+        [:has_one, :has_many, :has_and_belongs_to_many].include? macro
+      end
+      def validate?
+        false
+      end
+      def association_class
+        DummyAssociation
+      end
+
+      def check_validity!
+        true
+      end
+    end
+    class DummyAssociationReflection < DummyReflection; end
+    class DummyAggregateReflection < DummyReflection; end
+    class DummyThroughReflection < DummyReflection; end
+    class DummyAssociation < ActiveRecord::Associations::Association
+      def writer(*args); end
+      def reader(*args)
+        self
+      end
+      def loaded?
+        true
+      end
+      def identifier
+        nil
+      end
+    end
+  end
+end

data/lib/ansr/facets.rb

@@ -0,0 +1,103 @@
+require 'ostruct'
+
+module Ansr::Facets
+  
+  # represents a facet value; which is a field value and its hit count
+  class FacetItem < OpenStruct
+    def initialize *args
+      options = args.extract_options!
+
+      # Backwards-compat method signature
+      value = args.shift
+      hits = args.shift
+
+      options[:value] = value if value
+      options[:hits] = hits if hits
+      
+      super(options)
+    end
+
+    def label
+      super || value
+    end
+
+    def as_json(props = nil)
+      table.as_json(props)
+    end
+  end
+  
+  # represents a facet; which is a field and its values
+  class FacetField
+    attr_reader :name, :items
+    def initialize name, items, options = {}
+      @name, @items = name, items
+      @options = options
+    end
+
+    def limit
+      @options[:limit]
+    end
+
+    def sort
+      @options[:sort] || 'index'
+    end
+
+    def offset
+      @options[:offset] || 0
+    end
+  end
+  
+  # @response.facets.each do |facet|
+  #   facet.name
+  #   facet.items
+  # end
+  # "caches" the result in the @facets instance var
+  def facets
+    @facets ||= begin
+      facet_fields.map do |(facet_field_name,values_and_hits)|
+        items = []
+        options = {}
+        values_and_hits.each_slice(2) do |k,v|
+          items << FacetItem.new(:value => k, :hits => v)
+        end
+        options[:sort] = (params[:"f.#{facet_field_name}.facet.sort"] || params[:'facet.sort'])
+        if params[:"f.#{facet_field_name}.facet.limit"] || params[:"facet.limit"]
+          options[:limit] = (params[:"f.#{facet_field_name}.facet.limit"] || params[:"facet.limit"]).to_i
+        end
+
+        if params[:"f.#{facet_field_name}.facet.offset"] || params[:'facet.offset']
+          options[:offset] = (params[:"f.#{facet_field_name}.facet.offset"] || params[:'facet.offset']).to_i
+        end
+        FacetField.new(facet_field_name, items, options)
+      end
+    end
+  end
+  
+  # pass in a facet field name and get back a Facet instance
+  def facet_by_field_name(name)
+    @facets_by_field_name ||= {}
+    @facets_by_field_name[name] ||= (
+      facets.detect{|facet|facet.name.to_s == name.to_s}
+    )
+  end
+  
+  def facet_counts
+    @facet_counts ||= self['facet_counts'] || {}
+  end
+
+  # Returns the hash of all the facet_fields (ie: {'instock_b' => ['true', 123, 'false', 20]}
+  def facet_fields
+    @facet_fields ||= facet_counts['facet_fields'] || {}
+  end
+
+  # Returns all of the facet queries
+  def facet_queries
+    @facet_queries ||= facet_counts['facet_queries'] || {}
+  end
+  
+  # Returns all of the facet queries
+  def facet_pivot
+    @facet_pivot ||= facet_counts['facet_pivot'] || {}
+  end
+  
+end # end Facets