Performance fixes

Author: gkellogg

.fasterer.yml

@@ -0,0 +1,24 @@
+speedups:
+  parallel_assignment: false
+  rescue_vs_respond_to: true
+  module_eval: true
+  shuffle_first_vs_sample: true
+  for_loop_vs_each: true
+  each_with_index_vs_while: false
+  map_flatten_vs_flat_map: true
+  reverse_each_vs_reverse_each: true
+  select_first_vs_detect: true
+  sort_vs_sort_by: true
+  fetch_with_argument_vs_block: true
+  keys_each_vs_each_key: true
+  hash_merge_bang_vs_hash_brackets: true
+  block_vs_symbol_to_proc: true
+  proc_call_vs_yield: true
+  gsub_vs_tr: true
+  select_last_vs_reverse_detect: true
+  getter_vs_attr_reader: false
+  setter_vs_attr_writer: false
+
+exclude_paths:
+  - 'vendor/**/*.rb'
+  - 'spec/**/*.rb'

Gemfile

@@ -32,6 +32,7 @@ end
 group :test do
   gem "rake"
   gem "equivalent-xml"
+  gem 'fasterer'
 end
 
 platforms :rbx do

lib/rdf/format.rb

@@ -205,7 +205,7 @@ def self.reader_symbols
     #
     # @return [Array<String>]
     def self.reader_types
-      reader_symbols.map {|s| RDF::Format.for(s).content_type}.flatten.uniq
+      reader_symbols.flat_map {|s| RDF::Format.for(s).content_type}.uniq
     end
 
     ##
@@ -231,7 +231,7 @@ def self.writer_symbols
     #
     # @return [Array<String>]
     def self.writer_types
-      writer_symbols.map {|s| RDF::Format.for(s).content_type}.flatten.uniq
+      writer_symbols.flat_map {|s| RDF::Format.for(s).content_type}.uniq
     end
 
     ##

lib/rdf/mixin/enumerable.rb

@@ -218,10 +218,10 @@ def has_triple?(triple)
     #
     # @return [void]
     # @see    #enum_triple
-    def each_triple(&block)
+    def each_triple
       if block_given?
         each_statement do |statement|
-          block.call(*statement.to_triple)
+          yield *statement.to_triple
         end
       end
       enum_triple
@@ -281,10 +281,10 @@ def has_quad?(quad)
     #
     # @return [void]
     # @see    #enum_quad
-    def each_quad(&block)
+    def each_quad
       if block_given?
         each_statement do |statement|
-          block.call(*statement.to_quad)
+          yield *statement.to_quad
         end
       end
       enum_quad
@@ -346,14 +346,14 @@ def has_subject?(value)
     #
     # @return [void]
     # @see    #enum_subject
-    def each_subject(&block)
+    def each_subject
       if block_given?
         values = {}
         each_statement do |statement|
           value = statement.subject
           unless value.nil? || values.include?(value.to_s)
             values[value.to_s] = true
-            block.call(value)
+            yield value
           end
         end
       end
@@ -414,14 +414,14 @@ def has_predicate?(value)
     #
     # @return [void]
     # @see    #enum_predicate
-    def each_predicate(&block)
+    def each_predicate
       if block_given?
         values = {}
         each_statement do |statement|
           value = statement.predicate
           unless value.nil? || values.include?(value.to_s)
             values[value.to_s] = true
-            block.call(value)
+            yield value
           end
         end
       end
@@ -482,14 +482,14 @@ def has_object?(value)
     #
     # @return [void]
     # @see    #enum_object
-    def each_object(&block) # FIXME: deduplication
+    def each_object # FIXME: deduplication
       if block_given?
         values = {}
         each_statement do |statement|
           value = statement.object
           unless value.nil? || values.include?(value)
             values[value] = true
-            block.call(value)
+            yield value
           end
         end
       end
@@ -551,14 +551,14 @@ def has_context?(value)
     #
     # @return [void]
     # @see    #enum_context
-    def each_context(&block)
+    def each_context
       if block_given?
         values = {}
         each_statement do |statement|
           value = statement.context
           unless value.nil? || values.include?(value)
             values[value] = true
-            block.call(value)
+            yield value
           end
         end
       end
@@ -595,11 +595,11 @@ def enum_context
     # @return [void]
     # @see    #enum_graph
     # @since  0.1.9
-    def each_graph(&block)
+    def each_graph
       if block_given?
-        block.call(RDF::Graph.new(nil, :data => self))
+        yield RDF::Graph.new(nil, :data => self)
         each_context do |context|
-          block.call(RDF::Graph.new(context, :data => self))
+          yield RDF::Graph.new(context, :data => self)
         end
       end
       enum_graph

lib/rdf/model/graph.rb

@@ -312,8 +312,12 @@ def graphs
     # @private
     # @see    RDF::Enumerable#each_graph
     # @since  0.2.0
-    def each_graph(&block)
-      block_given? ? block.call(self) : enum_graph
+    def each_graph
+      if block_given?
+        yield self
+      else
+        enum_graph
+      end
     end
   end
 end

lib/rdf/model/list.rb

@@ -536,13 +536,13 @@ def slice_with_range(range)
     #
     # @return [RDF::Term]
     # @see    http://ruby-doc.org/core-1.9/classes/Array.html#M000420
-    def fetch(index, default = UNSET, &block)
+    def fetch(index, default = UNSET)
       each.with_index do |v, i|
         return v if i == index
       end
 
       case
-        when block_given?         then block.call(index)
+        when block_given?         then yield index
         when !default.eql?(UNSET) then default
         else raise IndexError, "index #{index} not in the list #{self.inspect}"
       end
@@ -753,16 +753,16 @@ def last_subject
     #
     # @return [Enumerator]
     # @see    RDF::Enumerable#each
