evoc 3.5.0

data/lib/evoc/analyze.rb

@@ -0,0 +1,395 @@
+module Evoc
+  class Analyze
+
+    attr_accessor :opts, :tx_store
+
+    def initialize(opts)
+      self.opts = opts
+      Logging.set_level(self.opts[:logger_level])
+      if opts[:tx_store].nil?
+      self.tx_store = TxStore.new(path: opts[:transactions],case_id: self.opts[:case_id], granularity: self.opts[:granularity])
+      else
+        self.tx_store = opts[:tx_store]
+      end
+    end
+
+    ##
+    # Perform all of the numerical analyzes
+    #
+    # Prints to stdout
+    def all
+      methods = %W(num_commits percent_method_changes_of_all_changes avg_changes_per_file avg_method_changes_per_parsable_file num_unique_changes average_changes_per_commit average_commits_per_specific_change time_span_in_years average_time_between_commits_in_minutes)
+
+      CSV {|row| row << methods}
+      results = []
+      methods.each do |m|
+        results << self.method(m).call
+      end
+      CSV {|row| row << results}
+    end
+
+    def avg_method_changes_per_parsable_file
+      parsable_files_changed = 0
+      method_changes = 0
+      self.tx_store.each do |tx|
+        named_items = tx.items.map {|i| self.tx_store.int_2_name[i]}
+        # group changed items by file name
+        named_items.group_by {|i| /^(?<file>[^:]+?)(?::|$)/.match(i)[:file]}.each do |file,changes|
+          # check if any method changes were found for this file
+          if changes.any? {|c| c =~ /:(?!@residuals)/}
+            parsable_files_changed += 1
+            # count number of method changes per file group
+            changes.each do |change|
+              if change =~ /:(?!@residuals)/
+                method_changes += 1
+              end
+            end
+          end
+        end
+      end
+      return (method_changes.to_f/parsable_files_changed).round(2)
+    end
+
+    def avg_changes_per_file
+      files_changed = 0
+      total_changes = 0
+      self.tx_store.each do |tx|
+        named_items = tx.items.map {|i| self.tx_store.int_2_name[i]}
+        named_items.group_by {|i| /^(?<file>[^:]+?)(?::|$)/.match(i)[:file]}.each do |file,changes|
+          files_changed += 1
+          total_changes += changes.size
+        end
+      end
+      return (total_changes.to_f/files_changed).round(2)
+    end
+
+    ##
+    # @return [Float] the percentage of changes that are method level
+    def percent_method_changes_of_all_changes
+      total_changes = 0
+      file_changes = 0
+      self.tx_store.each do |tx|
+        tx.items.each do |item|
+          total_changes += 1
+          if self.tx_store.int_2_name[item] =~ /^[^:]+?(\.[^:\/]+?)?(?::@residuals$|$)/
+            file_changes += 1
+          end
+        end
+      end
+      return ((1 - file_changes.to_f/total_changes)*100).round(2)
+    end
+
+    def num_commits
+      self.tx_store.size
+    end
+
+    def average_commits_per_specific_change
+      (self.tx_store.items.values.inject(0) {|sum,txes| sum + txes.size}.to_f/self.tx_store.items.size).round(2)
+    end
+
+    ##
+    # Prints a CSV formated table of the top N frequent files
+    # N is configured in opts[:top]
+    def file_frequency
+      # print header
+      CSV {|row| row << %W(file frequency)}
+      frequency = self.tx_store.items.map {|item,txes| [item, txes.size] }
+      frequency.sort_by! {|item,freq| -freq}
+      frequency.take(self.opts[:top]).each do |file,freq|
+        filename = self.tx_store.int_2_name[file]
+        CSV {|row| row << [filename,freq]}
+      end
+    end
+
+    ##
+    # Dumps the commit sizes, one commit per line
+    def commit_size
+      if self.opts[:group]
+        $stdout.puts 'commit_size,frequency'
+        self.tx_store.group_by(&:size).sort.each do |size,txes|
+          STDOUT.puts "#{size},#{txes.size}"
+        end
+      else
+        $stdout.puts 'commit_size'
+        self.tx_store.each_with_index do |tx,index|
+          $stderr.print "Dumping commit sizes: #{index+1} of #{self.tx_store.size}               \r"
+          $stdout.puts tx.size
+        end
+      end
+      $stderr.puts "DONE                                                 "
+    end
+
+    def num_unique_changes
+      self.tx_store.map(&:items).flatten.uniq.size
+    end
+
+    def average_changes_per_commit
+      arr = self.tx_store.map(&:size)
+      (arr.inject{ |sum, el| sum + el }.to_f / arr.size).round(2)
+    end
+
+    # added but not used as the data is not interesting --LM
+    def median_changes_per_commit
+      arr = self.tx_store.map(&:size)
+      sorted = arr.sort
+      len = sorted.length
+      (sorted[(len - 1) / 2] + sorted[len / 2]) / 2.0
+    end
+
+    def time_span_in_years
+      time_span(unit: 'years')
+    end
+
+    def average_time_between_commits_in_minutes
+      average_time_between_commits(unit: 'minutes').round(2)
+    end
+
+
+    def uniqueness
+      result = Hash.new
+
+      self.tx_store.each do |tx|
+        query_size = tx.size-1
+        queries = tx.items.combination(query_size).to_a
+        previous_history = self.tx_store.clone_with_subset(0,tx.index)
+
+        queries.each do |query|
+          hits = previous_history.transactions_of_list(query,true).size
+          if result[hits].nil?
+            result[hits] = 1
+          else
+            result[hits] += 1
+          end
+        end
+
+      end
+
+      result
+    end
+
+    def measure_values
+      # generate some random rules with min sup 1
+      samplable = self.tx_store.select {|tx| tx.size > 1}
+      measures = (Evoc::Rule.p_measures + Evoc::Rule.measures).sort
+      CSV {|r| r << measures} # print header
+      self.opts[:number].times do |i|
+        random_tx = samplable.sample
+        lhs = random_tx.items.sample(rand(1..random_tx.size-1))
+        rhs = (random_tx.items-lhs).sample
+        r = Evoc::Rule.new(lhs: lhs, rhs: rhs, tx_store: self.tx_store)
+        row = CSV::Row.new([],[],false)
+        measures.each do |m|
+          measure = r.get_measure(m)
+          if value = measure.is_a?(Evoc::InterestingnessMeasure) ? measure.value : measure
+            row << value.to_f
+          else
+            row << nil
+          end
+        end
+        CSV {|r| r << row} # print row
+      end
+    end
+
+    def measure_ranges
+      #rules = []
+      #ab_range = ([0.00000001]+(0.0..1).step(0.01).to_a+[0.99999999]).map(&:rationalize)
+      #ab_range.each do |ab|
+      #  ab_zero = ((ab == 0) ? 0.0000001 : 0)
+      #  a_range = (ab+ab_zero..1).step(0.01).map(&:rationalize)
+      #  b_range = (ab+ab_zero..1).step(0.01).map(&:rationalize)
+      #  # construct all rules starting from A
+      #  a_range.each do |a|
+      #    new_b_range = (ab..1-a+ab).step(0.01).map(&:rationalize)
+      #    new_b_range.each do |b|
+      #      if (a == 0) | (b == 0)
+      #        # a or b cant be 0
+      #        next
+      #      else
+      #        r = Evoc::Rule.new(lhs: [], rhs: [])
+      #        r.set_p('p_A',a)
+      #        r.set_p('p_B',b)
+      #        r.set_p('p_AB',ab)
+      #        rules << r
+      #      end
+      #    end
+      #  end
+      #  # construct all rules starting from B
+      #  b_range.each do |b|
+      #    new_a_range = (ab..1-b+ab).step(0.01).map(&:rationalize)
+      #    new_a_range.each do |a|
+      #      r = Evoc::Rule.new(lhs: [], rhs: [])
+      #      r.set_p('p_A',a)
+      #      r.set_p('p_B',b)
+      #      r.set_p('p_AB',ab)
+      #      rules << r
+      #    end
+      #  end
+      #end
+      ## A and B never change together, but do change
+      r1 = Evoc::Rule.new(lhs: [], rhs: [])
+      r1.set_p('p_A',1.to_r/4)
+      r1.set_p('p_B',1.to_r/4)
+      r1.set_p('p_AB',0)
+      # A and B never change together, and A almost never change
+      r2 = Evoc::Rule.new(lhs: [], rhs: [])
+      r2.set_p('p_A',1.to_r/1000000)
+      r2.set_p('p_B',1.to_r/2)
+      r2.set_p('p_AB',0)
+      # A and B never change together, and B almost never change
+      r3 = Evoc::Rule.new(lhs: [], rhs: [])
+      r3.set_p('p_A',1.to_r/2)
+      r3.set_p('p_B',1.to_r/1000000)
+      r3.set_p('p_AB',0)
+      # A and B never change together, but change half of the time
+      r4 = Evoc::Rule.new(lhs: [], rhs: [])
+      r4.set_p('p_A',1.to_r/2)
+      r4.set_p('p_B',1.to_r/2)
+      r4.set_p('p_AB',0)
+      
+      # A and B never change together, and A and B almost never change
+      r5 = Evoc::Rule.new(lhs: [], rhs: [])
+      r5.set_p('p_A',1.to_r/1000000)
+      r5.set_p('p_B',1.to_r/1000000)
+      r5.set_p('p_AB',0)
+
+      # A and B always change together
+      r6 = Evoc::Rule.new(lhs: [], rhs: [])
+      r6.set_p('p_A',1.to_r/3)
+      r6.set_p('p_B',1.to_r/3)
+      r6.set_p('p_AB',1.to_r/3)
+      # A and B always change together, but rarely change
+      r7 = Evoc::Rule.new(lhs: [], rhs: [])
+      r7.set_p('p_A',1.to_r/1000000)
+      r7.set_p('p_B',1.to_r/1000000)
+      r7.set_p('p_AB',1.to_r/1000000)
+      # A and B always change together, always
+      r8 = Evoc::Rule.new(lhs: [], rhs: [])
+      r8.set_p('p_A',1)
+      r8.set_p('p_B',1)
+      r8.set_p('p_AB',1)
+      
+      # B always change when A change, but rarely change
+      r9 = Evoc::Rule.new(lhs: [], rhs: [])
+      r9.set_p('p_A',1)
+      r9.set_p('p_B',1.to_r/10000000)
+      r9.set_p('p_AB',1.to_r/10000000)
+      
+      # A always change when B change, but rarely change
+      r10 = Evoc::Rule.new(lhs: [], rhs: [])
+      r10.set_p('p_A',1.to_r/10000000)
+      r10.set_p('p_B',1)
+      r10.set_p('p_AB',1.to_r/10000000)
+
+      # A and B sometimes change together, B always 
+      r11 = Evoc::Rule.new(lhs: [], rhs: [])
+      r11.set_p('p_A',1.to_r/2)
+      r11.set_p('p_B',1)
+      r11.set_p('p_AB',1.to_r/2)
+      
+      # A and B sometimes change together, A always 
+      r12 = Evoc::Rule.new(lhs: [], rhs: [])
+      r12.set_p('p_A',1)
+      r12.set_p('p_B',1.to_r/2)
+      r12.set_p('p_AB',1.to_r/2)
+      
+      # A and B always change together, almost always 
+      r13 = Evoc::Rule.new(lhs: [], rhs: [])
+      r13.set_p('p_A',0.99999999.rationalize)
+      r13.set_p('p_B',0.99999999.rationalize)
+      r13.set_p('p_AB',0.99999999.rationalize)
+      
+      # A and B always change together, half of the time 
+      r14 = Evoc::Rule.new(lhs: [], rhs: [])
+      r14.set_p('p_A',0.5.rationalize)
+      r14.set_p('p_B',0.5.rationalize)
+      r14.set_p('p_AB',0.5.rationalize)
+      
+      # A and B sometimes change together, A always 
+      r15 = Evoc::Rule.new(lhs: [], rhs: [])
+      r15.set_p('p_A',0.4.rationalize)
+      r15.set_p('p_B',0.4.rationalize)
+      r15.set_p('p_AB',0.1.rationalize)
+      
+      # A and B sometimes change together, A always 
+      r16 = Evoc::Rule.new(lhs: [], rhs: [])
+      r16.set_p('p_A',1.to_r/3)
+      r16.set_p('p_B',1.to_r/2)
+      r16.set_p('p_AB',1.to_r/4)
+
+      rules = [r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16]
+
+      measures = (Evoc::Rule.p_measures + Evoc::Rule.measures).sort
+      CSV {|r| r << [nil,nil,nil,nil,'min_configuration',nil,nil,'max_configuration',nil,nil]}
+      CSV {|r| r << ['measure','current_range','min','max','P(A)','P(B)','P(A,B)','P(A)','P(B)','P(A,B)']} # print header
+      measures.each do |m|
+        values = Hash.new
+        rules.each do |r|
+          measure = r.get_measure(m)
+          if value = (measure.is_a?(Evoc::InterestingnessMeasure) ? measure.value : measure)
+            if value != Float::NAN
+              a = r.p_A
+              b = r.p_B
+              ab = r.p_AB
+              key = "#{a},#{b},#{ab}"
+              values[key] = Hash.new
+              values[key][:m] = measure
+              values[key][:v] = value.to_f
+              values[key][:a] = a
+              values[key][:b] = b
+              values[key][:ab] = ab
+            end
+          end
+        end
+        min = values.min_by {|k,v| v[:v]}
+        max = values.max_by {|k,v| v[:v]}
+        current_range = (min[1][:m].is_a?(Evoc::InterestingnessMeasure) ? "[#{Evoc::InterestingnessMeasures.get_min(m)},#{Evoc::InterestingnessMeasures.get_max(m)}]" : "[0,1]")
+        CSV {|r| r << [m,current_range,min[1][:v],max[1][:v],min[1][:a],min[1][:b],min[1][:ab],max[1][:a],max[1][:b],max[1][:ab]]} # print row
+      end
+    end
+
+    def aggregator_range
+      r = Random.new
+      $stdout.puts 'aggregator,length,range,y'
+      (1..1000).each do |length|
+        list = ([1]*length).map {|i| i - rand(0.00001..1)}.sort.reverse
+        list_inf = ([1]*length).map {|i| rand(0..10)}.sort.reverse
+        aggregator = Evoc::InterestingnessMeasureAggregator.new('m_support',list)
+        aggregator_inf = Evoc::InterestingnessMeasureAggregator.new('m_hyper_coefficient',list_inf)
+        $stdout.puts "CG,#{length},\"0..1\",#{aggregator.cg}"
+        $stdout.puts "DCG,#{length},\"0..1\",#{aggregator.dcg}"
+        $stdout.puts "DCG2,#{length},\"0..1\",#{aggregator.dcg2}"
+        $stdout.puts "CG,#{length},inf,#{aggregator_inf.cg}"
+        $stdout.puts "DCG,#{length},inf,#{aggregator_inf.dcg}"
+        $stdout.puts "DCG2,#{length},inf,#{aggregator_inf.dcg2}"
+      end
+
+    end
+
+    def create_dict
+      puts "id,name"
+      self.tx_store.int_2_name.each do |id,name|
+        puts "#{id},#{name}"
+      end
+    end
+
+    private
+
+    def time_span(unit: 'years')
+      t1 = self.tx_store.first.date
+      t2 = self.tx_store.last.date
+      TimeDifference.between(t1,t2).method('in_'+unit).call
+    end
+
+    def average_time_between_commits(unit: 'hours')
+      if self.tx_store.size > 1
+        t1 = self.tx_store.first.date
+        t2 = self.tx_store.last.date
+        total_time = TimeDifference.between(t1,t2).method('in_'+unit).call
+        total_time.to_f/(self.tx_store.size-1)
+      else
+        raise Exception.new, "History only contained 1 or 0 transactions"
+      end
+    end
+  end #class
+end #module
+

