ruby-appraiser 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,5 @@
+# encoding: utf-8
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruby-appraiser.gemspec
+gemspec

data/LICENSE-APACHE.md

@@ -0,0 +1,13 @@
+Copyright 2013 Simply Measured
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/LICENSE-MIT.md

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Simply Measured
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/LICENSE.md

@@ -0,0 +1,4 @@
+This project is dual-licensed under [MIT][] and [APACHE][].
+
+[MIT]: LICENSE-MIT.md
+[APACHE]: LICENSE-APACHE.md

data/README.md

@@ -0,0 +1,77 @@
+RubyAppraiser
+=============
+
+So you have a big project and you want to improve the code quality? Sweet. Too
+bad you'll get a million errors when you run [rubocop][], [reek][], or
+[flog][], so it'll annoy you with information overload until you get fed up & 
+turn it off.
+
+Enter: RubyAppraiser, a generic interface for attaching code-quality tools
+that limits their output to the lines you're changing, which allows you to use
+these tools to gradually heal projects. Add a pre-commit hook that rejects
+defective contributions, level up to require entire touched files to be fixed,
+or run several code-quality tools in a single command.
+
+The filters currently provided are:
+
+ - all - (default) show all defects
+ - authored - all uncommitted defects
+ - staged - all staged defects
+ - touched - all defects in files that have been touched
+
+Usage:
+------
+
+1. Include one or more adapters in your `Gemfile` or as development
+dependencies of your gem. They'll make sure their dependencies (including
+`ruby-appraiser` itself) are taken care of.
+
+```ruby
+gem 'ruby-appraiser-rubocop'
+gem 'ruby-appraiser-reek'
+```
+
+2. Execute the appraiser:
+
+```sh
+bundle exec ruby-appraiser --mode=authored reek rubocop
+```
+
+The script will exit 0 IFF there are no matching defects from any of your
+coverage tools. The tools themselves will respect any project-wide settings or
+config files.
+
+```
+$ bundle exec ruby-appraiser --help
+Usage: ruby-appraiser [inspector...] [options]
+    -v, --[no-]verbose        Run verbosely
+        --list                List available adapters
+        --silent              Silence output
+        --mode=MODE           Set the mode. [staged,authored,touched,all]
+        --git-hook            Output a git hook with current comand to STDOUT
+        --all                 Run all available adapters.
+```
+
+Contributing:
+-------------
+
+1. Write an adapter! Take a look at the existing adapters for help.
+
+```ruby
+class Foo < RubyAppraiser::Adapter
+  def appraise
+    # ...
+    add_defect( file, line, description )
+    # ...
+  end
+end
+```
+
+License
+-------
+See [LICENSE][]
+
+[LICENSE]: LICENSE.md
+[rubocop]: https://github.com/bbatslov/rubocop
+[reek]: https://github.com/troessner/reek
+[flog]: https://github.com/seattlerb/flog

data/Rakefile

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require 'bundler/gem_tasks'

data/bin/ruby-appraiser

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$LOAD_PATH.unshift(File.dirname(File.realpath(__FILE__)) + '/../lib')
+
+require 'ruby-appraiser'
+require 'benchmark'
+
+cli = RubyAppraiser::CLI.new
+success = nil
+
+time = Benchmark::realtime do
+  success = cli.run
+end
+
+puts "Finished in #{time} seconds" if cli.options[:verbose]
+exit(success ? 0 : 1)

