outoftime-sunspot 0.0.1

data/lib/sunspot/field_builder.rb

@@ -0,0 +1,37 @@
+module Sunspot
+  class FieldBuilder
+    def initialize(clazz)
+      @clazz = clazz
+    end
+
+    def text(*names, &block)
+      for name in names
+        ::Sunspot::Field.register_text clazz, build_field(name, ::Sunspot::Type::TextType, &block)
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      begin
+        type = ::Sunspot::Type.const_get "#{method.to_s.camel_case}Type"
+      rescue(NameError)
+        super(method.to_sym, *args, &block) and return
+      end
+      name = args.shift
+      ::Sunspot::Field.register clazz, build_field(name, type, *args, &block)
+    end
+
+    protected
+    attr_reader :clazz
+
+    private
+
+    def build_field(name, type, *args, &block)
+      options = args.shift if args.first.is_a?(Hash)
+      unless block
+        ::Sunspot::Field::AttributeField.new(name, type, options || {})
+      else
+        ::Sunspot::Field::VirtualField.new(name, type, options || {}, &block)
+      end
+    end
+  end
+end

data/lib/sunspot/indexer.rb

@@ -0,0 +1,65 @@
+module Sunspot
+  class Indexer
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def add(model)
+      hash = static_hash_for model
+      for field in fields
+        hash.merge! field.pair_for(model)
+      end
+      connection.add hash
+    end
+
+    def fields
+      @fields ||= []
+    end
+
+    def add_fields(fields)
+      self.fields.concat fields
+    end
+
+    def remove(model)
+      connection.delete(::Sunspot::Adapters.adapt_instance(model).index_id)
+    end
+
+    protected 
+    attr_reader :connection
+
+    def static_hash_for(model)
+      { :id => ::Sunspot::Adapters.adapt_instance(model).index_id,
+        :type => Indexer.superclasses_for(model.class).map { |clazz| clazz.name }}
+    end
+  end
+
+  class <<Indexer
+    def add(connection, model)
+      self.for(model.class, connection).add(model)
+    end
+
+    def remove(connection, model)
+      self.for(model.class, connection).remove(model)
+    end
+
+    def remove_all(connection, clazz = nil)
+      connection.delete_by_query("type:#{clazz ? clazz.name : '[* TO *]'}")
+    end
+
+    def for(clazz, connection)
+      indexer = self.new(connection)
+      for superclass in superclasses_for(clazz)
+        indexer.add_fields ::Sunspot::Field.for(superclass)
+        indexer.add_fields ::Sunspot::Field.text_for(superclass)
+      end
+      raise ArgumentError, "Class #{clazz.name} has not been configured for indexing" if indexer.fields.empty?
+      indexer
+    end
+
+    def superclasses_for(clazz)
+      superclasses_for = [clazz]
+      superclasses_for << (clazz = clazz.superclass) while clazz.superclass != Object
+      superclasses_for
+    end
+  end
+end

data/lib/sunspot/query.rb

