active-fedora 1.0.0

data/lib/active_fedora/property.rb

@@ -0,0 +1,15 @@
+module ActiveFedora
+  class Property
+    
+    attr_accessor :name, :instance_variable_name
+    
+    def initialize(model, name, type, options = {})
+      @name = name
+      @instance_variable_name = "@#{@name}"
+    end
+    
+    def field
+    end
+    
+  end
+end

data/lib/active_fedora/qualified_dublin_core_datastream.rb

@@ -0,0 +1,80 @@
+module ActiveFedora
+  #This class represents a Qualified Dublin Core Datastream. A special case of ActiveFedora::MetdataDatastream
+  #The implementation of this class defines the terms from the Qualified Dublin Core specification.
+  #This implementation features customized xml generators and deserialization routines to handle the 
+  #Fedora Dublin Core XML datastreams structure.
+  #
+  #Fields can still be overridden if more specificity is desired (see ActiveFedora::Datastream#fields method).
+  class QualifiedDublinCoreDatastream < MetadataDatastream
+    #A frozen array of Dublincore Terms.
+    DCTERMS = [
+      :contributor, :coverage, :creator,  :description, :format, :identifier, :language, :publisher, :relation,  :source, :title, :abstract, :accessRights, :accrualMethod, :accrualPeriodicity, :accrualPolicy, :alternative, :audience, :available, :bibliographicCitation, :conformsTo, :contributor, :coverage, :created, :creator, :date, :dateAccepted, :dateCopyrighted, :dateSubmitted, :description, :educationLevel, :extent, :format, :hasFormat, :hasPart, :hasVersion, :identifier, :instructionalMethod, :isFormatOf, :isPartOf, :isReferencedBy, :isReplacedBy, :isRequiredBy, :issued, :isVersionOf, :language, :license, :mediator, :medium, :modified, :provenance, :publisher, :references, :relation, :replaces, :requires, :rights, :rightsHolder, :source, :spatial, :subject, :tableOfContents, :temporal, :type, :valid
+    ]
+    DCTERMS.freeze
+    
+    #Constructor. this class will call self.field for each DCTERM. In short, all DCTERMS fields will already exist
+    #when this method returns. Each term is marked as a multivalue string.
+    def initialize(attrs=nil)
+      super
+      DCTERMS.each do |el|
+        field el, :string, :multiple=>true
+      end
+      self
+    end
+    
+    def set_blob_for_save # :nodoc:
+      self.blob = self.to_dc_xml
+    end
+    
+   def self.from_xml(tmpl, el) # :nodoc:
+     tmpl.fields.each do |z|
+       fname = z.first
+       fspec = z.last
+       node = "dcterms:#{fspec[:xml_node] ? fspec[:xml_node] : fname}"
+       attr_modifier= "[@xsi:type='#{fspec[:encoding]}']" if fspec[:encoding]
+       query = "./foxml:datastreamVersion[last()]/foxml:xmlContent/dc/#{node}#{attr_modifier}"
+       el.elements.each(query) do |f|
+          tmpl.send("#{fname}_append", f.text)
+        end
+
+     end
+     tmpl.instance_variable_set(:@dirty, false)
+     tmpl
+   end
+
+   #Render self as a Fedora DC xml document.
+   def to_dc_xml
+     #TODO: pull the modifiers up into MDDS
+     xml = REXML::Document.new("<dc xmlns:dcterms='http://purl.org/dc/terms/' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'/>")
+     fields.each do |field_name,field_info|
+       el = REXML::Element.new("dcterms:#{field_name.to_s}")
+       if field_info.class == Hash
+         field_info.each do |k, v|
+           case k
+           when :element_attrs
+            v.each{|k,v| el.add_attribute(k.to_s, v.to_s)}
+           when :values, :type
+             # do nothing to the :values array
+           when :xml_node
+             el.name = "dcterms:#{v}"
+           when :encoding, :encoding_scheme
+             el.add_attribute("xsi:type", v)
+           when :multiple
+             next
+           else
+             el.add_attribute(k.to_s, v)
+           end
+         end
+         field_info = field_info[:values]
+       end
+       field_info.each do |val|
+         el = el.clone
+         el.text = val.to_s
+         xml.root.elements.add(el)
+       end
+     end
+     return xml.to_s
+   end
+
+  end
+end

