license_header 0.0.1

data/README.md

@@ -0,0 +1,29 @@
+# LicenseHeader
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'license_header'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install license_header
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/bin/license_header

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+
+require 'license_header'
+require 'optparse'
+require 'highline/import'
+
+command = nil
+options = { :exceptions => [] }
+
+@prompt = true
+def getYyn(text)
+  if @prompt
+    response = ask("#{text} (Y/y/n) ") { |q| 
+      q.overwrite = true
+      q.echo = true
+      q.character = true
+      q.validate { |r| r =~ /^[Yyn]$/ } 
+    }
+    if response == 'Y'
+      @prompt = false
+    end
+    return response.downcase == 'y'
+  else
+    return true
+  end
+end
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename $0} <action> [options] <filespec>"
+
+  opts.separator 'Actions:'
+
+  opts.on('-a', '--audit', "Print a list of files needing license updates") do
+    command = :audit
+  end
+
+  opts.on('-u', '--update', "Update files requiring license headers") do
+    command = :update
+  end
+
+  opts.on('-r', '--remove', "Remove license headers from files") do
+    command = :remove
+  end
+
+  opts.separator 'Common options:'
+
+  opts.on('-f FILE', '--header-file=FILE', "File containing header text") do |arg|
+    options[:header] = arg
+  end
+
+  opts.on('-x MASK', '--exclude=MASK', "Exclude pattern") do |arg|
+    pattern = Regexp.escape(arg).gsub('\*','.*?')
+    re = /^#{pattern}$/i
+    options[:exceptions] << re
+  end
+
+  opts.on('-y', '--yes', "Assume yes reponses to all prompts") do
+    @prompt = false
+  end
+
+  opts.on('-v', '--verbose', "Run verbosely") do
+    options[:verbose] = true
+  end
+
+  opts.on_tail('-h', '--help', "Show this message") do
+    puts opts
+    exit
+  end
+end
+opts.parse!
+
+if command.nil? or options[:header].nil? or ARGV.empty?
+  puts opts
+  exit
+end
+
+targets = ARGV.collect do |spec|
+  File.directory?(spec) ? File.join(spec,"**","*") : spec
+end
+
+auditor = LicenseHeader::Auditor.new(options)
+files = auditor.audit(*targets)
+invalid = (files[:missing]+files[:invalid]).sort
+present = (files[:present]+files[:valid]).sort
+case command
+when :audit
+  $stderr.puts "#{files[:valid].length} files have correct headers"
+  $stderr.puts files[:valid].join("\n") if options[:verbose]
+  $stderr.puts "#{files[:missing].length} files have missing headers"
+  $stderr.puts files[:missing].join("\n") if options[:verbose]
+  $stderr.puts "#{files[:invalid].length} files have invalid headers"
+  $stderr.puts files[:invalid].join("\n") if options[:verbose]
+when :update
+  $stderr.puts "#{invalid.length} files have missing or incorrect headers"
+  auditor.process_files(:update, *  invalid) do |file, format|
+    response = getYyn("Update header in #{file}?")
+    $stderr.puts "Updating #{file}..." if response
+    response
+  end
+when :remove
+  $stderr.puts "#{present.length} files have headers"
+  auditor.process_files(:remove, *present) do |file, format|
+    response = getYyn("Remove header from #{file}?")
+    $stderr.puts "Cleaning up #{file}..." if response
+    response
+  end
+end

data/lib/license_header/auditor.rb

