panache 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in vanilla_gem.gemspec
+gemspec

data/README.md

@@ -0,0 +1,75 @@
+Panache
+=======
+
+Panache is a simple way to create style checkers for various languages. It does simple parsing of source
+files and then applies user-specified rules to detect style violations.
+
+Code parsing is *not* full lexing; it is an intentional design goal to limit code introspection in order to
+avoid overlap with tasks best left to language-specific linters and static analysis tools. To that end, the
+code parsing is done with Textpow, which uses TextMate syntax files and annotates source with tags (so that we
+can detect things like comments, string literals, etc). Then rules are applied based on Textpow tags.
+
+Usage
+-----
+
+```bash
+$ gem install panache
+$ panache [-s panache_styles] code_path [code_path ...]
+```
+
+`panache_styles` is the directory where your style files are stored and each `code_path` is a file
+or directory to check.
+
+One of the most useful ways to use Panache is as a pre-commit or post-commit hook in your repository.
+For example, to check each file that was modified after you commit your git post-commit hook could look
+like:
+
+```bash
+#!/bin/sh
+
+panache -s ~/repos/panache_styles $(git show --pretty="format:" --name-only)
+```
+
+Creating new styles
+-------------------
+
+To create a new style, you will need a Textmate syntax file and a rules file written in the Panache DSL.
+
+The easiest way to get Textmate syntax files is to copy them out of a Textmate installation on your computer.
+They should have the path
+
+    /Applications/TextMate.app/Contents/SharedSupport/Bundles/<your-language>.tmbundle/Syntaxes/<your-language>.plist
+
+This is a binary plist file, and Panache requires it to be in the text XML format; you can convert it like this:
+
+    $ plutil -convert xml1 <your-language>.plist
+
+(Of course, you'll want to copy the plist file into the project directory to avoid corrupting your TextMate
+installation). You can download other, more exotic TextMate syntax files from the [TextMate subversion
+repository](http://svn.textmate.org/trunk/Bundles/).
+
+Next, you need to write your rules file.
+
+TODO(caleb): Update steps below.
+
+1. Make a file called `<language>_style.rb`, where `<language>` is the type of file you want to check.
+2. Use the DSL implemented in this file to write your style.
+   * The regex you give to Panache::Style#create matches the filenames you wish to check.
+   * Each rule consists of a regex and a message to indicate what the violation was.
+   * The regex may contain a match. The offset of the beginning of this match will be used to indicate
+     exactly where a style violation occurred.
+
+Dumb example:
+
+    Panache::Style.create(/\.txt$/) do
+      rule /(q)/, "The letter 'q' is not allowed in text files."
+    end
+
+Output formats
+--------------
+
+TODO(caleb) Implement these. Ideas:
+
+* Colorized console output
+* Summary output suitable for consumption by other tools (# of tests / # of failures)
+* Markdown? (For automatic CR bot)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/panache

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require "panache"
+
+# TODO(caleb): multiple output options.
+
+def usage
+  <<-EOF
+Usage:
+  panache [-s styles_directory] code_path [code_path ...]
+
+The styles_directory may also be specified with the PANACHE_STYLES environment variable.
+  EOF
+end
+
+style_directory = nil
+code_paths = []
+ARGV.each_with_index do |option, index|
+  next if ARGV[index - 1] == "-s"
+  if option == "-s"
+    style_directory = ARGV[index + 1]
+    next
+  end
+  code_paths << option
+end
+style_directory ||= ENV["PANACHE_STYLES"]
+
+if style_directory.nil? || code_paths.empty?
+  puts usage
+  exit 1
+end
+
+Panache.load_styles(style_directory)
+results = {}
+code_paths.each { |path| results.merge! Panache.check_path(path) }
+Panache::Printer.new(results).print_results

data/lib/panache/version.rb

@@ -0,0 +1,3 @@
+module Panache
+  VERSION = "0.1.0"
+end

data/lib/panache.rb

@@ -0,0 +1,157 @@
+require "find"
+require "colorize"
+
+module Panache
+  @@styles = []
+
+  DEFAULT_TAB_SPACES = 2
+  DEFAULT_STYLE_PATH = File.expand_path("~/repos/panache/panache_styles")
+  Violation = Struct.new :line_number, :line, :offset, :style, :rule
+
+  class Rule
+    attr_reader :message
+    def initialize(regexes, message)
+      @regexes = regexes
+      @message = message
+    end
+
+    def check(line)
+      offset = 0
+      violations = []
+      @regexes.each do |regex|
+        while (match = regex.match(line, offset))
+          # If the match size is 1, then the user did not provide any captures in their regex and we only know
+          # that there is >= 1 violation of the rule in this line.
+          if match.size == 1
+            return [Violation.new(nil, line, nil, nil, self)]
+          end
+          offset = match.offset(1)[0]
+          violations << Violation.new(nil, line, offset, nil, self)
+          offset += 1
+        end
+      end
+      violations
+    end
+  end
+
+  class Style
+    def initialize(file_regex)
+      @tab_spaces = DEFAULT_TAB_SPACES
+      @file_regex = file_regex
+      @rules = []
+    end
+
+    def self.create(file_regex, &block)
+      style = Style.new(file_regex)
+      style.instance_eval &block
+      Panache.add_style style
+    end
+
+    def spaces_per_tab(n)
+      @tab_spaces = n
+    end
+
+    def rule(regex, message)
+      if regex.is_a? Array
+        @rules << Rule.new(regex, message)
+      else
+        @rules << Rule.new([regex], message)
+      end
+    end
+
+    def checks?(file_name)
+      file_name =~ @file_regex
+    end
+
+    def check(line)
+      # Replace tabs with spaces according to the specified conversion.
+      line.gsub!("\t", " " * @tab_spaces)
+      @rules.flat_map do |rule|
+        violations = rule.check(line)
+        violations.each { |v| v.style = self }
+      end
+    end
+  end
+
+  def self.add_style(style)
+    @@styles << style
+  end
+
+  # Load all Panache styles (files matching *_style.rb) from a given directory.
+  def self.load_styles(directory = DEFAULT_STYLE_PATH)
+    raise "Need a directory of Panache styles" unless File.directory?(directory)
+    style_files = Dir.glob(File.join(directory, "*_style.rb"))
+    raise "No Panache styles found in #{directory}" if style_files.empty?
+    style_files.each do |style|
+      puts "Loading #{style}...".green
+      load style
+    end
+    puts "Loaded #{style_files.size} style#{"s" if style_files.size != 1}.".green
+  end
+
+  # Check a given file against loaded styles.
+  def self.check_file(path)
+    styles = @@styles.select { |style| style.checks? path }
+    line_number = 0
+    File.open(path).each_with_index.flat_map do |line, line_number|
+      line_number += 1
+      styles.flat_map { |style| style.check(line) }.each { |violation| violation.line_number = line_number }
+    end
+  end
+
+  # Check a file or directory
+  def self.check_path(path)
+    if File.directory? path
+      files = Find.find(path).select { |sub_path| File.file? sub_path }
+    elsif File.file? path
+      files = [path]
+    else
+      raise "Bad path: #{path}."
+    end
+    puts "Checking #{path}".green
+    results = {}
+    files.each { |file| results[file] = Panache.check_file file }
+    results
+  end
+
+  class Printer
+    def initialize(results, output_type = :normal)
+      @results = results
+      @output_type = output_type
+    end
+
+    def print_results
+      case @output_type
+      when :normal then print_normal
+      else print normal
+      end
+    end
+
+    private
+
+    def print_normal
+      violations_found = 0
+      bad_files = 0
+      @results.each do |file, result|
+        next if result.empty?
+        puts "Style violations in #{file}:".red
+        bad_files += 1
+        result.each do |violation|
+          violations_found += 1
+          puts "Line #{violation.line_number}: #{violation.rule.message}".blue
+          puts violation.line
+          puts " " * violation.offset + "^".blue if violation.offset
+        end
+      end
+      if violations_found.zero?
+        puts "No violations found.".green
+      else
+        puts "Found #{plural(violations_found, "violation")} in #{plural(bad_files, "bad file")}.".red
+      end
+    end
+  end
+end
+
+def plural(amount, thing)
+  "#{amount} #{thing}#{"s" unless amount == 1}"
+end

data/panache.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "panache/version"
+
+Gem::Specification.new do |s|
+  s.name        = "panache"
+  s.version     = Panache::VERSION
+  s.authors     = ["Caleb Spare", "Daniel MacDougall"]
+  s.email       = ["caleb@ooyala.com", "dmac@ooyala.com"]
+  s.homepage    = ""
+  s.summary     = %q{Create style checkers for various languages}
+  s.description = <<-EOF
+Panache is a simple way to create style checkers for various languages.
+It does simple parsing of source files and then applies user-specified rules to detect style violations.
+                  EOF
+
+  s.rubyforge_project = "panache"
+  s.required_ruby_version = ">= 1.9.2"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "colorize"
+end

data/post-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+export RBENV_VERSION="1.9.2-p290"
+panache -s ~/repos/panache_styles $(git show --pretty="format:" --name-only)

data/test/test_file.rb

@@ -0,0 +1,17 @@
+# This is a simple test file.
+#It has issues.
+
+def fooBar
+	puts "I'm just going to return an extremely long string here...maybe nobody will call me out on this blatant style violation!";
+	hello;
+end
+
+[1,2,3,4,5].each do |i| puts i end
+(0..10).times {|i| puts i }
+asDf = 3
+
+a =<<-EOS
+a
+b
+c
+EOS

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: panache
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Caleb Spare
+- Daniel MacDougall
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-10 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: &2164368800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2164368800
+description: ! 'Panache is a simple way to create style checkers for various languages.
+
+  It does simple parsing of source files and then applies user-specified rules to
+  detect style violations.
+
+'
+email:
+- caleb@ooyala.com
+- dmac@ooyala.com
+executables:
+- panache
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/panache
+- lib/panache.rb
+- lib/panache/version.rb
+- panache.gemspec
+- post-commit
+- test/test_file.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: panache
+rubygems_version: 1.8.7
+signing_key: 
+specification_version: 3
+summary: Create style checkers for various languages
+test_files:
+- test/test_file.rb