@@ -0,0 +1,115 @@
+module Sunspot
+  class Query
+    attr_accessor :keywords, :conditions, :rows, :start, :sort
+
+    def initialize(types, params, configuration)
+      @keywords, @types, @configuration = params[:keywords], types, configuration
+      @conditions = Sunspot::Conditions.new(self, params[:conditions] || {})
+      paginate(params[:page], params[:per_page])
+      self.order = params[:order] if params[:order]
+      attributes[:keywords] = @keywords
+      params[:conditions].each_pair do |field_name, value|
+        attributes[:conditions][field_name.to_sym] = value
+      end if params[:conditions]
+    end
+
+    def to_solr
+      query_components = []
+      query_components << keywords if keywords
+      query_components << types_query if types_query
+      query_components.map { |component| "(#{component})"} * ' AND '
+    end
+
+    def filter_queries
+      scope_queries + condition_queries
+    end
+
+    def add_scope(condition)
+      scope << condition
+    end
+
+    def build_condition(field_name, condition_clazz, value)
+      condition_clazz.new(field(field_name), value)
+    end
+
+    def paginate(page = nil, per_page = nil)
+      page ||= 1
+      per_page ||= configuration.pagination.default_per_page
+      @start = (page - 1) * per_page
+      @rows = per_page
+      attributes[:page], attributes[:per_page] = page, per_page
+    end
+
+    def order=(order)
+      order_by(*order.split(' '))
+    end
+
+    def order_by(field_name, direction = nil)
+      direction ||= :asc
+      @sort = [{ field(field_name).indexed_name.to_sym => (direction.to_s == 'asc' ? :ascending : :descending) }] #TODO should support multiple order columns
+      attributes[:order] = "#{field_name} #{direction}"
+    end
+
+    def page
+      return nil unless start && rows
+      start / rows + 1
+    end
+
+    def attributes
+      @attributes ||= {
+        :order => nil,
+        :conditions => fields_hash.keys.inject({}) { |conditions, key| conditions[key.to_sym] = nil; conditions }
+      }
+    end
+
+    alias_method :per_page, :rows
+
+    protected
+    attr_accessor :types, :configuration
+
+    private
+
+    def scope
+      @scope ||= []
+    end
+
+    def scope_queries
+      scope.map { |condition| condition.to_solr_query }
+    end
+
+    def condition_queries
+      conditions.restrictions.map { |condition| condition.to_solr_query }
+    end
+
+    def types_query
+      if types.nil? || types.empty? then "type:[* TO *]"
+      elsif types.length == 1 then "type:#{types.first}"
+      else "type:(#{types * ' OR '})"
+      end
+    end
+
+    def field(field_name)
+      fields_hash[field_name.to_s] || raise(ArgumentError, "No field configured for #{types * ', '} with name '#{field_name}'")
+    end
+
+    def fields_hash
+      @fields_hash ||= begin
+        fields_hash = types.inject({}) do |hash, type|
+          ::Sunspot::Field.for(type).each do |field|
+            (hash[field.name.to_s] ||= {})[type.name] = field
+          end
+          hash
+        end
+        fields_hash.each_pair do |field_name, field_configurations_hash|
+          if types.any? { |type| field_configurations_hash[type.name].nil? } # at least one type doesn't have this field configured
+            fields_hash.delete(field_name)
+          elsif field_configurations_hash.values.map { |configuration| configuration.indexed_name }.uniq.length != 1 # fields with this name have different configs
+            fields_hash.delete(field_name)
+          else
+            fields_hash[field_name] = field_configurations_hash.values.first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query_builder.rb

@@ -0,0 +1,30 @@
+module Sunspot
+  class QueryBuilder
+    def initialize(query)
+      @query = query 
+    end
+
+    def keywords(keywords)
+      @query.keywords = keywords
+    end
+
+    def with
+      @conditions_builder ||= ::Sunspot::ScopeBuilder.new(@query)
+    end
+
+    def conditions
+      @query.conditions
+    end
+
+    def paginate(options = {})
+      page = options.delete(:page) || raise(ArgumentError, "paginate requires a :page argument")
+      per_page = options.delete(:per_page)
+      raise ArgumentError, "unknown argument #{options.keys.first.inspect} passed to paginate" unless options.empty?
+      @query.paginate(page, per_page)
+    end
+
+    def order_by(field_name, direction = nil)
+      @query.order_by(field_name, direction)
+    end
+  end
+end

data/lib/sunspot/restriction.rb

@@ -0,0 +1,72 @@
+module Sunspot
+  module Restriction
+    class Base
+      def initialize(field, value)
+        @field, @value = field, value
+      end
+
+      def to_solr_query
+        "#{field.indexed_name}:#{to_solr_conditional}"
+      end
+
+      protected
+      attr_accessor :field, :value
+
+      def solr_value(value = self.value)
+        escape field.to_indexed(value)
+      end
+
+      def escape(value)
+        Solr::Util.query_parser_escape value
+      end
+    end
+
+    class EqualTo < Base
+      private
+
+      def to_solr_conditional
+        "#{solr_value}"
+      end
+    end
+
+    class LessThan < Base
+      private
+
+      def to_solr_conditional
+        "[* TO #{solr_value}]"
+      end
+    end
+
+    class GreaterThan < Base
+      private
+
+      def to_solr_conditional
+        "[#{solr_value} TO *]"
+      end
+    end
+
+    class Between < Base
+      private
+
+      def to_solr_conditional
+        "[#{solr_value value.first} TO #{solr_value value.last}]"                  
+      end
+    end
+
+    class AnyOf < Base
+      private
+
+      def to_solr_conditional
+        "(#{value.map { |v| solr_value v } * ' OR '})"
+      end
+    end
+
+    class AllOf < Base
+      private
+
+      def to_solr_conditional
+        "(#{value.map { |v| solr_value v } * ' AND '})"
+      end
+    end
+  end
+end

