jdzak-cf_case_check 0.1.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg
+coverage
+*.gem

data/History.txt

@@ -0,0 +1,19 @@
+0.1.0 / 2008-12-15
+==================
+* Add support for configurable substitutions for, e.g., application variable 
+  use in references
+* Include 'tem' (along with 'cfm' and 'cfc') in the list of extensions to use
+  when looking for CF source
+* Ensure that source filenames are globbed case-insensitively
+
+0.0.2 / 2008-12-15
+==================
+* Resolve CFCs in the same directory as the source
+
+0.0.1 / 2008-12-14
+==================
+* Fix recursion bug in CaseCheck::exit
+
+0.0.0 / 2008-12-14
+==================
+* Initial release

data/Manifest.txt

@@ -0,0 +1,26 @@
+.gitignore
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/cf_case_check
+lib/case_check.rb
+lib/case_check/coldfusion_source.rb
+lib/case_check/commands.rb
+lib/case_check/configuration.rb
+lib/case_check/core-ext.rb
+lib/case_check/reference.rb
+lib/case_check/references/cfc.rb
+lib/case_check/references/cfinclude.rb
+lib/case_check/references/cfmodule.rb
+lib/case_check/references/custom_tag.rb
+spec/coldfusion_source_spec.rb
+spec/commands_spec.rb
+spec/configuration_spec.rb
+spec/core_ext_spec.rb
+spec/reference_spec.rb
+spec/references/cfc_spec.rb
+spec/references/cfinclude_spec.rb
+spec/references/cfmodule_spec.rb
+spec/references/custom_tag_spec.rb
+spec/spec_helper.rb

data/README.txt

@@ -0,0 +1,75 @@
+`cf_case_check`
+===============
+http://github.com/rsutphin/cf_case_check
+    
+Description
+-----------
+
+`cf_case_check` is a utility which walks a ColdFusion application's source and 
+determines which references to other files will not work with a case-sensitive
+filesystem.  Its intended audience is developers/sysadmins who are migrating
+a CF application from Windows hosting to Linux or another UNIX.
+
+`cf_case_check` was developed at the [Northwestern University Biomedical
+Informatics Center][NUBIC].
+
+[NUBIC]: http://www.nucats.northwestern.edu/centers/nubic/index.html
+
+Features
+--------
+
+* Resolves references of the following types:
+  - `CF_`-style custom tags
+  - `cfinclude`
+  - `cfmodule` (both `template` and `name`)
+  - `createObject` (for CFCs only)
+* Prints report to stdout
+* Allows for designation of custom tag & CFC search paths outside the 
+  application root
+
+Synopsis
+--------
+
+    myapp$ cf_case_check
+
+For command-line options, do:
+
+    $ cf_case_check --help
+
+Requirements
+------------
+
+* Ruby 1.8.6 or later (may work with earlier, but not tested)
+
+Install
+-------
+
+Follow the GitHub rubygems [setup directions](http://gems.github.com/), then
+
+    $ sudo gem install rsutphin-cf_case_check
+
+License
+-------
+
+(The MIT License)
+
+Copyright (c) 2008 Rhett Sutphin
+
+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/Rakefile

@@ -0,0 +1,40 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  load 'tasks/setup.rb'
+end
+
+ensure_in_path 'lib'
+require 'case_check'
+
+task :default => 'spec:run'
+task :install => 'gem:install'
+
+PROJ.name = 'cf_case_check'
+PROJ.authors = 'Rhett Sutphin'
+PROJ.email = 'rhett@detailedbalance.net'
+PROJ.url = 'http://github.com/rsutphin/cf_case_check'
+PROJ.version = CaseCheck::VERSION
+# PROJ.rubyforge.name = 'cf_case_check'
+PROJ.description = "A utility which walks a ColdFusion application's source and determines which includes, custom tags, etc, will not work with a case-sensitive filesystem"
+PROJ.exclude << "gem$" << "gemspec$"
+
+PROJ.ruby_opts = [] # There are a bunch of warnings in rspec, so setting -w isn't useful
+PROJ.spec.opts << '--color'
+PROJ.rcov.opts << '--exclude /Library'
+
+PROJ.gem.dependencies << 'activesupport'
+
+desc 'Regenerate the gemspec for github'
+task :'gem:spec' => 'gem:prereqs' do
+  PROJ.gem._spec.files = PROJ.gem._spec.files.reject { |f| f =~ /^tasks/ }
+  PROJ.gem._spec.rubyforge_project = nil
+  File.open("#{PROJ.name}.gemspec", 'w') do |gemspec|
+    gemspec.puts PROJ.gem._spec.to_ruby
+  end
+end

data/bin/cf_case_check

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib case_check]))
+
+def print_report(checker, out=$stdout)
+  CaseCheck.status_stream.puts "#{checker.reference_count} references"
+  checker.sources.each do |s|
+    out.puts s.src.filename
+    s.internal_references.each do |ir|
+      out.puts " #{bullet(ir)} #{ir.message}"
+    end
+  end
+end
+
+def bullet(ir)
+  case ir.resolution
+  when :exact
+    '-'
+  when :case_insensitive
+    '+'
+  else
+    '*'
+  end
+end
+
+print_report CaseCheck::Checker.new(CaseCheck::Params.new(ARGV))

