solrizer 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34eabc78510ac3e701056114b5d5086dcc65257e
-  data.tar.gz: 88162b2315c00c3cdbba86761f3255c74a7ae0a4
+  metadata.gz: 1bfcd13e75eee3622c67f1cfac1222e73eb545b5
+  data.tar.gz: 844f374fc4c03f895c99a415439449344b722291
 SHA512:
-  metadata.gz: 9c7d84ee9270e01bcec4a5c6112fa01c907897414a98e78d4de0eb7fba1ce78e41900319230d4ddcd3fb6877f1a99cd9f9ecfaf02ad81deca8286496788aa3e7
-  data.tar.gz: a04661c08372898a9a1890b95c3911dbad938e4f7d33c3b1b353f86d299437c3f1949da6e874465d4fce87fd554f7cf86d016ec8f2039e81a97195fbcfb2e453
+  metadata.gz: 909cc4d4eb25b94b595c1eebbbb87921e892bc15f0fe6cb5c2b2b9ffe8865f99f85a478b5cfeb210011076ae5f31a8c75442cd2f35e5f41bd39dfb87a174ad18
+  data.tar.gz: f74ed09971903812dc3ae0e1ba8aaf258596226f3f258e3a4d739a6005fdcad90b3bc906bfa1202537c4808cabfcc0995f130921e8b9e7d0253ac906f10092a4

data/History.txt

@@ -1,3 +1,8 @@
+h2. 3.1.0
+  #16 Inserting non-multivalued fields should not create a solr error
+  #20 Time fields should be formatted correctly when using active_support/core_ext/date_time/conversions
+  #17 Solrizer should accept DateTime objects
+
 h2. 3.0.0 (2013-03-28)
 suffix changes:  
   _s -> _sim

data/lib/solrizer.rb

@@ -7,6 +7,7 @@ module Solrizer
   autoload :Descriptor
   autoload :FieldMapper
   autoload :DefaultDescriptors
+  autoload :Suffix
   autoload :HTML, 'solrizer/html'
   autoload :VERSION, 'solrizer/version'
   autoload :XML, 'solrizer/xml'
@@ -38,7 +39,11 @@ module Solrizer
     indexer_args = [:stored_searchable] if indexer_args.empty?
     default_field_mapper.solr_names_and_values(name, value, indexer_args).each do |k, v|
       doc[k] ||= []
-      doc[k] += v
+      if v.is_a? Array
+        doc[k] += v
+      else
+        doc[k] = v
+      end
     end
     doc
   end

data/lib/solrizer/common.rb

@@ -12,10 +12,8 @@ module Solrizer
       # @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, 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
+        index_as.each do |indexer|
+          Solrizer.insert_field(solr_doc, field_name_base, value, indexer)
         end
       end
     end

data/lib/solrizer/default_descriptors.rb

@@ -29,7 +29,8 @@ module Solrizer
       @facetable ||= Descriptor.new(:string, :indexed, :multivalued)
     end
 
-    # Produces _ssim suffix;  should probably be deprecated
+    # Produces _ssim suffix
+    # This is useful for when you only want to match whole words, such as user/group names from the the rightsMetadata datastream
     def self.symbol
       @symbol ||= Descriptor.new(:string, :stored, :indexed, :multivalued)
     end
@@ -113,9 +114,9 @@ module Solrizer
     def self.iso8601_date(value)
       begin 
         if value.is_a?(Date) || value.is_a?(Time)
-          DateTime.parse(value.to_s).to_time.utc.iso8601 
+          DateTime.parse(value.to_s).to_time.utc.strftime('%Y-%m-%dT%H:%M:%SZ') 
         elsif !value.empty?
-          DateTime.parse(value).to_time.utc.iso8601
+          DateTime.parse(value).to_time.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
         end
       rescue ArgumentError => e
         raise ArgumentError, "Unable to parse `#{value}' as a date-time object"

data/lib/solrizer/descriptor.rb

@@ -15,7 +15,7 @@ module Solrizer
       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
+        raise ArgumentError, "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
@@ -24,45 +24,20 @@ module Solrizer
       @type_required
     end
 
+    def evaluate_suffix(field_type)
+      Suffix.new(index_type.first.kind_of?(Proc) ? index_type.first.call(field_type) : index_type.dup)
+    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, :time, :text, :text_en, :string, :integer" unless type_suffix
 
