341 lines
10 KiB
Ruby
341 lines
10 KiB
Ruby
=begin
|
|
--------------------------------------------------------------------------------
|
|
|
|
Create a copy of the source files, with licensing information inserted.
|
|
|
|
--------------------------------------------------------------------------------
|
|
2010-01-26 initial version J.Blake
|
|
--------------------------------------------------------------------------------
|
|
=end
|
|
|
|
require 'date'
|
|
require 'fileutils'
|
|
|
|
class LicenserStats
|
|
attr_reader :substitutions
|
|
attr_reader :missing_tags
|
|
attr_reader :file_count
|
|
attr_reader :dir_count
|
|
|
|
# ------------------------------------------------------------------------------------
|
|
private
|
|
# ------------------------------------------------------------------------------------
|
|
#
|
|
def which_match(filename)
|
|
@file_matchers.each do |matcher|
|
|
return matcher if File.fnmatch(matcher, filename)
|
|
end
|
|
raise("filename matches no matchers!: #{filename}")
|
|
end
|
|
|
|
# ------------------------------------------------------------------------------------
|
|
public
|
|
# ------------------------------------------------------------------------------------
|
|
|
|
def initialize(file_matchers, full)
|
|
@file_matchers = file_matchers
|
|
|
|
@full = full
|
|
|
|
# keep track of how many substitutions for all file types
|
|
@substitutions = Hash.new()
|
|
file_matchers.each do |matcher|
|
|
@substitutions[matcher] = 0
|
|
end
|
|
|
|
# keep track of missing tags, only in file types that have missing tags
|
|
@missing_tags = Hash.new(0)
|
|
|
|
# keep track of how many files are copied
|
|
@file_count = 0
|
|
|
|
#keep track of how many directories are copied
|
|
@dir_count = 0
|
|
end
|
|
|
|
def enter_without_mods(path)
|
|
@dir_count += 1
|
|
puts "Entering, no mods: #{path}" if @full
|
|
end
|
|
|
|
def enter_with_mods(path)
|
|
@dir_count += 1
|
|
puts "Entering, with mods: #{path}" if @full
|
|
end
|
|
|
|
def record_copy_without_mods(filename)
|
|
@file_count += 1
|
|
puts " Copying, without mods: #{filename}" if @full
|
|
end
|
|
|
|
def record_copy_with_mods(filename)
|
|
@file_count += 1
|
|
puts " Copying, with mods: #{filename}" if @full
|
|
end
|
|
|
|
def record_substitution(filename)
|
|
puts " Substituted license text into #{filename}" if @full
|
|
matcher = which_match(filename)
|
|
@substitutions[matcher] += 1
|
|
end
|
|
|
|
def record_missing_tag(filename, source_path)
|
|
puts "WARN: Found no license tag in #{source_path}"
|
|
matcher = which_match(filename)
|
|
@missing_tags[matcher] += 1
|
|
end
|
|
end
|
|
|
|
class Licenser
|
|
|
|
MAGIC_STRING = '$This file is distributed under the terms of the license in /doc/license.txt$'
|
|
|
|
# ------------------------------------------------------------------------------------
|
|
private
|
|
# ------------------------------------------------------------------------------------
|
|
#
|
|
# Prepare the license as an array of lines of text,
|
|
# with the current year substituted in for ${year}
|
|
#
|
|
def prepare_license_text(license_file)
|
|
year_string = DateTime.now.year.to_s
|
|
text = []
|
|
File.open(license_file) do |file|
|
|
file.each do |line|
|
|
text << line.gsub('${year}', year_string)
|
|
end
|
|
end
|
|
return text
|
|
end
|
|
|
|
# Prepare the license-applicable directories as absolute paths.
|
|
#
|
|
def prepare_license_dir_paths(source_dir, license_dirs)
|
|
paths = []
|
|
license_dirs.each do |dir|
|
|
paths << "#{source_dir}/#{dir}".gsub('//', '/')
|
|
end
|
|
return paths
|
|
end
|
|
|
|
# Does this filename match any of the patterns?
|
|
#
|
|
def filename_matches_pattern?(filename)
|
|
@file_matchers.each do |pattern|
|
|
return true if File.fnmatch(pattern, filename)
|
|
end
|
|
return false
|
|
end
|
|
|
|
# Recursively copy this directory, without adding license mods to any files,
|
|
# unless we hit one of the licensed directories.
|
|
#
|
|
def copy_dir_without_mods(source_dir, target_dir)
|
|
@stats.enter_without_mods(source_dir)
|
|
Dir.mkdir(target_dir)
|
|
Dir.foreach(source_dir) do |filename|
|
|
source_path = "#{source_dir}/#{filename}"
|
|
target_path = "#{target_dir}/#{filename}"
|
|
|
|
if filename == '.'
|
|
elsif filename == '..'
|
|
elsif @license_dir_paths.include?(source_path)
|
|
copy_dir_with_mods(source_path, target_path)
|
|
elsif File.directory?(source_path)
|
|
copy_dir_without_mods(source_path, target_path)
|
|
else
|
|
copy_file_without_mods(source_dir, target_dir, filename)
|
|
end
|
|
end
|
|
end
|
|
|
|
# Recursively copy this directory, adding license mods to any suitable files.
|
|
#
|
|
def copy_dir_with_mods(source_dir, target_dir)
|
|
@stats.enter_with_mods(source_dir)
|
|
|
|
Dir.mkdir(target_dir)
|
|
Dir.foreach(source_dir) do |filename|
|
|
source_path = "#{source_dir}/#{filename}"
|
|
target_path = "#{target_dir}/#{filename}"
|
|
|
|
if filename == '.'
|
|
elsif filename == '..'
|
|
elsif File.directory?(source_path)
|
|
copy_dir_with_mods(source_path, target_path)
|
|
elsif filename_matches_pattern?(filename)
|
|
copy_file_with_mods(source_dir, target_dir, filename)
|
|
else
|
|
copy_file_without_mods(source_dir, target_dir, filename)
|
|
end
|
|
end
|
|
end
|
|
|
|
# This file either is not in a licensed directory, or doesn't match any of the
|
|
# file-matching strings
|
|
#
|
|
def copy_file_without_mods(source_dir, target_dir, filename)
|
|
@stats.record_copy_without_mods(filename)
|
|
source_path = "#{source_dir}/#{filename}"
|
|
target_path = "#{target_dir}/#{filename}"
|
|
FileUtils.cp(source_path, target_path)
|
|
end
|
|
|
|
# This file is in a licensed directory, and matches at least one of the
|
|
# file-matching strings. Replace the magic string with the license text.
|
|
#
|
|
def copy_file_with_mods(source_dir, target_dir, filename)
|
|
@stats.record_copy_with_mods(filename)
|
|
source_path = "#{source_dir}/#{filename}"
|
|
target_path = "#{target_dir}/#{filename}"
|
|
found = 0
|
|
File.open(source_path) do |source_file|
|
|
File.open(target_path, "w") do |target_file|
|
|
source_file.each do |line|
|
|
if line.include?(MAGIC_STRING)
|
|
found += 1
|
|
insert_license_text(target_file, line)
|
|
else
|
|
target_file.print line
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if found == 0
|
|
@stats.record_missing_tag(filename, source_path)
|
|
elsif found == 1
|
|
@stats.record_substitution(filename)
|
|
else
|
|
raise("File contains #{found} license lines: #{source_path}")
|
|
end
|
|
end
|
|
|
|
# Figure out the comment characters and write the license text to the file.
|
|
#
|
|
def insert_license_text(target_file, line)
|
|
ends = line.split(MAGIC_STRING)
|
|
if ends.size != 2
|
|
raise ("Can't parse this license line: #{line}")
|
|
end
|
|
|
|
target_file.print "#{ends[0].strip}\n"
|
|
|
|
@license_text.each do |text|
|
|
target_file.print "#{text.rstrip}\n"
|
|
end
|
|
|
|
target_file.print "#{ends[1].strip}\n"
|
|
end
|
|
|
|
# ------------------------------------------------------------------------------------
|
|
public
|
|
# ------------------------------------------------------------------------------------
|
|
|
|
# Setup and get ready to process.
|
|
# * source_dir is a String -- the path to the top level directory to be copied
|
|
# * target_dir is a String -- the path to the top level directory to copy into
|
|
# (must not already exist!)
|
|
# * license_dirs is an array of Strings -- relative paths to the directories that
|
|
# require license mods.
|
|
# * file_matchers
|
|
# * license_file is a String -- the path to the text of the license agreement
|
|
# (with a ${year} token in it)
|
|
# * full_report is a Boolean -- if true, we give a full log instead of just a summary.
|
|
#
|
|
def initialize(source_dir, target_dir, license_dirs, file_matchers, license_file, full_report)
|
|
if !File.exist?(source_dir)
|
|
raise "Source directory does not exist: #{source_dir}"
|
|
end
|
|
|
|
if File.exist?(target_dir)
|
|
raise "Target directory already exists: #{target_dir}"
|
|
end
|
|
|
|
if !File.exist?(license_file)
|
|
raise "Source directory does not exist: #{license_file}"
|
|
end
|
|
|
|
@source_dir = source_dir
|
|
@target_dir = target_dir
|
|
@file_matchers = file_matchers
|
|
|
|
@license_dirs = license_dirs
|
|
@license_dir_paths = prepare_license_dir_paths(source_dir, license_dirs)
|
|
|
|
@license_file = license_file
|
|
@license_text = prepare_license_text(license_file)
|
|
|
|
@full_report = full_report
|
|
@stats = LicenserStats.new(file_matchers, full_report)
|
|
end
|
|
|
|
# Start the recursive copying.
|
|
def process()
|
|
copy_dir_without_mods(@source_dir, @target_dir)
|
|
end
|
|
|
|
# Report the summary statistics
|
|
def report()
|
|
puts "Licenser: run completed at #{DateTime.now.strftime("%H:%M:%S on %b %d, %Y")}"
|
|
puts " copied #{@stats.file_count} files in #{@stats.dir_count} directories."
|
|
puts
|
|
puts 'Substitutions'
|
|
@stats.substitutions.sort.each do |line|
|
|
printf("%5d %s\n", line[1], line[0])
|
|
end
|
|
puts
|
|
puts 'Missing tags'
|
|
@stats.missing_tags.sort.each do |line|
|
|
printf("%5d %s\n", line[1], line[0])
|
|
end
|
|
puts
|
|
puts 'parameters:'
|
|
puts " source_dir = #{@source_dir}"
|
|
puts " target_dir = #{@target_dir}"
|
|
puts " license_dirs = #{@license_dirs.join(', ')}"
|
|
puts " file_matchers = #{@file_matchers.join(', ')}"
|
|
puts " license_file = #{@license_file}"
|
|
puts " full_report = #{@full_report}"
|
|
end
|
|
end
|
|
|
|
# ------------------------------------------------------------------------
|
|
# BOGUS test harness
|
|
# ------------------------------------------------------------------------
|
|
|
|
=begin
|
|
source_dir = '/Vivoweb_Stuff/Testing_licenser/sourceDir'
|
|
target_dir = '/Vivoweb_Stuff/Testing_licenser/targetDir'
|
|
|
|
license_dirs = []
|
|
license_dirs << '/licensed'
|
|
|
|
license_file = '../doc/license.txt'
|
|
=end
|
|
|
|
#=begin
|
|
source_dir = '/Vivoweb_Stuff/Testing_licenser/trunk'
|
|
target_dir = '/Vivoweb_Stuff/Testing_licenser/distribution'
|
|
|
|
license_dirs = []
|
|
license_dirs << '/themes'
|
|
license_dirs << '/vitro-core/webapp'
|
|
license_dirs << '/vitro-core/services'
|
|
|
|
file_matchers = []
|
|
file_matchers << '*.java'
|
|
file_matchers << '*.jsp'
|
|
file_matchers << '*.tld'
|
|
file_matchers << '*.xsl'
|
|
file_matchers << '*.xslt'
|
|
file_matchers << '*.css'
|
|
file_matchers << '*.js'
|
|
file_matchers << 'build.xml'
|
|
|
|
license_file = '/Vivoweb_Stuff/Testing_licenser/trunk/doc/license.txt'
|
|
#=end
|
|
|
|
l = Licenser.new(source_dir, target_dir, license_dirs, file_matchers, license_file, false)
|
|
l.process
|
|
l.report
|