fastruby-metric_fu 5.0.0

data/gem_tasks/build.rake

@@ -0,0 +1,197 @@
+# encoding: utf-8
+require 'rubygems'
+require 'digest/sha2'
+require 'rake/tasklib'
+# require 'bundler/gem_helper'
+# Bundler::GemHelper.install_tasks
+
+# Based on https://github.com/bundler/bundler/blob/ec0621d/lib/bundler/gem_helpers.rb
+GEM_TASKS = Class.new(Rake::TaskLib) do
+  include Rake::DSL if defined? Rake::DSL
+  attr_reader :base
+  def initialize
+    @base = File.expand_path('../..', __FILE__)
+    @gemspec_path = File.join(base, 'metric_fu.gemspec')
+    @gemspec = Gem::Specification.load(@gemspec_path)
+  end
+
+  def install
+    built_gem_path = nil
+
+    desc "Build #{built_gem_name} into the pkg directory."
+    task 'build' do
+      built_gem_path = build_gem
+    end
+
+    desc "Build and install #{built_gem_name} into system gems."
+    task 'install' => 'build' do
+      install_gem(built_gem_path)
+    end
+
+    desc 'Creates and commits a SHA512 checksum of the current version built gem'
+    task 'checksum' => 'build' do
+      add_checksum(built_gem_path)
+    end
+
+    desc "Create tag #{version_tag} and build and push #{built_gem_name} to Rubygems"
+    task 'release' => 'checksum' do
+      release_gem(built_gem_path)
+    end
+
+  end
+
+  def build_gem
+     file_name = nil
+     sh("gem build -V '#{@gemspec_path}'") { |out, code|
+       file_name = File.basename(built_gem_path)
+       FileUtils.mkdir_p(File.join(base, 'pkg'))
+       FileUtils.mv(built_gem_path, 'pkg')
+       STDOUT.puts "#{name} #{version} built to pkg/#{file_name}."
+     }
+     File.join(base, 'pkg', file_name)
+  end
+
+  def install_gem(built_gem_path=nil)
+    built_gem_path ||= build_gem
+    out, _ = sh_with_code("gem install '#{built_gem_path}' --local")
+    raise "Couldn't install gem, run `gem install #{built_gem_path}' for more detailed output" unless out[/Successfully installed/]
+    STDOUT.puts "#{name} (#{version}) installed."
+  end
+  # Based on https://github.com/YorickPeterse/ruby-lint/blob/3e946/task/checksum.rake
+  def add_checksum(built_gem_path=nil)
+    guard_clean
+    built_gem_path ||= build_gem
+    checksum_file = File.join(checksums, checksum_name)
+    File.open(checksum_file, 'w') do |handle|
+      handle.write(gem_checksum(built_gem_path))
+    end
+    sh_with_code("git add #{checksum_file} && git commit -m 'Add checksum for #{built_gem_name}'")
+  end
+
+  def checksums
+    File.expand_path('../../checksum', __FILE__)
+  end
+
+  def checksum_name
+    File.basename(built_gem_name) + '.sha512'
+  end
+
+  def gem_checksum(built_gem_path)
+    checksum(File.read(built_gem_path))
+  end
+
+  def checksum(content)
+    Digest::SHA512.new.hexdigest(content)
+  end
+
+  def release_gem(built_gem_path=nil)
+    guard_clean
+    built_gem_path ||= build_gem
+    add_checksum(built_gem_path) #unless already hashed?
+    tag_version { git_push } unless already_tagged?
+    rubygem_push(built_gem_path) if gem_push?
+  end
+
+  protected
+
+  def rubygem_push(path)
+    if Pathname.new("~/.gem/credentials").expand_path.exist?
+      sh("gem push '#{path}'")
+      STDOUT.puts "Pushed #{name} #{version} to rubygems.org."
+    else
+      raise "Your rubygems.org credentials aren't set. Run `gem push` to set them."
+    end
+  end
+
+  def built_gem_path
+    Dir[File.join(base, "#{name}-*.gem")].sort_by{|f| File.mtime(f)}.last
+  end
+
+  def git_push
+    perform_git_push
+    perform_git_push ' --tags'
+    STDOUT.puts "Pushed git commits and tags."
+  end
+
+  def perform_git_push(options = '')
+    cmd = "git push #{options}"
+    out, code = sh_with_code(cmd)
+    raise "Couldn't git push. `#{cmd}' failed with the following output:\n\n#{out}\n" unless code == 0
+  end
+
+  def already_tagged?
+    if sh('git tag').split(/\n/).include?(version_tag)
+      STDOUT.puts "Tag #{version_tag} has already been created."
+      true
+    end
+  end
+
+  def guard_clean
+    clean? && committed? or raise("There are files that need to be committed first.")
+  end
+
+  def clean?
+    sh_with_code("git diff --exit-code")[1] == 0
+  end
+
+  def committed?
+    sh_with_code("git diff-index --quiet --cached HEAD")[1] == 0
+  end
+
+  def tag_version
+    sh "git tag -a -m \"Version #{version}\" #{version_tag}"
+    STDOUT.puts "Tagged #{version_tag}."
+    yield if block_given?
+  rescue
+    STDERR.puts "Untagging #{version_tag} due to error."
+    sh_with_code "git tag -d #{version_tag}"
+    raise
+  end
+
+  def version
+    @gemspec.version
+  end
+
+  def version_tag
+    "v#{version}"
+  end
+
+  def name
+    @gemspec.name
+  end
+
+  def built_gem_name
+    "#{name}-#{version}.gem"
+  end
+
+  def sh(cmd, &block)
+    out, code = sh_with_code(cmd, &block)
+    code == 0 ? out : raise(out.empty? ? "Running `#{cmd}' failed. Run this command directly for more detailed output." : out)
+  end
+
+  def sh_with_code(cmd, &block)
+    cmd << " 2>&1"
+    outbuf = ''
+    p cmd
+    Dir.chdir(base) {
+      outbuf = `#{cmd}`
+      if $? == 0
+        block.call(outbuf) if block
+      end
+    }
+    [outbuf, $?]
+  end
+
+  def gem_push?
+    ! %w{n no nil false off 0}.include?(ENV['gem_push'].to_s.downcase)
+  end
+
+end.new.install
+
+# Based on https://github.com/YorickPeterse/ruby-lint/blob/3e946e6/task/todo.rake
+desc 'Extracts TODO tags and the likes'
+task :todo do
+  regex = %w{NOTE: FIXME: TODO: THINK: @todo}.join('|')
+
+  sh "ack '#{regex}' lib"
+end