data/lib/evoc/array.rb

@@ -0,0 +1,43 @@
+class Array
+	def subset?(other)
+		self & other == self
+	end
+
+	def include_any?(other)
+		(self & other).size > 0
+	end
+
+	##
+	# returns the union of an array of arraya
+	def array_union
+		if union = self.inject(:|)
+			return union
+		else
+			return []
+		end
+	end
+
+	##
+	# returns the intersection of a list of lists
+	def array_intersection
+		if intersection = self.inject(:&)
+			return intersection
+		else
+			return []
+		end
+	end
+
+	##
+	# returns the list of items in self that was not in other
+	def array_difference(other)
+		self.map {|a| a - other}.array_union
+	end
+
+  def self.powerset(set)
+    return [set] if set.empty?
+    p = set.pop
+    subset = powerset(set)  
+    subset | subset.map { |x| x | [p] }
+  end
+
+end

data/lib/evoc/evaluate.rb

@@ -0,0 +1,109 @@
+module Evoc
+  class Evaluate
+    extend Logging
+
+
+    def self.execute(recommendation,expected_outcome,evaluator)
+      if match = /average_precision(?<num>\d+)?/.match(evaluator)
+        if match[:num].nil?
+          self.average_precision(recommendation,expected_outcome)
+        else
+          self.average_precision(recommendation,expected_outcome,n: match[:num].to_i)
+        end
+      elsif match = /top10_recall/.match(evaluator)
+        self.top10_recall(recommendation,expected_outcome)
+      else raise ArgumentError, "The evaluator you requested (#{evaluator}) has not been implemented in Evoc::Evaluate"
+      end
+    end
+
+    # calculate the ratio of correct items in the top 10
+    # @param [Array] recommendation a sorted array 
+    # @param [Array] expected_outcome an array of items
+    # @return [Rational] the top10 recall
+    def self.top10_recall(recommendation,expected_outcome)
+        if !expected_outcome.is_a?(Array) then expected_outcome = [expected_outcome] end
+        if (expected_outcome.size > 0) & !recommendation.empty?
+          top10 = recommendation.take(10).flatten
+          common_items = (expected_outcome & top10).size.to_r
+          return common_items/expected_outcome.size
+        else
+          nil
+        end
+    end
+
+    ##
+    # calculate the average precision of the result based on an expected outcome
+    # @param [Array] recommendation a sorted array 
+    # @param [Array] expected_outcome an array of items
+    # @return [Float] the average precision
+    def self.average_precision(recommendation,expected_outcome, n: recommendation.size)
+        if !expected_outcome.is_a?(Array) then expected_outcome = [expected_outcome] end
+        if (expected_outcome.size > 0) & !recommendation.empty?
+          average_precision = 0
+          correct_items = []
+          total_items_considered = []
+          # sort rules by weight
+          # we first group rules with equal weights
+          # and then sort the groups by weight
+          recommendation.take(n).each do |items|
+            if !items.is_a?(Array) then items = [items] end
+            if items.first.class != expected_outcome.first.class
+                raise ArgumentError, "Expected outcome was of type #{expected_outcome.first.class}, while the item in the recommendation was of type #{items.first.class}"
+            end
+            # skip already considered items
+            if (new_items = items - total_items_considered).size > 0
+              new_items.each {|item| total_items_considered << item}
+              if correct_in_rule = (items & expected_outcome)
+                if correct_in_rule.size > 0
+                  # make sure that the new items havent already been added earlier
+                  new_correct = (correct_in_rule - correct_items)
+                  # add new items
+                  new_correct.each {|item| correct_items << item}
+                  change_in_recall = new_correct.size.to_r/expected_outcome.size
+                  precision_at_k = correct_items.size.to_r/total_items_considered.size
+                  average_precision += (precision_at_k * change_in_recall)
+                end
+              end
+            end
+          end
+          average_precision.to_f
+        else
+          nil
+        end
+    end
+
+    # calculate the grouped average precision of the result based on an expected outcome
+    def self.e_collected_average_precision(expected_outcome)
+        if !expected_outcome.is_a?(Array) then expected_outcome = [expected_outcome] end
+        if (expected_outcome.size > 0) & !self.empty?
+          collected_average_precision = 0
+          correct_items = []
+          total_items_considered = []
+          # sort rules by weight
+          # we first group rules with equal weights
+          # and then sort the groups by weight
+          groups = self.group_by {|r| r.weight}.sort.reverse
+          groups.each do |(_,rules)|
+            items = rules.map(&:rhs).flatten.uniq
+            if (new_items = items - total_items_considered).size > 0
+              new_items.each {|item| total_items_considered << item}
+              if correct_in_group = (items & expected_outcome)
+                if correct_in_group.size > 0
+                  # make sure that the new items havent already been added earlier
+                  new_correct = (correct_in_group - correct_items)
+                  # add new items
+                  new_correct.each {|item| correct_items << item}
+                  change_in_recall = new_correct.size.to_r/expected_outcome.size
+                  precision_at_k = correct_items.size.to_r/total_items_considered.size
+                  collected_average_precision += (precision_at_k * change_in_recall)
+                end
+              end
+            end
+          end
+          self.collected_average_precision = collected_average_precision.to_f
+        else
+          self.collected_average_precision = nil
+        end
+    end
+  end
+end