data/lib/ruby-appraiser/adapter/line-length.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'ruby-appraiser'
+
+class RubyAppraiser::Adapter::LineLength < RubyAppraiser::Adapter
+  def appraise
+    source_files.each do |source_file|
+      File.open(source_file) do |source|
+        source.lines.each_with_index do |line, number|
+          line_length = line.chomp.length
+          if line_length > 80
+            add_defect(source_file, number,
+                       "Line too long [#{line_length}/80]")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby-appraiser/adapter.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+require 'set'
+require 'forwardable'
+
+class RubyAppraiser::Adapter
+  class << self
+    def inherited(base)
+      registry << base
+    end
+
+    def registry
+      @registry ||= Set.new
+    end
+
+    def adapter_type(type = nil)
+      @adapter_type = type.to_s unless type.nil?
+
+      @adapter_type or
+        self.name.split('::').last.
+          sub(/Adapter$/, '').
+          gsub(/[A-Z]+/, '-\0').
+          sub(/^-/, '').
+          downcase
+    end
+
+    def find(query)
+      registry.detect do |adapter|
+        adapter.adapter_type == query
+      end
+    end
+
+    def get(query)
+      find(query) or
+        attempt_require_adapter(query, "ruby-appraiser/adapter/#{query}") or
+        attempt_require_adapter(query, "ruby-appraiser/#{query}") or
+        attempt_require_adapter(query, "ruby-appraiser-#{query}")
+    end
+
+    def all
+      # load relevant gems
+      scanner_pattern = /^(ruby-appraiser-([a-zA-Z0-9_\-]+))/
+      (`gem list --local`).scan(scanner_pattern) do |gem_name, adapter_type|
+        attempt_require_adapter(adapter_type, gem_name)
+      end
+
+      # look in the adapter directory
+      Dir::glob(File::expand_path('../adapter/*.rb', __FILE__)) do |filepath|
+        require filepath
+      end
+
+      # return the registry
+      registry
+    end
+
+    def attempt_require_adapter(name, path)
+      require path and find(name)
+    rescue LoadError
+      false
+    end
+
+    def find!(query)
+      find(query) or raise ArgumentError, "Adapter '#{query}' not found."
+    end
+  end
+
+  def initialize(appraisal, options)
+    @appraisal = appraisal
+    @options = options.dup
+  end
+
+  def appraise
+    raise NotImplementedError,
+          "#{self.class.name} does not implement appraise."
+  end
+
+  extend Forwardable
+
+  def_delegators :@appraisal, :source_files,
+                              :project_root,
+                              :relative_path,
+                              :add_defect,
+                              :authored_lines,
+                              :touched_files,
+                              :relevant_files,
+                              :relevant_lines
+end
+

data/lib/ruby-appraiser/appraisal.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+class RubyAppraiser
+  class Appraisal
+    def initialize(options = {})
+      @options = options.dup.freeze
+    end
+
+    def mode
+      @options.fetch(:mode) { 'all' }
+    end
+
+    def options
+      @options.dup
+    end
+
+    def run!
+      appraisers.each do |appraiser|
+        appraiser.appraise
+      end unless relevant_files.empty?
+
+      @has_run = true
+    end
+
+    def success?
+      run! unless @has_run
+
+      defects.empty?
+    end
+
+    def defects
+      @defects ||= Set.new
+    end
+
+    def adapters
+      @adapters ||= Set.new
+    end
+
+    def appraisers
+      adapters.map do |adapter|
+        adapter.new(self, options)
+      end
+    end
+
+    def add_adapter(name)
+      Adapter::get(name).tap do |adapter|
+        adapter and self.adapters << adapter
+      end
+    end
+
+    def source_files
+      Dir::glob(File::expand_path('**/*', project_root)).select do |filepath|
+        File::file? filepath and RubyAppraiser::rubytype? filepath
+      end.map { |path| relative_path path }
+    end
+
+    def add_defect(defect, *args)
+      unless defect.kind_of? Defect
+        defect = Defect.new(defect, *args)
+      end
+      defects << defect if match?(defect.location)
+    end
+
+    def to_s
+      defects.to_a.sort.map(&:to_s).join($/)
+    end
+
+    def summary
+      "#{defects.count} defects detected."
+    end
+
+    def project_root
+      @project_root ||= (`git rev-parse --show-toplevel`).chomp
+    end
+
+    def relative_path(path)
+      full_path = File::expand_path(path, project_root)
+      full_path[(project_root.length + 1)..-1]
+    end
+
+    protected
+
+    def match?(location)
+      file, line = *location
+      relevant_lines[file].include? line
+    end
+
+    def relevant_files
+      relevant_lines.keys
+    end
+
+    def relevant_lines
+      case mode
+      when 'staged'   then staged_authored_lines
+      when 'authored' then authored_lines
+      when 'touched'  then all_lines_in touched_files
+      when 'all'      then all_lines_in source_files
+      else            raise ArgumentError, "Unsupported mode #{mode}."
+      end
+    end
+
+    # return a hash.
+    # key is a filename
+    # value is a truebot
+    def all_lines_in(files)
+      infinite_set = (0 .. (1.0 / 0))
+      files.reduce(Hash.new { [] }) do |memo, file|
+        memo.merge!(file => infinite_set)
+      end
+    end
+
+    def touched_files
+      @touched_files ||= authored_lines.keys
+    end
+
+    def authored_lines
+      @authored_lines ||=
+        RubyAppraiser::Git::authored_lines
+    end
+
+    def staged_authored_lines
+      @staged_authored_lines ||=
+        RubyAppraiser::Git::authored_lines(staged: true)
+    end
+  end
+end