data/gem_tasks/rubocop.rake

@@ -0,0 +1,10 @@
+if ENV["FULL_BUILD"] != "true" # skip on Travis
+  require "rubocop/rake_task"
+  RuboCop::RakeTask.new(:rubocop) do |task|
+    task.patterns = ["lib", "spec"]
+    task.formatters = ["progress"]
+    task.options = ["--display-cop-names"]
+    task.fail_on_error = false
+    task.verbose = false
+  end
+end

data/gem_tasks/usage_test.rake

@@ -0,0 +1,19 @@
+ROOT_PATH    = File.expand_path("..", File.dirname(__FILE__))
+require File.join(ROOT_PATH, 'spec', 'support', 'usage_test')
+LIB_PATH     = File.join(ROOT_PATH, 'lib')
+BIN_PATH     = File.join(ROOT_PATH, 'bin')
+EXAMPLE_FILES = [
+  File.join(ROOT_PATH, 'README.md'),
+  File.join(ROOT_PATH, 'DEV.md')
+]
+task "load_path" do
+  $LOAD_PATH.unshift(LIB_PATH)
+  $VERBOSE = nil
+  ENV['PATH'] = "#{BIN_PATH}:#{ENV['PATH']}"
+  ENV['CC_BUILD_ARTIFACTS'] = 'turn_off_browser_opening'
+end
+desc "Test that documentation usage works"
+task "usage_test" => %w[load_path] do
+  usage_test = UsageTest.new
+  usage_test.test_files(EXAMPLE_FILES)
+end

data/gem_tasks/yard.rake

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+begin
+  require "yard"
+rescue LoadError
+else
+namespace :yard do
+  YARD::Rake::YardocTask.new(:doc) do |t|
+    t.stats_options = ["--list-undoc"]
+  end
+
+  desc "start a gem server"
+  task :server do
+    sh "bundle exec yard server --gems"
+  end
+
+  desc "use Graphviz to generate dot graph"
+  task :graph do
+    output_file = "doc/erd.dot"
+    sh "bundle exec yard graph --protected --full --dependencies > #{output_file}"
+    puts "open doc/erd.dot if you have graphviz installed"
+  end
+end
+end

data/lib/metric_fu.rb

