solrizer 2.2.0 → 3.0.0.pre1

data/.gitignore

@@ -5,7 +5,7 @@ Gemfile.lock
 *.sqlite3
 *.log
 *~
-*.swp
+*.sw[pon]
 
 pkg/
 coverage/*

data/History.txt

@@ -1,3 +1,15 @@
+h2. 3.0.0
+suffix changes:  
+  _s -> _si
+  _t -> _tesim
+  _dt -> _dtsi
+  _i  -> _isim
+  _sort -> _ssi
+  _display -> _sim
+  _facet   -> _sim
+  _unstem_search -> _tim
+
+
 h2. 2.1.0
 #11 There should only be one instance of the field mapper. It's now at Solrizer.default_field_mapper
 Extract create_and_insert_terms into Solrizer::Common.  This can be used for RDF datastreams

data/lib/solrizer/common.rb

@@ -1,21 +1,6 @@
 # The goal of this method is to have no dependency on OM, so that NOM or RDF datastreams could use this.
 
 module Solrizer
-  # Instructions on how to solrize the field (types and uses)
-  class Directive
-    attr_accessor :type, :index_as
-    def initialize(*args)
-      case args
-      when Hash
-        self.type = args[:type]
-        self.index_as = args[:index_as]
-      when Array
-        self.type = args[0]
-        self.index_as = args[1]
-      end
-    end
-  end
-
   module Common
     def self.included(klass)
       klass.send(:extend, ClassMethods)
@@ -24,10 +9,10 @@ module Solrizer
     module ClassMethods
       # @param [String] field_name_base the name of the solr field (without the type suffix)
       # @param [Object] value the value to insert into the document
-      # @param [Directive] directive instructions on which fields to create
+      # @param [Array] index_as list of indexers to use (e.g. [:searchable, :facetable])
       # @param [Hash] solr_doc the solr_doc to insert into.
-      def create_and_insert_terms(field_name_base, value, directive, solr_doc)
-        Solrizer.default_field_mapper.solr_names_and_values(field_name_base, value, directive.type, directive.index_as).each do |field_name, field_value|
+      def create_and_insert_terms(field_name_base, value, index_as, solr_doc)
+        Solrizer.default_field_mapper.solr_names_and_values(field_name_base, value, index_as).each do |field_name, field_value|
           unless field_value.join("").strip.empty?
             ::Solrizer::Extractor.insert_solr_field_value(solr_doc, field_name, field_value)
           end

data/lib/solrizer/default_descriptors.rb

@@ -0,0 +1,93 @@
+module Solrizer
+  module DefaultDescriptors
+
+    # Produces a _sim suffix
+    def self.facetable
+      @facetable ||= Descriptor.new(:string, :indexed, :multivalued)
+    end
+
+    # Most interesting case because the suffixe produced depends on the type parameter 
+    # produces suffixes:
+    #  _tesim - for strings or text fields
+    #  _dtsim - for dates
+    #  _isim - for integers
+    def self.searchable
+      @searchable ||= Descriptor.new(searchable_field_definition, converter: searchable_converter, requires_type: true)
+    end
+    
+    # Takes fields which are stored as strings, but we want indexed as dates.  (e.g. "November 6th, 2012")
+    # produces suffixes:
+    #  _dtsi - for dates
+    def self.dateable
+      @dateable ||= Descriptor.new(:date, :stored, :indexed, converter: dateable_converter)
+    end
+
+    # Produces a _ssim suffix
+    def self.symbol
+      @symbol ||= Descriptor.new(:string, :stored, :indexed, :multivalued)
+    end
+
+    # Produces a _ssi suffix
+    def self.sortable
+      @sortable ||= Descriptor.new(:string, :indexed, :stored)
+    end
+
+    # Produces a _ssm suffix
+    def self.displayable
+      @displayable ||= Descriptor.new(:string, :stored, :multivalued)
+    end
+
+    # Produces a _tim suffix (used to be _unstem)
+    def self.unstemmed_searchable
+      @unstemmed_searchable ||= Descriptor.new(:text, :indexed, :multivalued)
+    end
+
+    def self.simple
+      @simple ||= Descriptor.new(lambda {|field_type| [field_type, :indexed]})
+    end
+    protected
+
+    def self.searchable_field_definition
+      lambda do |type|
+        type = :text_en if [:string, :text].include?(type) # for backwards compatibility with old solr schema
+        vals = [type, :indexed, :stored]
+        vals << :multivalued unless type == :date
+        vals
+      end
+    end
+
+    def self.searchable_converter
+      lambda do |type|
+        case type
+        when :date
+          lambda { |val| iso8601_date(val)}
+        end
+      end
+    end
+
+    def self.dateable_converter
+      lambda do |type|
+        lambda do |val| 
+          begin
+            iso8601_date(Date.parse(val))
+          rescue ArgumentError
+            nil 
+          end
+        end
+      end
+    end
+    
+
+    def self.iso8601_date(value)
+      begin 
+        if value.is_a?(Date) 
+          DateTime.parse(value.to_s).to_time.utc.iso8601 
+        elsif !value.empty?
+          DateTime.parse(value).to_time.utc.iso8601
+        end
+      rescue ArgumentError => e
+        raise ArgumentError, "Unable to parse `#{value}' as a date-time object"
+      end
+    end
+  end
+end

data/lib/solrizer/descriptor.rb

@@ -0,0 +1,68 @@
+module Solrizer
+  class Descriptor
+    attr_reader :index_type
+    def initialize(*args)
+      if args.last.kind_of? Hash
+        opts = args.pop
+        @converter = opts[:converter] 
+        @type_required = opts[:requires_type] 
+      end
+      @index_type = args
+      raise Solrizer::InvalidIndexDescriptor, "Invalid index type passed to Sorizer.solr_name.  It should be an array like [:string, :indexed, :stored, :multivalued]. You provided: `#{@index_type}'" unless index_type.kind_of? Array
+    end
+
+    def name_and_converter(field_name, args=nil)
+      args ||= {}
+      field_type = args[:type]
+      if type_required?
+        raise "Must provide a :type argument when index_type is `#{self}' for #{field_name}" unless field_type
+      end
+      [field_name.to_s + suffix(field_type), converter(field_type)]
+    end
+
+    def type_required?
+      @type_required
+    end
+
+    protected
+    def suffix(field_type)
+      evaluated_type = index_type.first.kind_of?(Proc) ? index_type.first.call(field_type) : index_type.dup
+      stored_suffix = config[:stored_suffix] if evaluated_type.delete(:stored)
+      index_suffix = config[:index_suffix] if evaluated_type.delete(:indexed)
+      multivalued_suffix = config[:multivalued_suffix] if evaluated_type.delete(:multivalued)
+      index_datatype = evaluated_type.first
+      raise Solrizer::InvalidIndexDescriptor, "Missing datatype for #{evaluated_type}" unless index_datatype
+      type_suffix = config[:type_suffix].call(index_datatype)
+      raise Solrizer::InvalidIndexDescriptor, "Invalid datatype `#{index_datatype.inspect}'. Must be one of: :date, :text, :text_en, :string, :integer" unless type_suffix
+
+      suffix = [config[:suffix_delimiter], type_suffix, stored_suffix, index_suffix, multivalued_suffix].join
+    end
+
+    def converter(field_type)
+      @converter.call(field_type) if @converter
+    end
+
+    private
+    def config
+      @config ||= 
+      {suffix_delimiter: '_',
+      type_suffix: lambda do |type|  
+        case type
+        when :string, :symbol # TODO `:symbol' useage ought to be deprecated
+          's'
+        when :text
+          't'
+        when :text_en
+          'te'
+        when :date
+          'dt'
+        when :integer
+          'i'
+        end
+      end,
+      stored_suffix: 's', 
+      index_suffix: 'i',
+      multivalued_suffix: 'm'}
+    end
+  end
+end