data/lib/active_fedora/relationship.rb

@@ -0,0 +1,43 @@
+module ActiveFedora
+  
+  class Relationship 
+    
+    attr_accessor :subject, :predicate, :object, :is_literal, :data_type
+    def initialize(attr={})
+      attr.merge!({:is_literal => false})
+      self.subject = attr[:subject]
+      @predicate = attr[:predicate]
+      self.object = attr[:object]
+      @is_literal = attr[:is_literal]
+      @data_type = attr[:data_type]
+    end
+    
+    def subject=(subject)
+      @subject = generate_uri(subject)
+    end
+    
+    def subject_pid=(pid)
+      @subject = "info:fedora/#{pid}"
+    end
+    
+    def object=(object)
+      @object = generate_uri(object)
+    end
+    
+    def object_pid=(pid)
+      @object = "info:fedora/#{pid}"
+    end
+    
+    def generate_uri(input)
+      if input.class == Symbol || input == nil
+        return input
+      elsif input.respond_to?(:pid)
+        return "info:fedora/#{input.pid}"
+      else
+        input.include?("info:fedora") ? input : "info:fedora/#{input}"
+      end
+    end
+  
+  end
+  
+end

data/lib/active_fedora/rels_ext_datastream.rb

@@ -0,0 +1,42 @@
+
+module ActiveFedora
+  class RelsExtDatastream < Datastream
+    
+    include ActiveFedora::SemanticNode
+    
+    def initialize(attrs=nil)
+      super
+      self.dsid = "RELS-EXT"
+    end
+    
+    def save
+      if @dirty == true
+        self.content = to_rels_ext(self.pid)
+      end
+      super
+    end
+      
+    def pid=(pid)
+      super
+      self.blob = <<-EOL
+      <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+        <rdf:Description rdf:about="info:fedora/#{pid}">
+        </rdf:Description>
+      </rdf:RDF>
+      EOL
+    end
+    
+    def to_solr(solr_doc = Solr::Document.new)
+      self.relationships.each_pair do |subject, predicates|
+        if subject == :self || subject == "info:fedora/#{self.pid}"
+          predicates.each_pair do |predicate, values|
+            values.each do |val|
+              solr_doc << Solr::Field.new("#{predicate}_field" => val)
+            end
+          end
+        end
+      end
+      return solr_doc
+    end
+  end
+end

data/lib/active_fedora/semantic_node.rb

