openvox 7.37.1 → 8.19.0

data/tasks/memwalk.rake

@@ -1,195 +0,0 @@
-# Walks the memory dumped into heap.json, and produces a graph of the memory dumped in diff.json
-# If a single argument (a hex address to one object) is given, the graph is limited to this object and what references it
-# The heap dumps should be in the format produced by Ruby ObjectSpace in Ruby version 2.1.0 or later.
-#
-# The command produces a .dot file that can be rendered with graphwiz dot into SVG. If a memwalk is performed for all
-# objects in the diff.json, the output file name is memwalk.dot. If it is produced for a single address, the name of the
-# output file is memwalk-<address>.dot
-#
-# The dot file can be rendered with something like: dot -Tsvg -omemwalk.svg memwalk.dot
-#
-desc "Process a diff.json of object ids, and a heap.json of a Ruby 2.1.0 ObjectSpace dump and produce a graph"
-task :memwalk, [:id] do |t, args|
-  puts "Memwalk"
-  puts "Computing for #{args[:id] ? args[:id] : 'all'}"
-  @single_id = args[:id] ? args[:id].to_i(16) : nil
-
-  require 'json'
-  #require 'debug'
-
-  TYPE = "type".freeze
-  ROOT = "root".freeze
-  ROOT_UC = "ROOT".freeze
-  ADDR = "address".freeze
-  NODE = "NODE".freeze
-  STRING = "STRING".freeze
-  DATA = "DATA".freeze
-  HASH = "HASH".freeze
-  ARRAY = "ARRAY".freeze
-  OBJECT = "OBJECT".freeze
-  CLASS = "CLASS".freeze
-
-  allocations = {}
-  # An array of integer addresses of the objects to trace bindings for
-  diff_index = {}
-  puts "Reading data"
-  begin
-    puts "Reading diff"
-    lines = 0;
-    File.readlines("diff.json").each do | line |
-      lines += 1
-      diff = JSON.parse(line)
-      case diff[ TYPE ]
-      when STRING, DATA, HASH, ARRAY
-        # skip the strings
-      else
-        diff_index[ diff[ ADDR ].to_i(16) ] = diff
-      end
-    end
-    puts "Read #{lines} number of diffs"
-  rescue => e
-    raise "ERROR READING DIFF at line #{lines} #{e.message[0, 200]}"
-  end
-
-  begin
-    puts "Reading heap"
-    lines = 0
-    allocation = nil
-    File.readlines("heap.json").each do | line |
-      lines += 1
-      allocation = JSON.parse(line)
-      case allocation[ TYPE ]
-      when ROOT_UC
-        # Graph for single id must include roots, as it may be a root that holds on to the reference
-        # a global variable, thread, etc.
-        #
-        if @single_id
-          allocations[ allocation[ ROOT ] ] = allocation
-        end
-      when NODE
-        # skip the NODE objects - they represent the loaded ruby code
-      when STRING
-        # skip all strings - they are everywhere
-      else
-        allocations[ allocation[ ADDR ].to_i(16) ] = allocation
-      end
-    end
-    puts "Read #{lines} number of entries"
-  rescue => e
-    require 'debug'
-    puts "ERROR READING HEAP #{e.message[0, 200]}"
-    raise e
-  end
-  @heap = allocations
-
-  puts "Building reference index"
-  # References is an index from a referenced object to an array with addresses to the objects that references it
-  @references = Hash.new { |h, k| h[k] = [] }
-  REFERENCES = "references".freeze
-  allocations.each do |k,v|
-    refs = v[ REFERENCES ]
-    if refs.is_a?(Array)
-      refs.each {|addr| @references[ addr.to_i(16) ] << k }
-    end
-  end
-
-  @printed = Set.new()
-
-  def print_object(addr, entry)
-    # only print each node once
-    return unless @printed.add?(addr)
-    begin
-    if addr.is_a?(String)
-      @output.write( "x#{node_name(addr)} [label=\"#{node_label(addr, entry)}\\n#{addr}\"];\n")
-    else
-      @output.write( "x#{node_name(addr)} [label=\"#{node_label(addr, entry)}\\n#{addr.to_s(16)}\"];\n")
-    end
-    rescue => e
-      require 'debug'
-      raise e
-    end
-  end
-
-  def node_label(addr, entry)
-    if entry[ TYPE ] == OBJECT
-      class_ref = entry[ "class" ].to_i(16)
-      @heap[ class_ref ][ "name" ]
-    elsif entry[ TYPE ] == CLASS
-      "CLASS #{entry[ "name"]}"
-    else
-      entry[TYPE]
-    end
-  end
-
-  def node_name(addr)
-    return addr if addr.is_a? String
-    addr.to_s(16)
-  end
-
-  def print_edge(from_addr, to_addr)
-    @output.write("x#{node_name(from_addr)}->x#{node_name(to_addr)};\n")
-  end
-
-  def closure_and_edges(diff)
-    edges = Set.new()
-    walked = Set.new()
-    puts "Number of diffs referenced = #{diff.count {|k,_| @references[k].is_a?(Array) && @references[k].size() > 0 }}"
-    diff.each {|k,_| walk(k, edges, walked) }
-    edges.each {|e| print_edge(*e) }
-  end
-
-  def walk(addr, edges, walked)
-    if !@heap[ addr ].nil?
-      print_object(addr, @heap[addr])
-
-      @references [ addr ].each do |r|
-        walk_to_object(addr, r, edges, walked)
-      end
-    end
-  end
-
-  def walk_to_object(to_addr, cursor, edges, walked)
-    return unless walked
-    # if walked to an object, or everything if a single_id is the target
-    if @heap[ cursor ][ TYPE ] == OBJECT || (@single_id && @heap[ cursor ][ TYPE ] == ROOT_UC || @heap[ cursor ][ TYPE ] == CLASS )
-      # and the edge is unique
-      if edges.add?( [ cursor, to_addr ] )
-        # then we may not have visited objects this objects is being referred from
-        print_object(cursor, @heap[ cursor ])
-        # Do not follow what binds a class
-        if @heap[ cursor ][ TYPE ] != CLASS
-          @references[ cursor ].each do |r|
-            walk_to_object(cursor, r, edges, walked.add?(r))
-            walked.delete(r)
-          end
-        end
-      end
-    else
-      # continue search until Object
-      @references[cursor].each do |r|
-        walk_to_object(to_addr, r, edges, walked.add?(r))
-      end
-    end
-  end
-
-  def single_closure_and_edges(the_target)
-    edges = Set.new()
-    walked = Set.new()
-    walk(the_target, edges, walked)
-    edges.each {|e| print_edge(*e) }
-  end
-
-  puts "creating graph"
-  if @single_id
-    @output = File.open("memwalk-#{@single_id.to_s(16)}.dot", "w")
-    @output.write("digraph root {\n")
-    single_closure_and_edges(@single_id)
-  else
-    @output = File.open("memwalk.dot", "w")
-    @output.write("digraph root {\n")
-    closure_and_edges(diff_index)
-  end
-  @output.write("}\n")
-  @output.close
-  puts "done"
-end