data/lib/case_check/coldfusion_source.rb

@@ -0,0 +1,92 @@
+require 'enumerator'
+
+module CaseCheck
+
+class ColdfusionSource
+  attr_accessor :internal_references, :content, :filename
+  
+  def self.create(filename)
+    f = File.expand_path(filename)
+    new(f, File.read(f))
+  end
+  
+  def initialize(filename, content = nil)
+    @filename = filename
+    self.content = content
+  end
+  
+  def analyze
+    [CustomTag, Cfmodule, Cfinclude, Cfc].each do |reftype|
+      internal_references.concat reftype.search(self)
+    end
+  end
+  
+  def internal_references
+    @internal_references ||= []
+  end
+  
+  def inexact_internal_references
+    internal_references.reject { |ir| ir.resolution == :exact }
+  end
+  
+  # returns the line number (1-based) on which the given character index lies
+  def line_of(i)
+    return nil if i >= content.size
+    char_ct = 0
+    l = 0
+    while char_ct <= i
+      char_ct += lines[l].size
+      l += 1
+    end
+    l
+  end
+  
+  def content=(c)
+    @lines = nil
+    @content = c
+  end
+  
+  def lines
+    return @lines if @lines
+    @lines = []
+    content.split(/(\r\n|\r|\n)/).each_slice(2) { |line_and_br| @lines << line_and_br.join('') }
+    @lines
+  end
+  
+  # Scans the content for the given RE, yielding the MatchData for each match
+  # and the line number on which it occurred
+  def scan(re, &block)
+    results = []
+    char_offset = 0
+    re.scan(content) do |md|
+      results << (yield [md, line_of(char_offset + md.begin(0))])
+      
+      char_offset += md[0].size + md.pre_match.size
+      remaining = md.post_match
+    end
+    results
+  end
+  
+  # Scans the content for opening and/or self-closing tags with the given
+  # name. Yields the full text of the tag, a parsed representation of the
+  # attributes, and the line number back to the provided block.
+  def scan_for_tag(tag, &block)
+    scan(/<#{tag}(.*?)>/mi) do |md, l|
+      attributes = %w(' ").collect do |q|
+        /(\w+)\s*=\s*#{q}([^#{q}]*?)#{q}/.scan(md[1].gsub(%r(/$), ''))
+      end.flatten.inject({}) do |attrs, amd|
+        attrs[normalize_attribute_key(amd[1])] = amd[2]
+        attrs
+      end
+      yield md[0], attributes, l
+    end
+  end
+  
+  private
+  
+  def normalize_attribute_key(key)
+    key.downcase.to_sym
+  end
+end
+
+end

data/lib/case_check/commands.rb

@@ -0,0 +1,127 @@
+require 'optparse'
+require 'ostruct'
+
+module CaseCheck
+  
+  class Params
+    def initialize(argv, name='cf_case_check')
+      @options = OpenStruct.new
+      
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: #{name} [options]"
+        
+        opts.on("-d", "--dir DIRECTORY", 
+                "The application root from which to search.  Defaults to the current directory.") do |p|
+          @options.source_directory = p
+        end
+        
+        opts.on("-c", "--config CONFIGYAML", 
+                "The configuration file which includes the directories to search for custom tags and CFCs.") do |p|
+          @options.configfile = p
+        end
+        
+        opts.on("-a", "--auto-configure DIRECTORY", 
+                "Automatically configure the directories to search for custom tag and CFCs using Coldfusion's configuration.  (Coldfusion 8 Only)") do |p|
+          @options.coldfusion_directory = p
+        end
+        
+        opts.on("-v", "--verbose", "Show all references, including the ones which can be resolved exactly.") do |v|
+          @options.verbose = true
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+           CaseCheck.status_stream.puts opts
+           CaseCheck.exit
+        end
+        
+        opts.on_tail("--version", "Show version") do
+          CaseCheck.status_stream.puts "#{name} #{CaseCheck.version}"
+          CaseCheck.exit
+        end
+      end.parse!(argv)
+      
+      read_config!
+    end
+    
+    def source_directory
+      @options.source_directory || '.'
+    end
+    
+    def configuration_file
+      @options.configfile || File.join(source_directory, "cf_case_check.yml")
+    end
+    
+    def coldfusion_directory
+      @options.coldfusion_directory || '/opt/coldfusion8'
+    end
+    
+    def coldfusion_directory_given
+      @options.coldfusion_directory
+    end
+    
+    def verbose?
+      @options.verbose
+    end
+    
+    private
+    
+    def read_config!
+      @configuration = 
+        if coldfusion_directory_given && File.exist?(coldfusion_directory)
+          Coldfusion8Configuration.new(coldfusion_directory)
+        elsif File.exist?(configuration_file)
+          Configuration.new(configuration_file)
+        end
+    end
+  end
+  
+  class Checker
+    def initialize(params)
+      @params = params
+      CaseCheck.status_stream.print "Reading source files "
+      @sources = extensions.collect { 
+        |ext| [ext, Dir.glob("#{params.source_directory}/**/*.#{ext}", File::FNM_CASEFOLD)]
+      }.collect do |ext, files|
+        CaseCheck.status_stream.print "#{ext}: " unless files.empty?
+        files.collect do |f|
+          CaseCheck.status_stream.print '.'
+          ColdfusionSource.create(f)
+        end
+      end.flatten
+      CaseCheck.status_stream.puts
+      CaseCheck.status_stream.print "Analyzing "
+      @sources.each do |s|
+        CaseCheck.status_stream.print '.'
+        s.analyze
+      end
+      CaseCheck.status_stream.puts "\n"
+    end
+    
+    def sources
+      @sources.reject { |src| @params.verbose? ? src.internal_references.empty? : src.inexact_internal_references.empty? }.
+        collect { |src| FilteredSource.new(src, @params.verbose?) }
+    end
+    
+    def reference_count
+      sources.inject(0) { |c, s| c + s.internal_references.size }
+    end
+    
+    def extensions
+      %w(cfm cfc tem)
+    end
+  end
+  
+  class FilteredSource
+    attr_reader :src
+    
+    def initialize(source, include_exact_matches)
+      @src = source
+      @include_exact = include_exact_matches
+    end
+    
+    def internal_references
+      @include_exact ? src.internal_references : src.inexact_internal_references
+    end
+  end
+  
+end

data/lib/case_check/configuration.rb

@@ -0,0 +1,51 @@
+require 'pathname'
+require 'yaml'
+
+module CaseCheck
+
+class Configuration
+  def initialize(filename)
+    @filename = filename
+    @doc = YAML.load_file(@filename)
+    apply
+  end
+  
+  private
+  
+  def apply
+    read_custom_tag_dirs
+    read_cfc_dirs
+    read_substitutions
+  end
+  
+  def read_custom_tag_dirs
+    CustomTag.directories = absolutize_directories(@doc['custom_tag_directories'] || [])
+  end
+  
+  def read_cfc_dirs
+    Cfc.directories = absolutize_directories(@doc['cfc_directories'] || [])
+  end
+  
+  def read_substitutions
+    if @doc['substitutions']
+      @doc['substitutions'].each_pair do |re, repl|
+        CaseCheck::Reference.substitutions << [Regexp.new(re, Regexp::IGNORECASE), repl]
+      end
+    end
+  end
+  
+  private
+  
+  def absolutize_directories(dirs)
+    dirs.to_a.collect { |d|
+      p = Pathname.new(d)
+      if p.absolute?
+        p
+      else
+        Pathname.new(File.dirname(@filename)) + p
+      end
+    }.collect { |p| p.to_s }
+  end
+end
+
+end

data/lib/case_check/core-ext.rb

@@ -0,0 +1,51 @@
+# Extend File with case-insensitive utility functions
+class File
+  # Determines if the given filename maps exactly to an existing file, even
+  # if the underlying filesystem is case-insensitive
+  def self.exists_exactly?(name, base=nil)
+    first, rest = File.expand_path(name, '/')[1, name.size].split('/', 2)
+    base ||= ''
+    actual_files = Dir[File.join(base, '*')]
+    candidate = File.join(base, first)
+    actual_files.include?(candidate) && (!rest || self.exists_exactly?(rest, candidate))
+  end
+  
+  # Finds the true filename for the file which can be accessed as "name" 
+  # case-insensitively
+  def self.case_insensitive_canonical_name(name, base=nil)
+    first, rest = File.expand_path(name, '/')[1, name.size].split('/', 2)
+    base ||= ''
+    actual_files = Dir[File.join(base, '*')].collect { |fn| fn[(base.length + 1) .. -1] }
+    match =
+      if actual_files.include?(first)
+        first
+      else
+        actual_files.detect { |fn| fn.downcase == first.downcase }
+      end
+    if rest && match
+      case_insensitive_canonical_name(rest, File.join(base, match))
+    elsif match
+      File.join(base, match)
+    else
+      nil
+    end
+  end
+end
+
+class Regexp
+  # Like String#scan, except that it returns an array of MatchData instead of strings
+  # Works incrementally (returning nil) if given a block
+  def scan(s)
+    data = []
+    remaining = s
+    while md = self.match(remaining)
+      if block_given?
+        yield md
+      else
+        data << md
+      end
+      remaining = md.post_match
+    end
+    block_given? ? nil : data
+  end
+end

data/lib/case_check/reference.rb

@@ -0,0 +1,78 @@
+# Models of various sorts of file references within CF code
+
+require 'rubygems'
+require 'activesupport'
+
+module CaseCheck
+
+# abstract base class
+class Reference < Struct.new(:source, :text, :line)
+  class << self
+    def substitutions
+      @substitutions ||= []
+    end
+  end
+  
+  # abstract methods
+  # - expected_path
+  #   returns the exact relative path to which this reference refers
+  # - resolved_to
+  #   returns the absolute file to which this reference seems to point, if one could be found
+
+  # Returns :exact, :case_insensitive, or nil depending on whether
+  # the reference could be resolved on a case_sensitive FS, 
+  # only on a case_insensitive FS, or not at all 
+  def resolution
+    return nil unless resolved_to
+    case_sensitive_match? ? :exact : :case_insensitive
+  end
+  
+  def message
+    start = 
+      case resolution
+      when :exact
+        "Exactly resolved"
+      when :case_insensitive
+        "Case-insensitively resolved"
+      else
+        "Unresolved"
+      end
+    msg = "#{start} #{type_name} on line #{line}"
+    if resolution
+      "#{msg} from #{text} to #{resolved_to}"
+    else
+      "#{msg}: #{text}"
+    end
+  end
+  
+  def type_name
+    self.class.name.split('::').last.underscore.gsub('_', ' ')
+  end
+  
+  def substituted_text
+    re, sub = CaseCheck::Reference.substitutions.detect { |expr, _| expr =~ text }
+    if re
+      text.sub(re, sub)
+    else
+      text
+    end
+  end
+  
+  protected
+  
+  def case_sensitive_match?
+    resolved_to.ends_with?(expected_path_tail)
+  end
+  
+  def expected_path_tail
+    expected_path.split('/').reject { |pe| pe == '.' }.join('/').gsub(%r((\.\./)+), '')
+  end
+
+  def resolve_in(dir)
+    File.case_insensitive_canonical_name(File.expand_path(expected_path, dir))
+  end
+end
+
+end # module CaseCheck
+
+CaseCheck.require_all_libs_relative_to(__FILE__, 'references')

data/lib/case_check/references/cfc.rb

@@ -0,0 +1,51 @@
+module CaseCheck
+  
+  # Reference as createObject("component", '...')
+  class Cfc < Reference
+    attr_reader :expected_path, :resolved_to
+    
+    class << self
+      attr_writer :directories
+      
+      def directories
+        @directories ||= []
+      end
+      
+      def search(source)
+        source.scan(/createObject\((.*?)\)/mi) do |match, l|
+          args = match[1].split(/\s*,\s*/).collect { |a| a.gsub(/['"]/, '') }
+          unless args.size == 2 && args.first =~ /component/i
+            $stderr.puts "Non-CFC call on line #{l} of #{source.filename}: #{match[0]}"
+          end
+          new(source, args.last, l)
+        end
+      end
+    end
+    
+    def initialize(source, text, line_number)
+      super
+      @expected_path = substituted_text.gsub('.', '/') + ".cfc"
+      @resolved_to = search_path.inject(nil) do |resolved, dir|
+        resolved || resolve_in(dir)
+      end
+    end
+    
+    protected
+    
+    def search_path
+      [File.dirname(source.filename)] + self.class.directories
+    end
+    
+    def case_sensitive_match?
+      return true if super
+      # According to the CF docs:
+      #   "On UNIX systems, ColdFusion searches first for a file with a name
+      #    that matches the specified component name, but is all lowercase.
+      #    If it does not find the file, it looks for a filename that matches
+      #    the component name exactly, with the identical character casing."
+      resolved_to.ends_with?(expected_path_tail.downcase)
+    end
+    
+  end
+
+end

data/lib/case_check/references/cfinclude.rb

@@ -0,0 +1,20 @@
+module CaseCheck
+  
+  # Reference as <cfinclude template=
+  class Cfinclude < Reference
+    attr_accessor :expected_path, :resolved_to
+    
+    def self.search(source)
+      source.scan_for_tag('cfinclude') do |text, attributes, line_number|
+        new(source, attributes[:template], line_number)
+      end
+    end
+
+    def initialize(source, text, line)
+      super
+      @expected_path = substituted_text
+      @resolved_to = resolve_in(File.dirname(source.filename))
+    end
+  end
+  
+end