@@ -0,0 +1,224 @@
+module ActiveFedora
+  module SemanticNode 
+    include MediaShelfClassLevelInheritableAttributes
+    ms_inheritable_attributes  :class_relationships, :internal_uri
+    
+    attr_accessor :internal_uri, :relationships
+    
+    PREDICATE_MAPPINGS = Hash[:is_member_of => "isMemberOf",
+                          :is_part_of => "isPartOf",
+                          :has_part => "hasPart",
+                          :conforms_to => "conformsTo"]
+    PREDICATE_MAPPINGS.freeze
+    
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+    def assert_kind_of(n, o,t)
+      raise "Assertion failure: #{n}: #{o} is not of type #{t}" unless o.kind_of?(t)
+    end
+    
+    def add_relationship(relationship)
+      # Only accept ActiveFedora::Relationships as input arguments
+      assert_kind_of 'relationship',  relationship, ActiveFedora::Relationship
+      register_triple(relationship.subject, relationship.predicate, relationship.object)
+    end
+    
+    def register_triple(subject, predicate, object)
+      register_subject(subject)
+      register_predicate(subject, predicate)
+      relationships[subject][predicate] << object
+    end
+    
+    def register_subject(subject)
+      if !relationships.has_key?(subject) 
+          relationships[subject] = {} 
+      end
+    end
+  
+    def register_predicate(subject, predicate)
+      register_subject(subject)
+      if !relationships[subject].has_key?(predicate) 
+        relationships[subject][predicate] = []
+      end
+    end
+    
+    def outbound_relationships()
+      if !internal_uri.nil? && !relationships[internal_uri].nil?
+        return relationships[:self].merge(relationships[internal_uri]) 
+      else
+        return relationships[:self]
+      end
+    end
+    
+    def relationships
+      @relationships ||= relationships_from_class
+    end
+    
+    def relationships_from_class
+      rels = {}
+      self.class.relationships.each_pair do |subj, pred|
+        rels[subj] = {}
+        pred.each_key do |pred_key|
+          rels[subj][pred_key] = []
+        end
+      end
+      #puts "rels from class: #{rels.inspect}"
+      return rels
+    end
+    
+    # Creates a RELS-EXT datastream for insertion into a Fedora Object
+    # @pid
+    # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
+    def to_rels_ext(pid, relationships=self.relationships)
+      starter_xml = <<-EOL
+      <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+        <rdf:Description rdf:about="info:fedora/#{pid}">
+        </rdf:Description>
+      </rdf:RDF>
+      EOL
+      xml = REXML::Document.new(starter_xml)
+    
+      # Iterate through the hash of predicates, adding an element to the RELS-EXT for each "object" in the predicate's corresponding array.
+      # puts ""
+      # puts "Iterating through a(n) #{self.class}"
+      # puts "=> whose relationships are #{self.relationships.inspect}"
+      # puts "=> and whose outbound relationships are #{self.outbound_relationships.inspect}"
+      self.outbound_relationships.each do |predicate, targets_array|
+        targets_array.each do |target|
+          # puts ". #{predicate} #{target}"
+          xml.root.elements["rdf:Description"].add_element(self.class.predicate_lookup(predicate), {"xmlns" => "info:fedora/fedora-system:def/relations-external#", "rdf:resource"=>target})
+        end
+      end
+      xml.to_s
+    end
+    
+    module ClassMethods
+      
+    # Anticipates usage of a relationship in classes that include this module
+    # Creates a key in the @relationships array for the predicate provided.  Assumes
+    # :self as the subject of the relationship unless :inbound => true, in which case the 
+    # predicate is registered under @relationships[:inbound][#{predicate}]
+    #
+    # TODO:
+    # Custom Methods:
+    # A custom finder method will be appended based on the relationship name.
+    # ie. 
+    # class Foo
+    #   relationship "container", :is_member_of  
+    # end
+    # foo = Foo.new
+    # foo.parts
+    #
+    # Special Predicate Short Hand:
+    # These symbols map to the uris of corresponding Fedora RDF predicates
+    # :is_member_of, :has_member, :is_part_of, :has_part  
+      def has_relationship(name, predicate, opts = {})
+        opts = {:singular => nil, :inbound => false}.merge(opts)
+        opts[:inbound] == true ? register_predicate(:inbound, predicate) : register_predicate(:self, predicate) 
+      
+        if opts[:inbound] == true
+          create_inbound_relationship_finders(name, predicate, opts)
+        else        
+          create_outbound_relationship_finders(name, predicate, opts)
+        end
+      
+      end
+    
+      def create_inbound_relationship_finders(name, predicate, opts = {})
+        class_eval <<-END
+        def #{name}
+          escaped_uri = self.internal_uri.gsub(/(:)/, '\\:')
+          hits = SolrService.instance.conn.query("#{predicate}_field:\#{escaped_uri}").hits
+          results = []
+          hits.each do |hit|
+            classname = Kernel.const_get(hit["active_fedora_model_field"].first)
+            results << Fedora::Repository.instance.find_model(hit["id"], classname)
+          end
+          return results
+        end
+        def #{name}_ids
+          escaped_uri = self.internal_uri.gsub(/(:)/, '\\:')
+          SolrService.instance.conn.query("#{predicate}_field:\#{escaped_uri}")
+        end 
+        END
+      end
+    
+      def create_outbound_relationship_finders(name, predicate, opts = {})
+        class_eval <<-END
+        def #{name}
+          results = []
+          outbound_relationships[#{predicate.inspect}].each do |rel|
+            uri_as_pid = rel.gsub("info:fedora/", "")
+            results << Fedora::Repository.instance.find_model(uri_as_pid, ActiveFedora::Base)
+          end
+          return results
+        end
+        def #{name}_ids
+          results = []
+          outbound_relationships[#{predicate.inspect}].each do |rel|
+            results << rel
+          end
+        end 
+        END
+      end
+    
+      # relationships are tracked as a hash of structure {subject => {predicate => [object]}}
+      def relationships
+        @class_relationships ||= Hash[:self => {}]
+      end
+    
+    
+      def register_subject(subject)
+        if !relationships.has_key?(subject) 
+            relationships[subject] = {} 
+        end
+      end
+    
+      def register_predicate(subject, predicate)
+        register_subject(subject)
+        if !relationships[subject].has_key?(predicate) 
+          relationships[subject][predicate] = []
+        end
+      end
+    
+      #alias_method :register_target, :register_object
+    
+      # Creates a RELS-EXT datastream for insertion into a Fedora Object
+      # @pid
+      # Note: This method is implemented on SemanticNode instead of RelsExtDatastream because SemanticNode contains the relationships array
+      def relationships_to_rels_ext(pid, relationships=self.relationships)
+        starter_xml = <<-EOL
+        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+          <rdf:Description rdf:about="info:fedora/#{pid}">
+          </rdf:Description>
+        </rdf:RDF>
+        EOL
+        xml = REXML::Document.new(starter_xml)
+      
+        # Iterate through the hash of predicates, adding an element to the RELS-EXT for each "object" in the predicate's corresponding array.
+        self.outbound_relationships.each do |predicate, targets_array|
+          targets_array.each do |target|
+            #puts ". #{predicate} #{target}"
+            xml.root.elements["rdf:Description"].add_element(predicate_lookup(predicate), {"xmlns" => "info:fedora/fedora-system:def/relations-external#", "rdf:resource"=>target})
+          end
+        end
+        xml.to_s
+      end
+    
+      # If predicate is a symbol, looks up the predicate in the PREDICATE_MAPPINGS
+      # If predicate is not a Symbol, returns the predicate untouched
+      # @throws UnregisteredPredicateError if the predicate is a symbol but is not found in the PREDICATE_MAPPINGS
+      def predicate_lookup(predicate)
+        if predicate.class == Symbol 
+          if PREDICATE_MAPPINGS.has_key?(predicate)
+            return PREDICATE_MAPPINGS[predicate]
+          else
+            throw UnregisteredPredicateError
+          end
+        end
+        return predicate
+      end
+    end
+  end
+end

data/lib/active_fedora/solr_service.rb

@@ -0,0 +1,20 @@
+require 'solr'
+module ActiveFedora 
+  class SolrService
+    attr_reader :conn
+    def self.register(host=nil, args={})
+      Thread.current[:solr_service]=self.new(host, args)
+
+    end
+    def initialize(host, args)
+      host = 'http://localhost:8080/solr' unless host
+      opts = {:autocommit=>:on}.merge(args)
+      @conn = Solr::Connection.new(host, opts)
+    end
+    def self.instance
+      raise SolrNotInitialized unless Thread.current[:solr_service]
+      Thread.current[:solr_service]
+    end
+  end
+  class SolrNotInitialized < StandardError;end
+end

data/solr/config/schema.xml

@@ -0,0 +1,229 @@
+<?xml version="1.0" ?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<!-- This is the Solr schema file. This file should be named "schema.xml" and
+ should be in the conf directory under the solr home
+ (i.e. ./solr/conf/schema.xml by default) 
+ or located where the classloader for the Solr webapp can find it.
+
+ For more information, on how to customize this file, please see
+ http://wiki.apache.org/solr/SchemaXml
+-->
+
+<schema name="active_fedora" version="0.1">
+  <!-- attribute "name" is the name of this schema and is only used for display purposes.
+       Applications should change this to reflect the nature of the search collection.
+       version="1.1" is Solr's version number for the schema syntax and semantics.  It should
+       not normally be changed by applications.
+       1.0: multiValued attribute did not exist, all fields are multiValued by nature
+       1.1: multiValued attribute introduced, false by default -->
+
+  <types>
+    <!-- field type definitions. The "name" attribute is
+       just a label to be used by field definitions.  The "class"
+       attribute and any other attributes determine the real
+       behavior of the fieldtype.
+         Class names starting with "solr" refer to java classes in the
+       org.apache.solr.analysis package.
+    -->
+
+    <!-- The StrField type is not analyzed, but indexed/stored verbatim.  
+       - StrField and TextField support an optional compressThreshold which
+       limits compression (if enabled in the derived fields) to values which
+       exceed a certain size (in characters).
+    -->
+    <fieldtype name="string" class="solr.StrField" sortMissingLast="true" omitNorms="true"/>
+
+    <!-- boolean type: "true" or "false" -->
+    <fieldtype name="boolean" class="solr.BoolField" sortMissingLast="true" omitNorms="true"/>
+
+    <!-- The optional sortMissingLast and sortMissingFirst attributes are
+         currently supported on types that are sorted internally as strings.
+       - If sortMissingLast="true", then a sort on this field will cause documents
+         without the field to come after documents with the field,
+         regardless of the requested sort order (asc or desc).
+       - If sortMissingFirst="true", then a sort on this field will cause documents
+         without the field to come before documents with the field,
+         regardless of the requested sort order.
+       - If sortMissingLast="false" and sortMissingFirst="false" (the default),
+         then default lucene sorting will be used which places docs without the
+         field first in an ascending sort and last in a descending sort.
+    -->    
+
+
+    <!-- numeric field types that store and index the text
+         value verbatim (and hence don't support range queries, since the
+         lexicographic ordering isn't equal to the numeric ordering) -->
+    <fieldtype name="integer" class="solr.IntField" omitNorms="true"/>
+    <fieldtype name="long" class="solr.LongField" omitNorms="true"/>
+    <fieldtype name="float" class="solr.FloatField" omitNorms="true"/>
+    <fieldtype name="double" class="solr.DoubleField" omitNorms="true"/>
+
+
+    <!-- Numeric field types that manipulate the value into
+         a string value that isn't human-readable in its internal form,
+         but with a lexicographic ordering the same as the numeric ordering,
+         so that range queries work correctly. -->
+    <fieldtype name="sint" class="solr.SortableIntField" sortMissingLast="true" omitNorms="true"/>
+    <fieldtype name="slong" class="solr.SortableLongField" sortMissingLast="true" omitNorms="true"/>
+    <fieldtype name="sfloat" class="solr.SortableFloatField" sortMissingLast="true" omitNorms="true"/>
+    <fieldtype name="sdouble" class="solr.SortableDoubleField" sortMissingLast="true" omitNorms="true"/>
+
+
+    <!-- The format for this date field is of the form 1995-12-31T23:59:59Z, and
+         is a more restricted form of the canonical representation of dateTime
+         http://www.w3.org/TR/xmlschema-2/#dateTime    
+         The trailing "Z" designates UTC time and is mandatory.
+         Optional fractional seconds are allowed: 1995-12-31T23:59:59.999Z
+         All other components are mandatory.
+
+         Expressions can also be used to denote calculations that should be
+         performed relative to "NOW" to determine the value, ie...
+
+               NOW/HOUR
+                  ... Round to the start of the current hour
+               NOW-1DAY
+                  ... Exactly 1 day prior to now
+               NOW/DAY+6MONTHS+3DAYS
+                  ... 6 months and 3 days in the future from the start of
+                      the current day
+                      
+         Consult the DateField javadocs for more information.
+      -->
+    <fieldtype name="date" class="solr.DateField" sortMissingLast="true" omitNorms="true"/>
+
+    <!-- solr.TextField allows the specification of custom text analyzers
+         specified as a tokenizer and a list of token filters. Different
+         analyzers may be specified for indexing and querying.
+
+         The optional positionIncrementGap puts space between multiple fields of
+         this type on the same document, with the purpose of preventing false phrase
+         matching across fields.
+
+         For more info on customizing your analyzer chain, please see
+         http://wiki.apache.org/solr/AnalyzersTokenizersTokenFilters
+     -->
+
+    <!-- One can also specify an existing Analyzer class that has a
+         default constructor via the class attribute on the analyzer element
+    <fieldtype name="text_greek" class="solr.TextField">
+      <analyzer class="org.apache.lucene.analysis.el.GreekAnalyzer"/>
+    </fieldType>
+    -->
+
+    <!-- A text field that only splits on whitespace for exact matching of words -->
+    <fieldtype name="text_ws" class="solr.TextField" positionIncrementGap="100">
+      <analyzer>
+        <tokenizer class="solr.WhitespaceTokenizerFactory"/>
+      </analyzer>
+    </fieldtype>
+
+    <fieldtype name="text" class="solr.TextField" positionIncrementGap="100">
+      <analyzer>
+        <tokenizer class="solr.StandardTokenizerFactory"/>
+        <filter class="solr.StandardFilterFactory"/>
+        <filter class="solr.LowerCaseFilterFactory"/>
+      </analyzer>
+    </fieldtype>
+
+    <fieldtype name="text_zh" class="solr.TextField">
+      <analyzer class="org.apache.lucene.analysis.cn.ChineseAnalyzer"/>
+    </fieldtype>
+
+
+    <!-- Less flexible matching, but less false matches.  Probably not ideal for product names,
+         but may be good for SKUs.  Can insert dashes in the wrong place and still match. -->
+    <fieldtype name="textTight" class="solr.TextField" positionIncrementGap="100" >
+      <analyzer>
+        <tokenizer class="solr.WhitespaceTokenizerFactory"/>
+        <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="false"/>
+        <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt"/>
+        <filter class="solr.WordDelimiterFilterFactory" generateWordParts="0" generateNumberParts="0" catenateWords="1" catenateNumbers="1" catenateAll="0"/>
+        <filter class="solr.LowerCaseFilterFactory"/>
+        <filter class="solr.EnglishPorterFilterFactory" protected="protwords.txt"/>
+        <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
+      </analyzer>
+    </fieldtype>
+
+ </types>
+
+
+ <fields>
+   <!-- Valid attributes for fields:
+     name: mandatory - the name for the field
+     type: mandatory - the name of a previously defined type from the <types> section
+     indexed: true if this field should be indexed (searchable or sortable)
+     stored: true if this field should be retrievable
+     compressed: [false] if this field should be stored using gzip compression
+       (this will only apply if the field type is compressable; among
+       the standard field types, only TextField and StrField are)
+     multiValued: true if this field may contain multiple values per document
+     omitNorms: (expert) set to true to omit the norms associated with
+       this field (this disables length normalization and index-time
+       boosting for the field, and saves some memory).  Only full-text
+       fields or fields that need an index-time boost need norms.
+   -->
+
+   <field name="id" type="string" indexed="true" stored="true"/>
+
+   <!-- catchall field, containing all other searchable text fields (implemented
+        via copyField further on in this schema  -->
+   <field name="text" type="text" indexed="true" stored="false" multiValued="true"/>
+   <!-- catchall field, containing all other searchable text fields (implemented
+        via copyField further on in this schema  -->
+   <field name="date" type="date" indexed="true" stored="false" multiValued="true"/>
+
+   <!-- Dynamic field definitions.  If a field name is not found, dynamicFields
+        will be used if the name matches any of the patterns.
+        RESTRICTION: the glob-like pattern in the name attribute must have
+        a "*" only at the start or the end.
+        EXAMPLE:  name="*_i" will match any field ending in _i (like myid_i, z_i)
+        Longer patterns will be matched first.  if equal size patterns
+        both match, the first appearing in the schema will be used.  -->
+	<dynamicField name="*_date"  type="date"  indexed="true"  stored="true" multiValued="true"/>
+	<dynamicField name="*_name"  type="date"  indexed="true"  stored="true" multiValued="true"/>
+   <dynamicField name="*_field"  type="text"  indexed="true"  stored="true" multiValued="true"/>
+
+   <dynamicField name="*_facet"  type="string"  indexed="true"  stored="true" multiValued="true"/>
+   <dynamicField name="*_zh_text"   type="text_zh"    indexed="true"  stored="true" multiValued="true"/>
+   <dynamicField name="*_text"   type="text"    indexed="true"  stored="true" multiValued="true"/>
+   <dynamicField name="*_display"   type="text"    indexed="false"  stored="true" multiValued="true"/>   
+ </fields>
+
+ <!-- field to use to determine and enforce document uniqueness. -->
+ <uniqueKey>id</uniqueKey>
+
+ <!-- field for the QueryParser to use when an explicit fieldname is absent -->
+ <defaultSearchField>text</defaultSearchField>
+
+ <!-- SolrQueryParser configuration: defaultOperator="AND|OR" -->
+ <solrQueryParser defaultOperator="AND"/>
+
+  <!-- copyField commands copy one field to another at the time a document
+        is added to the index.  It's used either to index the same field differently,
+        or to add multiple fields to the same field for easier/faster searching.  -->
+ <copyField source="*_date" dest="date"/>
+ <copyField source="*_text" dest="text"/>
+ <copyField source="*_facet" dest="text"/>
+
+ <!-- Similarity is the scoring routine for each document vs. a query.
+      A custom similarity may be specified here, but the default is fine
+      for most applications.  -->
+ <!-- <similarity class="org.apache.lucene.search.DefaultSimilarity"/> -->
+
+</schema>