data/tasks/parallel.rake

@@ -1,410 +0,0 @@
-# encoding: utf-8
-
-require 'rubygems'
-require 'thread'
-begin
-  require 'rspec'
-  require 'rspec/core/formatters/helpers'
-  require 'etc'
-rescue LoadError
-  # Don't define the task if we don't have rspec present
-else
-  module Parallel
-    module RSpec
-      #
-      # Responsible for buffering the output of RSpec's progress formatter.
-      #
-      class ProgressFormatBuffer
-        attr_reader :pending_lines
-        attr_reader :failure_lines
-        attr_reader :examples
-        attr_reader :failures
-        attr_reader :pending
-        attr_reader :failed_example_lines
-        attr_reader :state
-
-        module OutputState
-          HEADER = 1
-          PROGRESS = 2
-          SUMMARY = 3
-          PENDING = 4
-          FAILURES = 5
-          DURATION = 6
-          COUNTS = 7
-          FAILED_EXAMPLES = 8
-        end
-
-        def initialize(io, color)
-          @io = io
-          @color = color
-          @state = OutputState::HEADER
-          @pending_lines = []
-          @failure_lines = []
-          @examples = 0
-          @failures = 0
-          @pending = 0
-          @failed_example_lines = []
-        end
-
-        def color?
-          @color
-        end
-
-        def read
-          # Parse and ignore the one line header
-          if @state == OutputState::HEADER
-            begin
-              @io.readline
-            rescue EOFError
-              return nil
-            end
-            @state = OutputState::PROGRESS
-            return ''
-          end
-
-          # If the progress has been read, parse the summary
-          if @state == OutputState::SUMMARY
-            parse_summary
-            return nil
-          end
-
-          # Read the progress output up to 128 bytes at a time
-          # 128 is a small enough number to show some progress, but not too small that
-          # we're constantly writing synchronized output
-          data = @io.read(128)
-          return nil unless data
-
-          data = @remainder + data if @remainder
-
-          # Check for the end of the progress line
-          if (index = data.index "\n")
-            @state = OutputState::SUMMARY
-            @remainder = data[(index+1)..-1]
-            data = data[0...index]
-          # Check for partial ANSI escape codes in colorized output
-          elsif @color && !data.end_with?("\e[0m") && (index = data.rindex("\e[", -6))
-            @remainder = data[index..-1]
-            data = data[0...index]
-          else
-            @remainder = nil
-          end
-
-          data
-        end
-
-        private
-
-        def parse_summary
-          # If there is a remainder, concat it with the next line and handle each line
-          unless @remainder.empty?
-            lines = @remainder
-            eof = false
-            begin
-              lines += @io.readline
-            rescue EOFError
-              eof = true
-            end
-            lines.each_line do |line|
-              parse_summary_line line
-            end
-            return if eof
-          end
-
-          # Process the rest of the lines
-          begin
-            @io.each_line do |line|
-              parse_summary_line line
-            end
-          rescue EOFError
-          end
-        end
-
-        def parse_summary_line(line)
-          line.chomp!
-          return if line.empty?
-
-          if line == 'Pending:'
-            @status = OutputState::PENDING
-            return
-          elsif line == 'Failures:'
-            @status = OutputState::FAILURES
-            return
-          elsif line == 'Failed examples:'
-            @status = OutputState::FAILED_EXAMPLES
-            return
-          elsif (line.match /^Finished in ((\d+\.?\d*) minutes?)? ?(\d+\.?\d*) seconds?$/)
-            @status = OutputState::DURATION
-            return
-          elsif (match = line.gsub(/\e\[\d+m/, '').match /^(\d+) examples?, (\d+) failures?(, (\d+) pending)?$/)
-            @status = OutputState::COUNTS
-            @examples = match[1].to_i
-            @failures = match[2].to_i
-            @pending = (match[4] || 0).to_i
-            return
-          end
-
-          case @status
-            when OutputState::PENDING
-              @pending_lines << line
-            when OutputState::FAILURES
-              @failure_lines << line
-            when OutputState::FAILED_EXAMPLES
-              @failed_example_lines << line
-          end
-        end
-      end
-
-      #
-      # Responsible for parallelizing spec testing.
-      # Optional options list will be passed to rspec.
-      #
-      class Parallelizer
-        # Number of processes to use
-        attr_reader :process_count
-        # Approximate size of each group of tests
-        attr_reader :group_size
-        # Options list for rspec
-        attr_reader :options
-
-        def initialize(process_count, group_size, color, options = [])
-          @process_count = process_count
-          @group_size = group_size
-          @color = color
-          @options = options
-        end
-
-        def color?
-          @color
-        end
-
-        def run
-          @start_time = Time.now
-
-          groups = group_specs
-          fail red('error: no specs were found') if groups.length == 0
-
-          begin
-            run_specs(groups, options)
-          ensure
-            groups.each do |file|
-              File.unlink(file)
-            end
-          end
-        end
-
-        private
-
-        def group_specs
-          # Spawn the rspec_grouper utility to perform the test grouping
-          # We do this in a separate process to limit this processes' long-running footprint
-          io = IO.popen("ruby util/rspec_grouper #{@group_size}")
-
-          header = true
-          spec_group_files = []
-          io.each_line do |line|
-            line.chomp!
-            header = false if line.empty?
-            next if header || line.empty?
-            spec_group_files << line
-          end
-
-          _, status = Process.waitpid2(io.pid)
-          io.close
-
-          fail red('error: no specs were found.') unless status.success?
-          spec_group_files
-        end
-
-        def run_specs(groups, options)
-          puts "Processing #{groups.length} spec group(s) with #{@process_count} worker(s)"
-
-          interrupted = false
-          success = true
-          worker_threads = []
-          group_index = -1
-          pids = Array.new(@process_count)
-          mutex = Mutex.new
-
-          # Handle SIGINT by killing child processes
-          original_handler = Signal.trap :SIGINT do
-            break if interrupted
-            interrupted = true
-
-            # Can't synchronize in a trap context, so read dirty
-            pids.each do |pid|
-              begin
-                Process.kill(:SIGKILL, pid) if pid
-              rescue Errno::ESRCH
-              end
-            end
-            puts yellow("\nshutting down...")
-          end
-
-          buffers = []
-
-          process_count.times do |thread_id|
-            worker_threads << Thread.new do
-              while !interrupted do
-                # Get the spec file for this rspec run
-                group = mutex.synchronize { if group_index < groups.length then groups[group_index += 1] else nil end }
-                break unless group && !interrupted
-
-                # Spawn the worker process with redirected output
-                options_string = options ? options.join(' ') : ''
-                io = IO.popen("ruby util/rspec_runner #{group} #{options_string}")
-                pids[thread_id] = io.pid
-
-                # TODO: make the buffer pluggable to handle other output formats like documentation
-                buffer = ProgressFormatBuffer.new(io, @color)
-
-                # Process the output
-                while !interrupted
-                  output = buffer.read
-                  break unless output && !interrupted
-                  next if output.empty?
-                  mutex.synchronize { print output }
-                end
-
-                # Kill the process if we were interrupted, just to be sure
-                if interrupted
-                  begin
-                    Process.kill(:SIGKILL, pids[thread_id])
-                  rescue Errno::ESRCH
-                  end
-                end
-
-                # Reap the process
-                result = Process.waitpid2(pids[thread_id])[1].success?
-                io.close
-                pids[thread_id] = nil
-                mutex.synchronize do
-                  buffers << buffer
-                  success &= result
-                end
-              end
-            end
-          end
-
-          # Join all worker threads
-          worker_threads.each do |thread|
-            thread.join
-          end
-
-          Signal.trap :SIGINT, original_handler
-          fail yellow('execution was interrupted') if interrupted
-
-          dump_summary buffers
-          success
-        end
-
-        def colorize(text, color_code)
-          if @color
-            "#{color_code}#{text}\e[0m"
-          else
-            text
-          end
-        end
-
-        def red(text)
-          colorize(text, "\e[31m")
-        end
-
-        def green(text)
-          colorize(text, "\e[32m")
-        end
-
-        def yellow(text)
-          colorize(text, "\e[33m")
-        end
-
-        def dump_summary(buffers)
-          puts
-
-          # Print out the pending tests
-          print_header = true
-          buffers.each do |buffer|
-            next if buffer.pending_lines.empty?
-            if print_header
-              puts "\nPending:"
-              print_header = false
-            end
-            puts buffer.pending_lines
-          end
-
-          # Print out the failures
-          print_header = true
-          buffers.each do |buffer|
-            next if buffer.failure_lines.empty?
-            if print_header
-              puts "\nFailures:"
-              print_header = false
-            end
-            puts
-            puts buffer.failure_lines
-          end
-
-          # Print out the run time
-          puts "\nFinished in #{::RSpec::Core::Formatters::Helpers.format_duration(Time.now - @start_time)}"
-
-          # Count all of the examples
-          examples = 0
-          failures = 0
-          pending = 0
-          buffers.each do |buffer|
-            examples += buffer.examples
-            failures += buffer.failures
-            pending += buffer.pending
-          end
-          if failures > 0
-            puts red(summary_count_line(examples, failures, pending))
-          elsif pending > 0
-            puts yellow(summary_count_line(examples, failures, pending))
-          else
-            puts green(summary_count_line(examples, failures, pending))
-          end
-
-          # Print out the failed examples
-          print_header = true
-          buffers.each do |buffer|
-            next if buffer.failed_example_lines.empty?
-            if print_header
-              puts "\nFailed examples:"
-              print_header = false
-            end
-            puts buffer.failed_example_lines
-          end
-        end
-
-        def summary_count_line(examples, failures, pending)
-          summary = ::RSpec::Core::Formatters::Helpers.pluralize(examples, "example")
-          summary << ", " << ::RSpec::Core::Formatters::Helpers.pluralize(failures, "failure")
-          summary << ", #{pending} pending" if pending > 0
-          summary
-        end
-      end
-    end
-  end
-
-  namespace 'parallel' do
-    def color_output?
-      # Check with RSpec to see if color is enabled
-      config = ::RSpec::Core::Configuration.new
-      config.error_stream = $stderr
-      config.output_stream = $stdout
-      options = ::RSpec::Core::ConfigurationOptions.new []
-      options.configure config
-      config.color
-    end
-
-    desc 'Runs specs in parallel. Extra args are passed to rspec.'
-    task 'spec', [:process_count, :group_size] do |_, args|
-      # Default group size in rspec examples
-      DEFAULT_GROUP_SIZE = 1000
-
-      process_count = [(args[:process_count] || Etc.nprocessors).to_i, 1].max
-      group_size = [(args[:group_size] || DEFAULT_GROUP_SIZE).to_i, 1].max
-
-      abort unless Parallel::RSpec::Parallelizer.new(process_count, group_size, color_output?, args.extras).run
-    end
-  end
-end

data/tasks/parser.rake

@@ -1,22 +0,0 @@
-desc "Generate the 4.x 'future' parser"
-task :gen_eparser => :require_racc do
-  %x{racc -olib/puppet/pops/parser/eparser.rb lib/puppet/pops/parser/egrammar.ra}
-end
-
-desc "Generate the 4.x 'future' parser with egrammar.output"
-task :gen_eparser_output => :require_racc do
-  %x{racc -v -olib/puppet/pops/parser/eparser.rb lib/puppet/pops/parser/egrammar.ra}
-end
-
-desc "Generate the 4.x 'future' parser with debugging output"
-task :gen_eparser_debug => :require_racc do
-  %x{racc -t -olib/puppet/pops/parser/eparser.rb lib/puppet/pops/parser/egrammar.ra}
-end
-
-task :require_racc do
-  begin
-    require 'racc'
-  rescue LoadError
-    abort("Run `bundle install --with development` to install the `racc` gem.")
-  end
-end

data/tasks/yard.rake

@@ -1,59 +0,0 @@
-begin
-  require 'yard'
-
-  namespace :doc do
-    desc "Clean up generated documentation"
-    task :clean do
-      rm_rf "doc"
-    end
-
-    desc "Generate public documentation pages for the API"
-    YARD::Rake::YardocTask.new(:api) do |t|
-      t.files = ['lib/**/*.rb']
-      t.options = %w{
-        --protected
-        --private
-        --verbose
-        --markup markdown
-        --readme README.md
-        --tag status
-        --transitive-tag status
-        --tag comment
-        --hide-tag comment
-        --tag dsl:"DSL"
-        --no-transitive-tag api
-        --template-path yardoc/templates
-        --files README_DEVELOPER.md,CO*.md,api/**/*.md
-        --api public
-        --api private
-        --hide-void-return
-      }
-    end
-
-    desc "Generate documentation pages for all of the code"
-    YARD::Rake::YardocTask.new(:all) do |t|
-      t.files = ['lib/**/*.rb']
-      t.options = %w{
-        --verbose
-        --markup markdown
-        --readme README.md
-        --tag status
-        --transitive-tag status
-        --tag comment
-        --hide-tag comment
-        --tag dsl:"DSL"
-        --no-transitive-tag api
-        --template-path yardoc/templates
-        --files README_DEVELOPER.md,CO*.md,api/**/*.md
-        --api public
-        --api private
-        --no-api
-        --hide-void-return
-      }
-    end
-  end
-rescue LoadError => e
-  if verbose
-    STDERR.puts "Document generation not available without yard. #{e.message}"
-  end
-end