-      suffix = [config[:suffix_delimiter], type_suffix, stored_suffix, index_suffix, multivalued_suffix].join
+
+    # Suffix can be overridden if you want a different method of grabbing the suffix
+    def suffix(field_type)
+      evaluate_suffix(field_type).to_s
     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' usage ought to be deprecated
-          's'
-        when :text
-          't'
-        when :text_en
-          'te'
-        when :date, :time
-          'dt'
-        when :integer
-          'i'
-        end
-      end,
-      stored_suffix: 's', 
-      index_suffix: 'i',
-      multivalued_suffix: 'm'}
-    end
   end
 end

data/lib/solrizer/extractor.rb

@@ -18,8 +18,11 @@ class Extractor
   # @param [String] field_value
   def self.insert_solr_field_value(solr_doc, field_name, field_value)
     formatted_value = self.format_node_value(field_value)
-    solr_doc[field_name] ||= []
-    solr_doc[field_name] << formatted_value
+    if solr_doc[field_name]
+      solr_doc[field_name] = Array(solr_doc[field_name]) << formatted_value
+    else
+      solr_doc[field_name] = formatted_value
+    end
     return solr_doc
   end
   

data/lib/solrizer/field_mapper.rb

@@ -168,6 +168,8 @@ module Solrizer
       when NilClass
       when Fixnum
         :integer
+      when DateTime
+        :time
       else
         value.class.to_s.underscore.to_sym
       end
@@ -199,8 +201,9 @@ module Solrizer
       index_types.each do |index_type|
         Array(field_value).each do |single_value|
           # Get mapping for field
-          name, converter = indexer(index_type).name_and_converter(field_name, type: extract_type(single_value))
-          #name, converter = solr_name_and_converter(field_name, index_type, field_type)
+          descriptor = indexer(index_type)
+          data_type = extract_type(single_value)
+          name, converter = descriptor.name_and_converter(field_name, type: data_type)
           next unless name
           
           # Is there a custom converter?
@@ -217,8 +220,13 @@ module Solrizer
           end
           
           # Add mapped name & value, unless it's a duplicate
-          values = (results[name] ||= [])
-          values << value unless value.nil? || values.include?(value)
+          if descriptor.evaluate_suffix(data_type).multivalued?
+            values = (results[name] ||= [])
+            values << value unless value.nil? || values.include?(value)
+          else
+            logger.warn "Setting #{name} to `#{value}', but it already had `#{results[name]}'" if results[name]
+            results[name] = value
+          end
         end
       end
         

data/lib/solrizer/suffix.rb

@@ -0,0 +1,59 @@
+module Solrizer
+  class Suffix
+
+    def initialize(fields)
+      @fields = fields
+    end
+
+    def multivalued?
+      @fields.include? :multivalued
+    end
+
+    def stored?
+      @fields.include? :stored
+    end
+
+    def indexed?
+      @fields.include? :indexed
+    end
+
+    def data_type
+      @fields.first
+    end
+
+    def to_s
+      stored_suffix = config[:stored_suffix] if stored?
+      index_suffix = config[:index_suffix] if indexed?
+      multivalued_suffix = config[:multivalued_suffix] if multivalued?
+      raise Solrizer::InvalidIndexDescriptor, "Missing datatype for #{@fields}" unless data_type
+      type_suffix = config[:type_suffix].call(data_type)
+      raise Solrizer::InvalidIndexDescriptor, "Invalid datatype `#{data_type.inspect}'. Must be one of: :date, :time, :text, :text_en, :string, :integer" unless type_suffix
+
+      [config[:suffix_delimiter], type_suffix, stored_suffix, index_suffix, multivalued_suffix].join
+    end
+
+
+    private
+    def config
+      @config ||= 
+      {suffix_delimiter: '_',
+      type_suffix: lambda do |type|  
+        case type
+        when :string, :symbol # TODO `:symbol' usage ought to be deprecated
+          's'
+        when :text
+          't'
+        when :text_en
+          'te'
+        when :date, :time
+          'dt'
+        when :integer
+          'i'
+        end
+      end,
+      stored_suffix: 's', 
+      index_suffix: 'i',
+      multivalued_suffix: 'm'}
+    end
+  end
+end

data/lib/solrizer/version.rb

@@ -1,3 +1,3 @@
 module Solrizer