-    def each_subject(&block)
+    def each_subject
       return enum_subject unless block_given?
 
       subject = self.subject
-      block.call(subject)
+      yield subject
 
       loop do
         rest = graph.first_object(:subject => subject, :predicate => RDF.rest)
         break if rest.nil? || rest.eql?(RDF.nil)
-        block.call(subject = rest)
+        yield subject = rest
       end
     end
 
@@ -776,12 +776,12 @@ def each_subject(&block)
     #
     # @return [Enumerator]
     # @see    http://ruby-doc.org/core-1.9/classes/Enumerable.html
-    def each(&block)
+    def each
       return to_enum unless block_given?
 
       each_subject do |subject|
         if value = graph.first_object(:subject => subject, :predicate => RDF.first)
-          block.call(value) # FIXME
+          yield value # FIXME
         end
       end
     end

lib/rdf/model/node.rb

@@ -142,8 +142,7 @@ def eql?(other)
     # @return [Boolean]
     # @see http://www.w3.org/TR/rdf-sparql-query/#func-RDFterm-equal
     def ==(other)
-      case other
-      when Literal
+      if other.is_a?(Literal)
         # If other is a Literal, reverse test to consolodate complex type checking logic
         other == self
       else

lib/rdf/model/statement.rb

@@ -79,17 +79,16 @@ def self.from(statement, options = {})
     #   @option options [RDF::Term]  :context   (nil)
     #   @return [RDF::Statement]
     def initialize(subject = nil, predicate = nil, object = nil, options = {})
-      case subject
-        when Hash
-          @options   = subject.dup
-          @subject   = @options.delete(:subject)
-          @predicate = @options.delete(:predicate)
-          @object    = @options.delete(:object)
-        else
-          @options   = !options.empty? ? options.dup : {}
-          @subject   = subject
-          @predicate = predicate
-          @object    = object
+      if subject.is_a?(Hash)
+        @options   = Hash[subject] # faster subject.dup
+        @subject   = @options.delete(:subject)
+        @predicate = @options.delete(:predicate)
+        @object    = @options.delete(:object)
+      else
+        @options   = !options.empty? ? Hash[options] : {}
+        @subject   = subject
+        @predicate = predicate
+        @object    = object
       end
       @id      = @options.delete(:id) if @options.has_key?(:id)
       @context = @options.delete(:context)
@@ -100,18 +99,24 @@ def initialize(subject = nil, predicate = nil, object = nil, options = {})
     # @private
     def initialize!
       @context   = Node.intern(@context)   if @context.is_a?(Symbol)
-      @subject   = case @subject
-        when nil      then nil
-        when Symbol   then Node.intern(@subject)
-        when Value    then @subject.to_term
-        else          raise ArgumentError, "expected subject to be nil or a term, was #{@subject.inspect}"
+      @subject   = if @subject.is_a?(Value)
+        @subject.to_term
+      elsif @subject.is_a?(Symbol)
+        Node.intern(@subject)
+      elsif @subject.nil?
+        nil
+      else
+        raise ArgumentError, "expected subject to be nil or a term, was #{@subject.inspect}"
       end
       @predicate = Node.intern(@predicate) if @predicate.is_a?(Symbol)
-      @object    = case @object
-        when nil    then nil
-        when Symbol then Node.intern(@object)
-        when Value  then @object.to_term
-        else Literal.new(@object)
+      @object    = if @object.is_a?(Value)
+        @object.to_term
+      elsif @object.is_a?(Symbol)
+        Node.intern(@object)
+      elsif @object.nil?
+        nil
+      else
+        Literal.new(@object)
       end
     end
 

lib/rdf/model/uri.rb

@@ -873,18 +873,18 @@ def parse(value)
         parts[:path] = (path.to_s.force_encoding(Encoding::UTF_8) unless path.empty?)
         parts[:query] = (query[1..-1].force_encoding(Encoding::UTF_8) if query)
         parts[:fragment] = (fragment[1..-1].force_encoding(Encoding::UTF_8) if fragment)
-
-        parts.each_key do |k|
-          parts[k].force_encoding(Encoding::UTF_8) if parts[k].respond_to?(:encoding)
-        end
       end
 
       parts
     end
 
     ##
     # @return [String]
-    def scheme; object.fetch(:scheme, nil); end
+    def scheme
+      object.fetch(:scheme) do
+        nil
+      end
+    end
 
     ##
     # @param [String, #to_s] value
@@ -1014,7 +1014,11 @@ def normalized_port
 
     ##
     # @return [String]
-    def path; object.fetch(:path, nil); end
+    def path
+      object.fetch(:path) do
+        nil
+      end
+    end
 
     ##
     # @param [String, #to_s] value
@@ -1071,7 +1075,11 @@ def normalized_path
 
     ##
     # @return [String]
-    def query; object.fetch(:query, nil); end
+    def query
+      object.fetch(:query) do
+        nil
+      end
+    end
 
     ##
     # @param [String, #to_s] value
@@ -1091,7 +1099,11 @@ def normalized_query
 
     ##
     # @return [String]
-    def fragment; object.fetch(:fragment, nil); end
+    def fragment
+      object.fetch(:fragment) do
+        nil
+      end
+    end
 
     ##
     # @param [String, #to_s] value

lib/rdf/query.rb

@@ -322,7 +322,7 @@ def execute(queryable, options = {}, &block)
 
         old_solutions, @solutions = @solutions, Query::Solutions()
 
-        options[:bindings].keys.each do |variable|
+        options[:bindings].each_key do |variable|
           if pattern.variables.include?(variable)
             unbound_solutions, old_solutions = old_solutions, Query::Solutions()
             options[:bindings][variable].each do |binding|