@@ -0,0 +1,151 @@
+# coding: utf-8
+require "metric_fu/version"
+require "forwardable"
+require "pathname"
+module MetricFu
+  APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+  LIB_ROOT = File.join(APP_ROOT, "lib/metric_fu")
+
+  module_function
+
+  def root
+    @app_root ||= Pathname(APP_ROOT)
+  end
+
+  def metric_url
+    "https://github.com/metricfu/metric_fu"
+  end
+
+  def metric_name
+    "MetricFu"
+  end
+
+  def with_run_dir(dir, &block)
+    old_dir = run_dir
+    self.run_dir = dir
+
+    block.call
+
+    self.run_dir = old_dir
+  end
+
+  def run_dir
+    @run_dir ||= Dir.pwd
+  end
+
+  def run_path
+    Pathname(run_dir)
+  end
+
+  def run_dir=(run_dir)
+    @run_dir = run_dir
+  end
+
+  def report_name
+    @report_name || self.report_name = run_path.basename.to_s
+  end
+
+  def report_name=(report_name)
+    @report_name = report_name
+  end
+
+  # The time at analyzed code state
+  def report_time
+    Time.now
+  end
+
+  def report_date_string
+    report_time.strftime("%Y%m%d")
+  end
+
+  # @return [String]
+  # @example '20140323'
+  # Used to uniquely identify reports
+  # as a sortable reference to when the report
+  # was generated
+  def report_id
+    report_date_string
+  end
+
+  # Non-date-specific; Used to uniquely identify a report run
+  def report_fingerprint
+    report_time.to_i.to_s
+  end
+
+  # The time the metrics are generated
+  def current_time
+    Time.now.localtime
+  end
+
+  def root_dir
+    APP_ROOT
+  end
+
+  def lib_dir
+    LIB_ROOT
+  end
+
+  require "metric_fu/loader"
+  LOADER = MetricFu::Loader.new(LIB_ROOT)
+  def loader
+    LOADER
+  end
+  extend SingleForwardable
+
+  def_delegators :loader, :lib_require, :load_tasks
+
+  def library_dirs
+    %w(metrics formatter reporting logging errors data_structures tasks)
+  end
+
+  loader.create_dirs(self) do
+    library_dirs
+  end
+
+  # @note artifact_dir is relative to where the task is being run,
+  #   not to the metric_fu library
+  require "metric_fu/io"
+  def artifact_dir
+    MetricFu::Io::FileSystem.artifact_dir
+  end
+
+  def artifact_subdirs
+    %w(scratch output _data)
+  end
+
+  loader.create_artifact_subdirs(self) do
+    artifact_subdirs
+  end
+
+  loader.setup
+
+  def reset
+    # TODO Don't like how this method needs to know
+    # all of these class variables that are defined
+    # in separate classes.
+    @configuration = nil
+    @graph = nil
+    @result = nil
+  end
+
+  def run(options)
+    MetricFu::Run.new.run(options)
+  end
+
+  def run_only(metrics_to_run_names, options)
+    metrics_to_run_names = Array(metrics_to_run_names).map(&:to_s)
+    MetricFu::Configuration.run do |config|
+      config.configure_metrics.each do |metric|
+        metric_name = metric.name.to_s
+        if metrics_to_run_names.include?(metric_name)
+          p "Enabling #{metric_name}"
+          metric.enabled = true
+        else
+          p "Disabling #{metric_name}"
+          metric.enabled = false
+        end
+      end
+    end
+    run(options)
+  end
+end

data/lib/metric_fu/calculate.rb

@@ -0,0 +1,10 @@
+module MetricFu
+  module Calculate
+    module_function
+
+    def integer_percent(num, total)
+      return 0 if total.zero?
+      (Float(num) / Float(total) * 100).round
+    end
+  end
+end

data/lib/metric_fu/cli/client.rb

@@ -0,0 +1,26 @@
+require "metric_fu"
+require "metric_fu/cli/helper"
+require "metric_fu/cli/parser"
+module MetricFu
+  module Cli
+    class Client
+      def initialize
+        @helper = MetricFu::Cli::Helper.new
+      end
+
+      def shutdown
+        @helper.shutdown
+      end
+
+      def run(argv = ARGV.dup)
+        options =  @helper.process_options(argv)
+        mf_debug "Got options #{options.inspect}"
+        if options[:run]
+          @helper.run(options)
+        else
+          STDOUT.puts @helper.usage
+        end
+      end
+    end
+  end
+end

data/lib/metric_fu/cli/helper.rb

@@ -0,0 +1,80 @@
+require "metric_fu"
+require "metric_fu/cli/parser"
+MetricFu.lib_require { "run" }
+# see https://github.com/grosser/pru/blob/master/bin/pru
+module MetricFu
+  module Cli
+    def self.immediate_shutdown!
+      exit(1)
+    end
+    def self.complete!
+      exit(0)
+    end
+    class Helper
+      def initialize
+        @metric_fu = MetricFu::Run.new
+      end
+
+      def run(options = {})
+        @metric_fu.run(options)
+        complete
+      end
+
+      def version
+        MetricFu::VERSION
+      end
+
+      def shutdown
+        out "\nShutting down. Bye"
+        MetricFu::Cli.immediate_shutdown!
+      end
+
+      def banner
+        "MetricFu: A Fistful of code metrics"
+      end
+
+      def usage
+        <<-EOS
+        #{banner}
+        Use --help for help
+        EOS
+      end
+
+      def executable_name
+        "metric_fu"
+      end
+
+      def metrics
+        MetricFu::Metric.metrics.map(&:name).sort_by(&:to_s)
+      end
+
+      def process_options(argv = [])
+        options = MetricFu::Cli::MicroOptParse::Parser.new do |p|
+          p.banner = banner
+          p.version = version
+          p.option :run, "Run all metrics with defaults", default: true
+          metrics.each do |metric|
+            p.option metric.to_sym, "Enables or disables #{metric}", default: true # , :value_in_set => [true, false]
+          end
+          p.option :open, "Open report in browser (if supported by formatter)", default: true
+        end.process!(argv)
+        options
+      end
+
+      private
+
+      def out(text)
+        STDOUT.puts text
+      end
+
+      def error(text)
+        STDERR.puts text
+      end
+
+      def complete
+        out "all done"
+        MetricFu::Cli.complete!
+      end
+    end
+  end
+end