-  VERSION = "3.0.0"
+  VERSION = "3.1.0"
 end

data/spec/units/common_spec.rb

@@ -13,7 +13,7 @@ describe Solrizer::Common do
   it "should handle many field types" do
     solr_doc = {}
     Foo.create_and_insert_terms('my_name', 'value', [:displayable, :searchable, :sortable], solr_doc)
-    solr_doc.should == {'my_name_ssm' => ['value'], 'my_name_si' => ['value'], 'my_name_teim' => ['value']}
+    solr_doc.should == {'my_name_ssm' => ['value'], 'my_name_si' => 'value', 'my_name_teim' => ['value']}
   end
 
   it "should handle dates that are searchable" do
@@ -25,7 +25,7 @@ describe Solrizer::Common do
   it "should handle dates that are stored_sortable" do
     solr_doc = {}
     Foo.create_and_insert_terms('my_name', Date.parse('2013-01-10'), [:stored_sortable], solr_doc)
-    solr_doc.should == {'my_name_dtsi' => ['2013-01-10T00:00:00Z']}
+    solr_doc.should == {'my_name_dtsi' => '2013-01-10T00:00:00Z'}
   end
 
   it "should handle dates that are displayable" do
@@ -37,6 +37,6 @@ describe Solrizer::Common do
   it "should handle dates that are sortable" do
     solr_doc = {}
     Foo.create_and_insert_terms('my_name', Date.parse('2013-01-10'), [:sortable], solr_doc)
-    solr_doc.should == {'my_name_dti' => ['2013-01-10T00:00:00Z']}
+    solr_doc.should == {'my_name_dti' => '2013-01-10T00:00:00Z'}
   end
 end

data/spec/units/extractor_spec.rb

@@ -24,8 +24,21 @@ describe Solrizer::Extractor do
     it "should initialize a solr doc list if it is nil" do
        solr_doc = {'title_tesim' => nil }
        Solrizer::Extractor.insert_solr_field_value(solr_doc, 'title_tesim', 'Frank')
-       solr_doc.should == {"title_tesim"=>["Frank"]}
+       solr_doc.should == {"title_tesim"=>"Frank"}
     end
+    it "should insert multiple" do
+       solr_doc = {'title_tesim' => nil }
+       Solrizer::Extractor.insert_solr_field_value(solr_doc, 'title_tesim', 'Frank')
+       Solrizer::Extractor.insert_solr_field_value(solr_doc, 'title_tesim', 'Margret')
+       Solrizer::Extractor.insert_solr_field_value(solr_doc, 'title_tesim', 'Joyce')
+       solr_doc.should == {"title_tesim"=>["Frank", 'Margret', 'Joyce']}
+    end
+    it "should not make a list if a single valued field is passed in" do
+       solr_doc = {}
+       Solrizer::Extractor.insert_solr_field_value(solr_doc, 'title_dtsi', '2013-03-22T12:33:00Z')
+       solr_doc.should == {"title_dtsi"=>"2013-03-22T12:33:00Z"}
+    end
+
   end
   
 end

data/spec/units/field_mapper_spec.rb

@@ -37,18 +37,27 @@ describe Solrizer::FieldMapper do
         def name_and_converter(field_name, args)
           [field_name + '_s', lambda { |value| "#{value} o'clock" }]
         end
+        def index_type
+          [:multivalued]
+        end
       end
 
       class StoredSearchableDescriptor < Solrizer::Descriptor
         def name_and_converter(field_name, args)
           [field_name.to_s + '_s']
         end
+        def index_type
+          [:multivalued]
+        end
       end
 
       class EdibleDescriptor < Solrizer::Descriptor
         def name_and_converter(field_name, args)
           [field_name + '_food']
         end
+        def index_type
+          [:multivalued]
+        end
       end
 
       class FungibleDescriptor < Solrizer::Descriptor
@@ -94,6 +103,9 @@ describe Solrizer::FieldMapper do
             end
           end
         end
+        def index_type
+          [:multivalued]
+        end
       end
     end
 
@@ -146,6 +158,7 @@ describe Solrizer::FieldMapper do
       @mapper.extract_type(nil).should == nil
       @mapper.extract_type(Date.today).should == :date
       @mapper.extract_type(Time.now).should == :time
+      @mapper.extract_type(DateTime.now).should == :time
       @mapper.extract_type("Hi").should == :string
     end
   end