data/lib/evoc/exceptions/aggregation_error.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class AggregationError < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/expectedoutcome_nil_or_empty.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class ExpectedOutcomeNilorEmpty < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/measure_calculation_error.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class MeasureCalculationError < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/no_changed_items_in_changes.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class NoChangedItemsInChanges < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/no_changes_in_json_object.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class NoChangesInJsonObject < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/no_date_in_json_object.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class NoDateInJsonObject < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/no_result.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class NoResult < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/non_finite.rb

@@ -0,0 +1,8 @@
+module Evoc
+  module Exceptions
+    module InterestingnessMeasure
+      class NonFinite < StandardError
+      end
+    end
+  end
+end

data/lib/evoc/exceptions/non_numeric.rb

@@ -0,0 +1,8 @@
+module Evoc
+  module Exceptions
+    module InterestingnessMeasure
+      class NonNumeric < StandardError
+      end
+    end
+  end
+end

data/lib/evoc/exceptions/not_a_query.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class NotAQuery < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/not_a_result.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class NotAResult < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/not_a_transaction.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class NotATransaction < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/not_initialized.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class NotInitialized < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/only_nil_in_changes.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class OnlyNilInChanges < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/query_nil_or_empty.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class QueryNilOrEmpty < StandardError
+    end
+  end
+end

data/lib/evoc/exceptions/unable_to_convert_json_to_tx.rb

@@ -0,0 +1,6 @@
+module Evoc
+  module Exceptions
+    class UnableToConvertJsonToTx < StandardError
+    end
+  end
+end