data/lib/ruby-appraiser/cli.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+require 'ruby-appraiser'
+require 'optparse'
+require 'set'
+
+class RubyAppraiser
+  class CLI
+    def initialize(args = ARGV)
+      @argv = ARGV.dup
+      args = @argv.dup # needed for --git-hook
+      @options = {}
+      adapters = Set.new
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{File::basename($0)} [inspector...] [options]"
+        opts.on('-v', '--[no-]verbose', 'Run verbosely') do |verbose|
+          @options[:verbose] = verbose
+        end
+        opts.on('--list', 'List available adapters') do |list|
+          puts available_adapters
+          exit 1
+        end
+        opts.on('--silent', 'Silence output') do |silent|
+          @options[:silent] = true
+        end
+        opts.on('--mode=MODE',
+                'Set the mode. ' +
+                '[staged,authored,touched,all]') do |mode|
+          @options[:mode] = mode
+        end
+        opts.on('--git-hook', 
+                'Output a git hook with current comand to STDOUT') do
+          command = $0
+          if (`which #{File::basename(command)}`).chomp == command
+            command = File::basename(command)
+          end
+          be = 'bundle exec'
+          hook_args = @argv.select { |arg| arg != '--git-hook' }
+
+          indented_git_hook = <<-EOGITHOOK
+            #!/bin/bash
+            echo -e "\\033[0;36mRuby Appraiser: running\\033[0m"
+
+            bundle exec #{command} #{hook_args.join(' ')}
+
+            result_code=$?
+            if [ $result_code -gt "0" ]; then
+              echo -en "\\033[0;31m" # RED
+              echo "[✘] Ruby Appraiser found newly-created defects and "
+              echo "    has blocked your commit."
+              echo "    Fix the defects and commit again."
+              echo "    To bypass, commit again with --no-verify."
+              echo -en "\\033[0m" # RESET
+              exit $result_code
+            else
+              echo -en "\\033[0;32m" # GREEN
+              echo "[✔] Ruby Appraiser ok"
+              echo -en "\\033[0m" #RESET
+            fi
+          EOGITHOOK
+
+          indent = indented_git_hook.scan(/^\s*/).map(&:length).min
+          puts indented_git_hook.lines.map {|l| l[indent..-1]}.join
+          exit 1
+        end
+        opts.on('--all', 'Run all available adapters.') do
+          adapters += available_adapters
+        end
+      end.parse!(args)
+
+      @appraisal = RubyAppraiser::Appraisal.new(options)
+      adapters += args
+      adapters.each do |adapter|
+        @appraisal.add_adapter(adapter) or
+          raise "Unknown adapter '#{adapter}'"
+      end
+      Dir::chdir((`git rev-parse --show-toplevel`).chomp)
+    end
+
+    def options
+      @options.dup
+    end
+
+    def run
+      @appraisal.run!
+      puts @appraisal unless @options[:silent]
+      puts @appraisal.summary if @options[:verbose]
+      @appraisal.success?
+    rescue Object
+      puts "#{@appraisal.class.name} caught #{$!} at #{$!.backtrace.first}."
+    end
+
+    def available_adapters
+      @available_adapters ||= RubyAppraiser::Adapter::all.map(&:adapter_type)
+    end
+  end
+end

data/lib/ruby-appraiser/defect.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+class RubyAppraiser
+  class Defect
+    def initialize(file, line, description)
+      @location = [file, line.to_i].freeze
+      @description = description.dup.freeze
+    end
+
+    attr_reader :location
+    attr_reader :description
+
+    def file
+      @location[0]
+    end
+
+    def line
+      @location[1]
+    end
+
+    def to_s
+      "#{file}:#{line} #{description}"
+    end
+
+    def ==(other)
+      self.to_s == other.to_s
+    end
+
+    def <=>(other)
+      self.to_s <=> other.to_s
+    end
+  end
+end