@@ -269,16 +282,16 @@ describe Solrizer::FieldMapper do
         "foo_tesim" => ["bar"], #stored_searchable
         "foo_ssm" => ["bar"], #displayable
         "foo_sim" => ["bar"], #facetable
-        "foo_si" => ["bar"], #sortable
-        "foo_ssi" => ["bar"], #stored_sortable
+        "foo_si" => "bar", #sortable
+        "foo_ssi" => "bar", #stored_sortable
         "foo_tim" => ["bar"] #unstemmed_searchable
       }
     end
 
     it "should support stored_sortable" do
       time = Time.iso8601("2012-11-06T15:16:17Z")
-      @mapper.solr_names_and_values('foo', time, :stored_sortable).should == {"foo_dtsi" => ["2012-11-06T15:16:17Z"]} 
-      @mapper.solr_names_and_values('foo', 'bar', :stored_sortable).should == {"foo_ssi" => ["bar"]} 
+      @mapper.solr_names_and_values('foo', time, :stored_sortable).should == {"foo_dtsi" => "2012-11-06T15:16:17Z"} 
+      @mapper.solr_names_and_values('foo', 'bar', :stored_sortable).should == {"foo_ssi" => "bar"} 
     end
   end
 end

data/spec/units/solrizer_spec.rb

@@ -9,9 +9,13 @@ describe Solrizer do
         Solrizer.insert_field(doc, 'foo', 'A name')
         doc.should == {'foo_tesim' => ['A name']}
       end
+      it "should not create an array of fields that are not multivalued" do
+        Solrizer.insert_field(doc, 'foo', 'A name', :sortable)
+        doc.should == {'foo_si' => 'A name'}
+      end
       it "should insert a field with multiple indexers" do
         Solrizer.insert_field(doc, 'foo', 'A name', :sortable, :facetable)
-        doc.should == {'foo_si' => ['A name'], 'foo_sim' => ['A name']}
+        doc.should == {'foo_si' => 'A name', 'foo_sim' => ['A name']}
       end
       it "should insert Dates" do
         Solrizer.insert_field(doc, 'foo', Date.parse('2013-01-13'))
@@ -24,17 +28,16 @@ describe Solrizer do
 
       it "should insert multiple values" do
         Solrizer.insert_field(doc, 'foo', ['A name', 'B name'], :sortable, :facetable)
-        # NOTE:  is this desired behavior for non-multivalued fields, like :sortable ?
-        doc.should == {'foo_si' => ['A name', 'B name'], 'foo_sim' => ['A name', 'B name']}
+        doc.should == {'foo_si' => 'B name', 'foo_sim' => ['A name', 'B name']}
       end
     end
 
     describe "on a document with values" do
-      before{ @doc = {'foo_si' => ['A name'], 'foo_sim' => ['A name']}}
+      before{ @doc = {'foo_si' => 'A name', 'foo_sim' => ['A name']}}
 
-      it "should not overwrite values that exist before" do
+      it "should not overwrite muli-values that exist before" do
         Solrizer.insert_field(@doc, 'foo', 'B name', :sortable, :facetable)
-        @doc.should == {'foo_si' => ['A name', 'B name'], 'foo_sim' => ['A name', 'B name']}
+        @doc.should == {'foo_si' => 'B name', 'foo_sim' => ['A name', 'B name']}
       end
     end
   end
@@ -44,7 +47,7 @@ describe Solrizer do
 
       it "should overwrite values that exist before" do
         Solrizer.set_field(@doc, 'foo', 'B name', :sortable, :facetable)
-        @doc.should == {'foo_si' => ['B name'], 'foo_sim' => ['B name']}
+        @doc.should == {'foo_si' => 'B name', 'foo_sim' => ['B name']}
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solrizer
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Matt Zumwalt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-28 00:00:00.000000000 Z
+date: 2013-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -177,6 +177,7 @@ files:
 - lib/solrizer/field_mapper.rb
 - lib/solrizer/html.rb
 - lib/solrizer/html/extractor.rb
+- lib/solrizer/suffix.rb
 - lib/solrizer/version.rb
 - lib/solrizer/xml.rb
 - lib/solrizer/xml/extractor.rb
@@ -209,7 +210,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: A utility for building solr indexes, usually from Fedora repository content