Adds RDF::Vocabulary.limit_vocabs which is used to limit the vocabularies returned by RDF::Vocabulary.each and can substantially reduce load time when the rdf-vocabs gem is used.

For #411.

Author: gkellogg

lib/rdf/vocabulary.rb

@@ -70,11 +70,15 @@ class << self
       # @return [Enumerator]
       def each(&block)
         if self.equal?(Vocabulary)
-          # This is needed since all vocabulary classes are defined using
-          # Ruby's autoloading facility, meaning that `@@subclasses` will be
-          # empty until each subclass has been touched or require'd.
-          RDF::VOCABS.each { |v, p| RDF.const_get(p[:class_name].to_sym) unless v == :rdf }
-          @@subclasses.select(&:name).each(&block)
+          if @vocabs
+            @vocabs.select(&:name).each(&block)
+          else
+            # This is needed since all vocabulary classes are defined using
+            # Ruby's autoloading facility, meaning that `@@subclasses` will be
+            # empty until each subclass has been touched or require'd.
+            RDF::VOCABS.each { |v, p| RDF.const_get(p[:class_name].to_sym) unless v == :rdf }
+            @@subclasses.select(&:name).each(&block)
+          end
         else
           __properties__.each(&block)
         end
@@ -96,6 +100,38 @@ def from_sym(sym)
         RDF.const_get(sym.to_sym)
       end
 
+      ##
+      # Limits iteration over vocabularies to just those selected
+      #
+      # @example limit to set of vocabularies by symbol
+      #     RDF::Vocabulary.limit_vocabs(:rdf, :rdfs
+      #     RDF::Vocabulary.find_term('http://www.w3.org/2000/01/rdf-schema#Resource').pname
+      #     # => 'rdfs:Resource'
+      #
+      # @example limit to set of vocabularies by class name
+      #     RDF::Vocabulary.limit_vocabs(RDF::RDFV, RDF::RDFS)
+      #     RDF::Vocabulary.find_term('http://www.w3.org/2000/01/rdf-schema#Resource').pname
+      #     # => 'rdfs:Resource'
+      #
+      # @param [Array<symbol, RDF::Vocabulary>] vocabs
+      #   A list of vocabularies (symbols or classes) which may
+      #   be returned by {Vocabulary.each}. Also limits
+      #   vocabularies that will be inspeced for other methods.
+      #   Set to nil, or an empty array to reset.
+      # @return [Array<RDF::Vocabulary>]
+      def limit_vocabs(*vocabs)
+        @vocabs = if Array(vocabs).empty?
+          nil
+        else
+          vocabs.map do |vocab|
+            vocab = :rdfv if vocab == :rdf
+            vocab.is_a?(Symbol) && RDF::VOCABS.key?(vocab) ?
+              RDF.const_get(RDF::VOCABS[vocab][:class_name].to_sym) :
+              vocab
+          end.compact
+        end
+      end
+
       ##
       # Is this a strict vocabulary, or a liberal vocabulary allowing arbitrary properties?
       def strict?; false; end
@@ -610,7 +646,6 @@ def inherited(subclass) # @private
         unless @@uri.nil?
           @@subclasses << subclass unless %w(http://www.w3.org/1999/02/22-rdf-syntax-ns#).include?(@@uri)
           subclass.send(:private_class_method, :new)
-          #vocab_map[subclass.__prefix__] ||= {uri: @@uri, class_name: subclass.__name__.split('::').last.downcase}
           @@uris[subclass] = @@uri
           @@uri = nil
         end

spec/vocabulary_spec.rb

@@ -55,6 +55,66 @@
       expect {|b| RDF::RDFS.each(&b)}.to yield_control.at_least(5).times
       expect(RDF::RDFS.each.to_a).to include(RDF::RDFS.range, RDF::RDFS.subClassOf, RDF::RDFS.domain)
     end
+
+    context "with limited vocabularies" do
+      before { RDF::Vocabulary.limit_vocabs(:rdfs)}
+      after { RDF::Vocabulary.limit_vocabs()}
+
+      it "inumerates limited vocabularies" do
+        expect {|b| RDF::Vocabulary.each(&b)}.to yield_control.exactly(1).times
+        expect(RDF::Vocabulary.each.to_a).to include(RDF::RDFS)
+      end
+    end
+  end
+
+  describe ".vocab_map" do
+    it "returns map of vocabularies" do
+      expect(RDF::Vocabulary.vocab_map).to have_key(:rdfv)
+      expect(RDF::Vocabulary.vocab_map).to have_key(:rdfs)
+      expect(RDF::Vocabulary.vocab_map).to have_key(:owl)
+    end
+  end
+
+  describe ".from_sym" do
+    %w(RDFS OWL XSD).each do |sym|
+      it "returns voabulary for #{sym}" do
+        expect(RDF::Vocabulary.from_sym(sym)).to respond_to(:find_term)
+      end
+    end
+  end
+
+  describe ".limit_vocabs" do
+    before { RDF::Vocabulary.limit_vocabs(:rdf, :rdfs)}
+    after { RDF::Vocabulary.limit_vocabs()}
+
+    terms = {
+      'http://www.w3.org/2000/01/rdf-schema#Resource' => RDF::RDFS,
+      'http://www.w3.org/2002/07/owl#Ontology' => nil,
+      'http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement' => RDF::RDFV
+    }
+    describe ".find_term" do
+      terms.each do |term, cls|
+        it "#{cls ? 'finds' : 'does not find'} #{term}" do
+          if cls
+            expect(RDF::Vocabulary.find_term(term)).to be_a(RDF::Vocabulary::Term)
+          else
+            expect(RDF::Vocabulary.find_term(term)).to be_nil
+          end
+        end
+      end
+    end
+
+    describe ".find" do
+      terms.each do |term, cls|
+        it "#{cls ? 'finds' : 'does not find'} #{term}" do
+          if cls
+            expect(RDF::Vocabulary.find(term)).to eql cls
+          else
+            expect(RDF::Vocabulary.find_term(term)).to be_nil
+          end
+        end
+      end
+    end
   end
 
   describe "#to_enum" do