data/lib/sunspot/scope_builder.rb

@@ -0,0 +1,33 @@
+module Sunspot
+  class ScopeBuilder
+    def initialize(query)
+      @query = query
+    end
+
+    def method_missing(field_name, *args)
+      if args.length == 0 then RestrictionBuilder.new(field_name, @query)
+      elsif args.length == 1 then @query.add_scope @query.build_condition(field_name, ::Sunspot::Restriction::EqualTo, args.first)
+      else super(field_name.to_sym, *args)
+      end
+    end
+
+    class RestrictionBuilder
+      def initialize(field_name, query)
+        @field_name, @query = field_name, query
+      end
+
+      def method_missing(condition_name, *args)
+        clazz = begin
+                  ::Sunspot::Restriction.const_get(condition_name.to_s.camel_case)
+                rescue(NameError)
+                  super(condition_name.to_sym, *args)
+                end
+        if value = args.first
+          @query.add_scope @query.build_condition(@field_name, clazz, args.first)
+        else
+          @query.interpret_condition @field_name, clazz
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/search.rb

@@ -0,0 +1,83 @@
+module Sunspot
+  class Search
+    def initialize(connection, configuration, *types, &block)
+      @connection = connection
+      params = types.last.is_a?(Hash) ? types.pop : {}
+      @query = Sunspot::Query.new(types, params, configuration)
+      QueryBuilder.new(@query).instance_eval(&block) if block
+      @types = types
+    end
+
+    def execute!
+      query_options = {}
+      query_options[:filter_queries] = query.filter_queries
+      query_options[:rows] = query.rows
+      query_options[:start] = query.start if query.start
+      query_options[:sort] = query.sort if query.sort
+      @solr_result = connection.query(query.to_solr, query_options)
+      self
+    end
+
+    def results
+      @results ||= if query.page && defined?(WillPaginate::Collection)
+        WillPaginate::Collection.create(query.page, query.per_page, @solr_result.total_hits) do |pager|
+          pager.replace(result_objects)
+        end
+      else
+        result_objects
+      end
+    end
+
+    def total
+      @total ||= @solr_result.total_hits
+    end
+
+    def attributes
+      @query.attributes
+    end
+
+    def order
+      @query.attributes[:order]
+    end
+
+    def page
+      @query.attributes[:page]
+    end
+
+    def per_page
+      @query.attributes[:per_page]
+    end
+
+    def keywords
+      @query.attributes[:keywords]
+    end
+
+    def conditions
+      ::Sunspot::Util::ClosedStruct.new(@query.attributes[:conditions])
+    end
+
+    protected
+    attr_reader :query, :types, :connection
+
+    private
+
+    def result_objects
+      hit_ids = @solr_result.hits.map { |hit| hit['id'] }
+      hit_ids.inject({}) do |type_id_hash, hit_id|
+        match = /([^ ]+) (.+)/.match hit_id
+        (type_id_hash[match[1]] ||= []) << match[2]
+        type_id_hash
+      end.inject([]) do |results, pair|
+        type_name, ids = pair
+        results.concat ::Sunspot::Adapters.adapt_class(type_with_name(type_name)).load_all(ids)
+      end.sort_by do |result|
+        hit_ids.index(::Sunspot::Adapters.adapt_instance(result).index_id)
+      end
+    end
+
+    def type_with_name(type_name)
+      @types_cache ||= {}
+      @types_cache[type_name] ||= type_name.split('::').inject(Module) { |namespace, name| namespace.const_get(name) }
+    end
+  end
+end

