class Mvp::Runner

Public Class Methods

new(options = {}) click to toggle source
# File lib/mvp/runner.rb, line 11
def initialize(options = {})
  @cachedir = options[:cachedir]
  @debug    = options[:debug]
  @options  = options
end

Public Instance Methods

analyze() click to toggle source
# File lib/mvp/runner.rb, line 109
def analyze
  bigquery = Mvp::Bigquery.new(@options)
  itemizer = Mvp::Itemizer.new(@options)

  begin
    spinner = mkspinner("Analyzing modules...")
    modules = bigquery.get(:modules, [:owner, :name, :version, :downloads])
    modules = modules.sample(@options[:count]) if @options[:count]

    require 'csv'
    csv_string = CSV.generate do |csv|
      modules.each do |mod|
        spinner.stop if @options[:debug]
        rows = itemizer.analyze(mod, @options[:script], @options[:debug])
        spinner.start if @options[:debug]

        next unless rows
        spinner.update(title: mod[:name])
        rows.each {|row| csv << row}
      end
    end

    File.write(@options[:output_file], csv_string)
    spinner.success('(OK)')
  end
end
mirror(target = :all) click to toggle source
# File lib/mvp/runner.rb, line 37
def mirror(target = :all)
  forge    = Mvp::Forge.new(@options)
  bigquery = Mvp::Bigquery.new(@options)
  itemizer = Mvp::Itemizer.new(@options)
  pfparser = Mvp::PuppetfileParser.new(@options)

  begin
    [:authors, :modules, :releases].each do |thing|
      next unless [:all, thing].include? target
      spinner = mkspinner("Mirroring #{thing}...")
      bigquery.truncate(thing)
      forge.retrieve(thing) do |data, offset|
        spinner.update(title: "Mirroring #{thing} [#{offset}]...")
        bigquery.insert(thing, data)
      end
      spinner.success('(OK)')
    end

    if [:all, :validations].include? target
      spinner = mkspinner("Mirroring validations...")
      modules = bigquery.get(:modules, [:slug])
      bigquery.truncate(:validations)
      forge.retrieve_validations(modules) do |data, offset|
        spinner.update(title: "Mirroring validations [#{offset}]...")
        bigquery.insert(:validations, data)
      end
      spinner.success('(OK)')
    end

    if [:all, :itemizations].include? target
      spinner = mkspinner("Itemizing modules...")
      bigquery.unitemized.each do |mod|
        spinner.update(title: "Itemizing [#{mod[:slug]}]...")
        rows = itemizer.itemized(mod)
        bigquery.delete(:itemized, :module, mod[:slug])
        bigquery.insert(:itemized, rows)
      end
      spinner.success('(OK)')
    end

    if [:all, :mirrors, :tables].include? target
      @options[:gcloud][:mirrors].each do |entity|
        spinner = mkspinner("Mirroring #{entity[:type]} #{entity[:name]} to BigQuery...")
        bigquery.mirror_table(entity)
        spinner.success('(OK)')
      end
    end

    if [:all, :puppetfiles].include? target
      spinner = mkspinner("Analyzing Puppetfile module references...")
      if pfparser.suitable?
        pfparser.sources = bigquery.module_sources
        bigquery.puppetfiles.each do |repo|
          spinner.update(title: "Analyzing [#{repo[:repo_name]}/Puppetfile]...")
          rows = pfparser.parse(repo)
          bigquery.delete(:puppetfile_usage, :repo_name, repo[:repo_name], :github)
          bigquery.insert(:puppetfile_usage, rows, :github)
        end
        spinner.success('(OK)')
      else
        spinner.error("(Not functional on Ruby #{RUBY_VERSION})")
      end
    end

  rescue => e
    spinner.error("API error: #{e.message}")
    $logger.error "API error: #{e.message}"
    $logger.debug e.backtrace.join("\n")
    sleep 10
  end
end
mkspinner(title) click to toggle source
# File lib/mvp/runner.rb, line 145
def mkspinner(title)
  spinner = TTY::Spinner.new("[:spinner] :title")
  spinner.update(title: title)
  spinner.auto_spin
  spinner
end
retrieve(target = :all, download = true) click to toggle source
# File lib/mvp/runner.rb, line 17
def retrieve(target = :all, download = true)
  bigquery = Mvp::Bigquery.new(@options)

  begin
    [:authors, :modules, :releases, :validations].each do |thing|
      next unless [:all, thing].include? target
      spinner = mkspinner("Retrieving #{thing} ...")
      data = bigquery.retrieve(thing)
      save_json(thing, data)
      spinner.success('(OK)')
    end

  rescue => e
    spinner.error("API error: #{e.message}")
    $logger.error "API error: #{e.message}"
    $logger.debug e.backtrace.join("\n")
    sleep 10
  end
end
save_json(thing, data) click to toggle source
# File lib/mvp/runner.rb, line 152
def save_json(thing, data)
  File.write("#{@cachedir}/#{thing}.json", data.to_json)
end
stats(target) click to toggle source
# File lib/mvp/runner.rb, line 136
def stats(target)
  stats = Mvp::Stats.new(@options)

  [:authors, :modules, :releases, :relationships, :validations].each do |thing|
    next unless [:all, thing].include? target
    stats.send(thing)
  end
end
test() click to toggle source
# File lib/mvp/runner.rb, line 156
def test()
  require 'pry'
  binding.pry
end