@@ -0,0 +1,142 @@
+require 'fileutils'
+
+# Module to assist in making sure that all files have the right license
+# block as a header.
+
+module LicenseHeader
+  # For each language you can define three variables
+  #
+  # :pre will be prepended to the header
+  # :each will be prepended to each line of the header
+  # :post will be appended to the end of the file
+  #
+  # Only :each is required; if the other two are not provided they will be
+  # ignored
+  LANGUAGE_SYNTAX = { 
+    :css        => { :pre => '/* ',  :each => ' * ', :post => '*/',  :exts => %w(.css .scss)        },
+    :erb        => { :pre => '<%#',  :each => '',    :post => '%>',  :exts => %w(.erb)              },
+    :haml       => { :pre => '-#',   :each => '  ',                  :exts => %w(.haml)             },
+    :html       => { :pre => '<!--', :each => '',    :post => '-->', :exts => %w(.html)             },
+    :javascript => { :pre => '/* ',  :each => ' * ', :post => '*/',  :exts => %w(.js .json)         },
+    :ruby       => {                 :each => '# ',                  :exts => %w(.rb .rake .coffee) },
+  }
+
+  class Auditor
+    attr_accessor :exceptions, :header, :verbose
+
+    # Should set some sensible defaults here for license location, file
+    # mappings, etc
+    def initialize(configuration)
+      @verbose = configuration[:verbose]
+      @header = configuration[:header]
+      @exceptions = configuration[:exceptions]
+      initialize_headers
+    end
+
+    # Create a list of all files grouped by type and return the map
+    def audit(*patterns)
+      result = Hash.new { |h,k| h[k] = [] }
+
+      Dir.glob(patterns).each do |entry|
+        # Skip directories and files that match the exceptions
+        next if File.directory?(entry)
+        if @exceptions.any? { |ex| ex.match(entry) }
+          $stderr.puts "Skipping #{entry}" if @verbose
+          next
+        end
+
+        # Now to get down to business
+        format = determine_format(entry)
+        result[evaluate_header(entry, format)] << entry
+      end
+
+      return result
+    end
+
+    def evaluate_header(path, format)
+      if format.nil? or format[:header].nil?
+        :not_applicable
+      else
+        file_content = read_file(path)
+        header_content = format[:header]
+        index = file_content.find_index { |l| l =~ /---  [E]ND AVALON LICENSE BLOCK  ---/ }
+        if index.nil?
+          :missing
+        else
+          file_heading = file_content[0, header_content.size]
+          if file_heading.eql? header_content
+            :valid
+          else
+            :present
+          end
+        end
+      end
+    end
+
+    def process_files(action, *files)
+      files.each do |file|
+        format = determine_format(file)
+        source_file = read_file(file)
+        confirm = block_given? ? yield(file) : true
+        if confirm and self.send(:"#{action.to_s}_license!", source_file, format)
+          write_file(file, source_file)
+        end
+      end
+    end
+
+    def update_license!(source_file, format)
+      remove_license!(source_file, format)
+      header_content = format[:header]
+      header_content.reverse.each { |line| source_file.insert(0, line) }
+      return true
+    end
+
+    def remove_license!(source_file, format)
+      end_of_license = source_file.find_index { |l| l =~ /---  [E]ND AVALON LICENSE BLOCK  ---/ }
+      if end_of_license.nil?
+        return false
+      else
+        extra_lines = format[:post].nil? ? 1 : 2
+        source_file.shift(end_of_license+extra_lines+1)
+        return true
+      end
+    end
+
+    private
+
+    def determine_format(file)
+      @headers.values.find { |syntax| syntax[:exts].include?(File.extname(file)) }
+    end
+
+    def read_file(file)
+      File.read(file).chomp.split(/\n/)
+    end
+
+    def write_file(file, content)
+      File.open("#{file}.tmp", "w") { |tmpfile| tmpfile.puts(content.join("\n")) }
+      FileUtils.rm(file)
+      FileUtils.mv("#{file}.tmp", file)
+    end
+
+    # Here we need to take the stock header and create two different versions -
+    # one for Ruby based content using the # notation and another for
+    # Javascript that uses /* */ syntax
+    def initialize_headers
+      @headers = LANGUAGE_SYNTAX.clone
+      base = File.read(@header)
+      # Break each line down so we can do easy manipulation to create our new
+      # versions
+      license_terms = base.split(/\n/)
+
+      @headers.each_pair do |lang,syntax|
+        syntax[:header] = []
+        syntax[:header] << syntax[:pre] unless syntax[:pre].nil?
+        syntax[:header] << "#{syntax[:each]} --- BEGIN AVALON LICENSE BLOCK ---"
+        syntax[:header] += license_terms.collect {|line| syntax[:each] + line }
+        syntax[:header] << "#{syntax[:each]} ---  #{'E'}ND AVALON LICENSE BLOCK  ---"
+        syntax[:header] << syntax[:post] unless syntax[:post].nil?
+        syntax[:header] << ""
+      end
+    end
+  end
+end

data/lib/license_header/version.rb

@@ -0,0 +1,3 @@
+module LicenseHeader
+  VERSION = "0.0.1"
+end

data/lib/license_header.rb

@@ -0,0 +1,6 @@
+require "license_header/version"
+require "license_header/auditor"
+
+module LicenseHeader
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: license_header
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nathan Rogers
+- Michael Klein
+- Chris Colvard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: License header block auditing/updating
+email:
+- rogersna@indiana.edu
+executables:
+- license_header
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/license_header/auditor.rb
+- lib/license_header/version.rb
+- lib/license_header.rb
+- bin/license_header
+- README.md
+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: '0'
+      segments:
+      - 0
+      hash: 3735959797291095628
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3735959797291095628
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: This gem will assist in making sure that all files have the right license
+  block as a header.
+test_files: []