data/lib/sunspot/session.rb

@@ -0,0 +1,43 @@
+module Sunspot
+  class Session
+    attr_reader :config
+
+    def initialize(config = Sunspot::Configuration.build, connection = nil)
+      @config = config
+      yield(@config) if block_given?
+      @connection = connection
+    end
+
+    def search(*types, &block)
+      ::Sunspot::Search.new(connection, @config, *types, &block).execute!
+    end
+
+    def index(*objects)
+      for object in objects
+        ::Sunspot::Indexer.add(connection, object)
+      end
+    end
+
+    def remove(*objects)
+      for object in objects
+        ::Sunspot::Indexer.remove(connection, object)
+      end
+    end
+
+    def remove_all(*classes)
+      if classes.empty?
+        ::Sunspot::Indexer.remove_all(connection)
+      else
+        classes.each do |clazz|
+          ::Sunspot::Indexer.remove_all(connection, clazz)
+        end
+      end
+    end
+
+    private
+
+    def connection
+      @connection ||= Solr::Connection.new(config.solr.url, :autocommit => :on)
+    end
+  end
+end

data/lib/sunspot/type.rb

@@ -0,0 +1,62 @@
+module Sunspot
+  module Type
+    TextType = Module.new
+    StringType = Module.new
+    IntegerType = Module.new
+    FloatType = Module.new
+    TimeType = Module.new
+
+    class <<TextType
+      def indexed_name(name)
+        "#{name}_text"
+      end
+
+      def to_indexed(value)
+        value.to_s if value
+      end
+    end
+
+    class <<StringType
+      def indexed_name(name)
+        "#{name}_s"
+      end
+
+      def to_indexed(value)
+        value.to_s if value
+      end
+    end
+
+    class <<IntegerType
+      def indexed_name(name)
+        "#{name}_i"
+      end
+
+      def to_indexed(value)
+        value.to_i.to_s if value
+      end
+    end
+
+    class <<FloatType
+      def indexed_name(name)
+        "#{name}_f"
+      end
+
+      def to_indexed(value)
+        value.to_f.to_s if value
+      end
+    end
+
+    class <<TimeType
+      def indexed_name(name)
+        "#{name}_d"
+      end
+
+      def to_indexed(value)
+        if value
+          time = value.respond_to?(:to_time) ? value.to_time : Time.parse(value.to_s)
+          time.utc.strftime('%FT%TZ')
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/util.rb

@@ -0,0 +1,13 @@
+module Sunspot
+  module Util
+    class ClosedStruct
+      def initialize(data)
+        (class <<self; self; end).module_eval do
+          data.each_pair do |attr_name, value|
+            define_method(attr_name.to_s) { value }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/version.rb

@@ -0,0 +1,10 @@
+module Sunspot
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+    self
+  end
+end

data/lib/sunspot.rb

@@ -0,0 +1,50 @@
+require 'rubygems'
+gem 'solr-ruby'
+gem 'extlib'
+require 'solr'
+require 'extlib'
+require File.join(File.dirname(__FILE__), 'light_config')
+
+%w(adapters restriction conditions configuration field field_builder indexer query query_builder scope_builder search session type util).each do |filename|
+  require File.join(File.dirname(__FILE__), 'sunspot', filename)
+end
+
+module Sunspot
+  VERSION='0.0.1'
+end
+
+class <<Sunspot
+  def setup(clazz, &block)
+    ::Sunspot::FieldBuilder.new(clazz).instance_eval(&block) if block
+  end
+
+  def index(*objects)
+    session.index(*objects)
+  end
+
+  def search(*types, &block)
+    session.search(*types, &block)
+  end
+  
+  def remove(*objects)
+    session.remove(*objects)
+  end
+
+  def remove_all(*classes)
+    session.remove_all(*classes)
+  end
+
+  def config
+    session.config
+  end
+
+  def reset!
+    @session = nil
+  end
+
+  private
+
+  def session
+    @session ||= ::Sunspot::Session.new
+  end
+end