data/lib/ruby-appraiser/git.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+class RubyAppraiser
+  module Git
+    extend self
+
+    def authored_lines(options = {})
+      diff_command = ['git diff']
+      if options[:range]
+        diff_command << options[:range]
+      else
+        diff_command << (options[:staged] ? '--cached' : 'HEAD')
+      end
+
+      diff_output = IO.popen(diff_command.join(' ')) { |io| io.read }
+
+      current_path, current_line = nil, nil
+      authored_lines = Hash.new { |hash, key| hash[key] = [] }
+
+      diff_output.lines do |line|
+        case line
+        when /^---/ then next
+        when /^\+\+\+ (?:b\/)?(.*)/
+          current_path = Regexp::last_match(1)
+        when /-[0-9]+(?:,[0-9]+)? \+([0-9]+)((,[0-9]+)?)/
+          current_line = Regexp::last_match(1).to_i
+        else
+          next if line.start_with? '-'
+          authored_lines[current_path] << current_line if line[0] == '+'
+          current_line += 1 unless current_line.nil?
+        end
+      end
+
+      authored_lines.default_proc = Proc.new { [] }
+      authored_lines.reject do |filepath, lines|
+        not File::file? filepath or
+        not RubyAppraiser::rubytype? filepath
+      end
+    end
+  end
+end

data/lib/ruby-appraiser/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+class RubyAppraiser
+  VERSION = '1.0.0'
+end

data/lib/ruby-appraiser.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'ruby-appraiser/version'
+
+class RubyAppraiser
+
+  autoload :Adapter,    'ruby-appraiser/adapter'
+  autoload :Appraisal,  'ruby-appraiser/appraisal'
+  autoload :CLI,        'ruby-appraiser/cli'
+  autoload :Defect,     'ruby-appraiser/defect'
+  autoload :Git,        'ruby-appraiser/git'
+
+  def initialize(options)
+    @options = options.dup
+  end
+
+  def options
+    @options.dup
+  end
+
+
+  def appraisal
+    unless @appraisal
+      @appraisal = Appraisal.new(options)
+
+      unless @appraisal.relevant_files.empty?
+        appraisers(@appraisal).each(&:appraise)
+      end
+    end
+
+    @appraisal
+  end
+
+  class << self
+    def rubytypes
+      %w(
+        *.rb
+        *.gemspec
+        Capfile
+        Gemfile
+        Rakefile
+      )
+    end
+
+    def rubytype?(filepath)
+      # true if the extension matches
+      filename = File::basename(filepath)
+      return true if rubytypes.any? do |rubytype|
+        File::fnmatch(rubytype, filename)
+      end
+
+      # true if file has a ruby shebang
+      begin
+        return true if File.open(filepath) do |file|
+          file.read(20).chomp =~ /\A#\!.+ruby/
+        end
+      rescue Errno::ENOENT
+      rescue ArgumentError # invalid byte sequence
+      end
+
+      false
+    end
+  end
+end

data/ruby-appraiser.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby-appraiser/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'ruby-appraiser'
+  gem.version       = RubyAppraiser::VERSION
+  gem.authors       = ['Ryan Biesemeyer']
+  gem.email         = ['ryan@simplymeasured.com']
+  gem.description   = 'Run multiple code-quality tools against staged changes'
+  gem.summary       = 'A Common interface/executor for code quality tools'
+  gem.homepage      = 'https://github.com/simplymeasured'
+
+  gem.files         = `git ls-files | grep -v '^ruby-appraiser-'`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: ruby-appraiser
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Biesemeyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-01 00:00:00.000000000 Z
+dependencies: []
+description: Run multiple code-quality tools against staged changes
+email:
+- ryan@simplymeasured.com
+executables:
+- ruby-appraiser
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE-APACHE.md
+- LICENSE-MIT.md
+- LICENSE.md
+- README.md
+- Rakefile
+- bin/ruby-appraiser
+- lib/ruby-appraiser.rb
+- lib/ruby-appraiser/adapter.rb
+- lib/ruby-appraiser/adapter/line-length.rb
+- lib/ruby-appraiser/appraisal.rb
+- lib/ruby-appraiser/cli.rb
+- lib/ruby-appraiser/defect.rb
+- lib/ruby-appraiser/git.rb
+- lib/ruby-appraiser/version.rb
+- ruby-appraiser.gemspec
+homepage: https://github.com/simplymeasured
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A Common interface/executor for code quality tools
+test_files: []
+has_rdoc: