rsutphin-cf_case_check 0.0.0

data/lib/case_check/references/custom_tag.rb

@@ -0,0 +1,50 @@
+module CaseCheck
+  
+  # Reference as cf_name (or CF_name)
+  class CustomTag < Reference
+    attr_reader :expected_path, :resolved_to
+
+    class << self
+      attr_writer :directories
+      
+      def directories
+        @directories ||= []
+      end
+      
+      def search(source)
+        source.scan(/<(CF_(\w+))/i) do |match_data, line_number|
+          self.new(source, match_data[1], line_number)
+        end
+      end
+      
+      def recursive_directories
+        directories + directories.collect do |dir|
+          collect_subdirs(dir)
+        end.flatten
+      end
+      
+      private
+      
+      def collect_subdirs(start)
+        [start] + Dir[File.join(start, '*')].select { |f| File.directory?(f) }.collect do |dir|
+          collect_subdirs(dir)
+        end.flatten
+      end
+    end
+
+    def initialize(source, text, line)
+      super
+      @expected_path = text[3, text.size] + ".cfm"
+      @resolved_to = resolve
+    end
+
+    private
+
+    def resolve
+      [File.dirname(source.filename), self.class.recursive_directories].flatten.inject(nil) do |resolved, dir|
+        resolved || resolve_in(dir)
+      end
+    end
+  end
+  
+end

data/lib/case_check.rb

@@ -0,0 +1,60 @@
+
+module CaseCheck
+  # :stopdoc:
+  VERSION = '0.0.0'.freeze
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+  
+  def self.status_stream
+    @stderr ||= $stderr
+  end
+  
+  def self.status_stream=(err)
+    @stderr = err
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to rquire all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+  
+  def self.exit
+    exit
+  end
+
+end  # module CaseCheck
+
+CaseCheck.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/spec/coldfusion_source_spec.rb

@@ -0,0 +1,161 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+module CaseCheck
+
+describe ColdfusionSource do
+  describe "line_of" do
+    def actual_line_of(content, i)
+      ColdfusionSource.new("dc", content).line_of(i)
+    end
+    
+    it "is always line 1 for a single line file" do
+      actual_line_of("some text", 3).should == 1
+    end
+    
+    it "can find something on the last line" do
+      actual_line_of("some\ntext\nhere", 13).should == 3
+    end
+    
+    it "is 1 for character 0" do
+      actual_line_of("some text", 0).should == 1
+    end
+  end
+  
+  describe "scan" do
+    def perform_scan(content, re)
+      ColdfusionSource.new("dc", content).scan(re) do |md, l|
+        [md[0], l]
+      end
+    end
+    
+    it "finds one instance" do
+      actual = perform_scan("123 abc", /[a-z]+/)
+      actual.should have(1).match
+      actual.first.should == ['abc', 1]
+    end
+    
+    it "finds multiple instances" do
+      actual = perform_scan("abc def 123 four", /[a-z]+/)
+      actual.should have(3).matches
+      actual[0].should == ['abc', 1]
+      actual[1].should == ['def', 1]
+      actual[2].should == ['four', 1]
+    end
+    
+    it "finds instances on multiple lines" do
+      actual = perform_scan(<<-TEXT, /[a-z]+/)
+        for
+        23
+        answers
+      TEXT
+      actual.should have(2).matches
+      actual[0].should == ['for', 1]
+      actual[1].should == ['answers', 3]
+    end
+  end
+  
+  describe "scan for tag" do
+    def perform_scan(content, tag)
+      ColdfusionSource.new("dc", content).scan_for_tag(tag) do |text, attributes, l|
+        { :text => text, :attributes => attributes, :line_number => l }
+      end
+    end
+    
+    it "finds a tag with no attributes" do
+      actual = perform_scan("text <cfabort>more text", "cfabort")
+      actual.should have(1).match
+      actual.first[:text].should == "<cfabort>"
+      actual.first[:attributes].should == { }
+      actual.first[:line_number].should == 1
+    end
+    
+    it "finds an XML-style self-closing tag with no attributes" do
+      actual = perform_scan("text <cfabort/>more text", "cfabort")
+      actual.should have(1).match
+      actual.first[:text].should == "<cfabort/>"
+      actual.first[:attributes].should == { }
+      actual.first[:line_number].should == 1
+    end
+    
+    it "finds a single-line tag with attributes" do
+      actual = perform_scan("and then <cflog text='in the middle'> something happens", 'cflog')
+      actual.should have(1).match
+      actual.first[:text].should == "<cflog text='in the middle'>"
+      actual.first[:attributes].should have(1).attribute
+      actual.first[:attributes][:text].should == 'in the middle'
+      actual.first[:line_number].should == 1
+    end
+    
+    it "finds a single-line self-closing tag with attributes" do
+      actual = perform_scan("and then <cflog text='in the middle'/> something happens", 'cflog')
+      actual.should have(1).match
+      actual.first[:text].should == "<cflog text='in the middle'/>"
+      actual.first[:attributes].should have(1).attribute
+      actual.first[:attributes][:text].should == 'in the middle'
+      actual.first[:line_number].should == 1
+    end
+    
+    it "finds attributes which are surrounded by single quotes" do
+      actual = perform_scan("and then <cflog text='in the middle'/> something happens", 'cflog')
+      actual.should have(1).match
+      actual.first[:attributes].should have(1).attribute
+      actual.first[:attributes][:text].should == 'in the middle'
+    end
+    
+    it "finds attributes which are surrounded by double quotes" do
+      actual = perform_scan(%q(and then <cflog text="in the middle"/> something happens), 'cflog')
+      actual.should have(1).match
+      actual.first[:attributes].should have(1).attribute
+      actual.first[:attributes][:text].should == 'in the middle'
+    end
+    
+    it "finds multiple tags" do
+      actual = perform_scan(<<-CFM, "cfparam")
+        <cfparam name="foo" default="42">
+        <cfparam name="bar" default="11">
+      CFM
+      actual.should have(2).matches
+      actual[0][:attributes].should == { :name => 'foo', :default => '42' }
+      actual[1][:attributes].should == { :name => 'bar', :default => '11' }
+      actual[1][:line_number].should == 2
+    end
+    
+    it "finds tags that are spread over multiple lines" do
+      actual = perform_scan(<<-CFM, "cfmodule")
+        <html>
+        <title>
+          <cfmodule
+            name="whatever"
+            >
+        </title></html>
+      CFM
+      actual.should have(1).match
+      actual.first[:attributes].should == { :name => 'whatever' }
+    end
+    
+    it "is flexible about whitespace around '='" do
+      actual = perform_scan(<<-CFM, "cfparam")
+        <cfparam name ="foo" default= "42">
+        <cfparam name="bar" default = "11">
+      CFM
+      actual.should have(2).matches
+      actual[0][:attributes].should == { :name => 'foo', :default => '42' }
+      actual[1][:attributes].should == { :name => 'bar', :default => '11' }
+      actual[1][:line_number].should == 2
+    end
+    
+    it "downcases attribute keys" do
+      actual = perform_scan(%q(<cfabort NOW='later'>), 'cfabort')
+      actual.first[:attributes].keys.should include(:now)
+    end
+    
+    it "matches tags without regard to case" do
+      actual = perform_scan(%q(Time to go <CFABORT/>), 'cfAbort')
+      actual.should have(1).matches
+      actual.first[:text].should == '<CFABORT/>'
+    end
+  end
+end
+
+end # module
+

data/spec/commands_spec.rb

@@ -0,0 +1,103 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe CaseCheck::Params do
+  def config_file(filename, contents)
+    FileUtils.mkdir_p File.dirname(filename)
+    File.open(filename, 'w') { |f| f.write contents }
+  end
+  
+  def actual_params(*argv)
+    CaseCheck::Params.new(argv.flatten)
+  end
+  
+  describe "--dir directory" do
+    before do
+      @dirname = "/tmp/cftest"
+      FileUtils.mkdir_p @dirname
+    end
+    
+    after do
+      FileUtils.rm_rf @dirname
+    end
+    
+    it "makes the directory available" do
+      actual = actual_params('--dir', @dirname)
+      actual.directory.should == @dirname
+    end
+    
+    it "defaults the directory to the current" do
+      actual_params.directory.should == '.'
+    end
+    
+    it "reads the configuration directory/cf_case_check.yml" do
+      config_file File.join(@dirname, "cf_case_check.yml"), <<-YAML
+        cfc_directories:
+          - /tmp/baz
+      YAML
+      actual_params('--dir', @dirname)
+      CaseCheck::Cfc.directories.should == %w(/tmp/baz)
+    end
+    
+    it "prefers an explicitly named configuration file if both are available" do
+      config_file File.join(@dirname, "cf_case_check.yml"), <<-YAML
+        cfc_directories:
+          - /tmp/quux
+      YAML
+      config_file File.join(@dirname, "another.yml"), <<-YAML
+        cfc_directories:
+          - /tmp/qurt
+      YAML
+      actual_params('--dir', @dirname, '--config', File.join(@dirname, 'another.yml'))
+      CaseCheck::Cfc.directories.should == %w(/tmp/qurt)
+    end
+  end
+  
+  describe "--config filename" do
+    before do
+      @filename = "/tmp/foo.yml"
+      config_file @filename, <<-YAML
+        cfc_directories:
+          - /tmp/bar
+      YAML
+      CaseCheck::Cfc.directories = nil
+    end
+    
+    after do
+      FileUtils.rm_rf @filename
+    end
+    
+    it "loads the configuration" do
+      actual_params('--config', @filename)
+      CaseCheck::Cfc.directories.should == %w(/tmp/bar)
+    end
+  end
+  
+  describe "--version" do
+    it "prints to configured stderr" do
+      CaseCheck.should_receive(:exit)
+      actual_params('--version')
+      CaseCheck.status_stream.string.should == "cf_case_check #{CaseCheck.version}\n"
+    end
+  end
+  
+  describe "--help" do
+    it "prints to configured stderr" do
+      CaseCheck.should_receive(:exit)
+      actual_params('--help')
+      CaseCheck.status_stream.string.should include("cf_case_check")
+      CaseCheck.status_stream.string.should include("config")
+      CaseCheck.status_stream.string.should include("dir")
+    end
+  end
+  
+  describe "--verbose" do
+    it "sets the verbose flag" do
+      actual_params('--verbose').should be_verbose
+      actual_params('-v').should be_verbose
+    end
+    
+    it "does not set the verbose flag when omitted" do
+      actual_params.should_not be_verbose
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,42 @@
+require 'fileutils'
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe CaseCheck::Configuration do
+  before do
+    @filename = "/tmp/cf_case_check/config.yml"
+  end
+  
+  after do
+    if File.exist?(@filename)
+      FileUtils.rm_rf @filename
+    end
+  end
+  
+  def config_file(contents)
+    FileUtils.mkdir_p File.dirname(@filename)
+    File.open(@filename, 'w') { |f| f.write contents }
+  end
+  
+  def read_config
+    CaseCheck::Configuration.new(@filename)
+  end
+  
+  it "reads custom tag directories" do
+    config_file <<-YAML
+      custom_tag_directories:
+        - /var/www/customtags
+        - /home/cf/customtags
+    YAML
+    read_config
+    CaseCheck::CustomTag.directories.should == %w(/var/www/customtags /home/cf/customtags)
+  end
+  
+  it "resolves relative custom tag directories against the config file directory" do
+    config_file <<-YAML
+      custom_tag_directories:
+        - zappo/customtags
+    YAML
+    read_config
+    CaseCheck::CustomTag.directories.should == %w(/tmp/cf_case_check/zappo/customtags)
+  end
+end

data/spec/core_ext_spec.rb

@@ -0,0 +1,72 @@
+require 'fileutils'
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe File, ' extensions ' do
+  before do
+    @tmpdir = "/tmp/case_check_spec"
+    FileUtils.mkdir_p(File.dirname(@tmpdir))
+  end
+  
+  after do
+    FileUtils.rm_rf(@tmpdir)
+  end
+  
+  def touch(filename)
+    full = testfile(filename)
+    FileUtils.mkdir_p(File.dirname(full))
+    File.open(full, 'w') { }
+    full
+  end
+  
+  def testfile(filename)
+    File.join(@tmpdir, filename)
+  end
+  
+  describe "#exists_exactly?" do
+    it "does not include insensitive file matches" do
+      touch("some_file")
+      File.exists_exactly?(testfile("some_File")).should be_false
+    end
+    
+    it "does not include insensitive directory matches" do
+      touch("Bar/quUx")
+      File.exists_exactly?(testfile("bAr/quUx")).should be_false
+    end
+    
+    it "does not have a problem with files that don't exist at all" do
+      File.exists_exactly?(testfile("nope")).should be_false
+    end
+    
+    it "does match exact file paths" do
+      touch("qUuX/foo")
+      File.exists_exactly?(testfile("qUuX/foo")).should be_true
+    end
+  end
+  
+  describe "#case_insensitive_canonical_name" do
+    it "finds exact matches" do
+      touch("baz/bar.foo")
+      File.case_insensitive_canonical_name(testfile("baz/bar.foo")).should == testfile("baz/bar.foo")
+    end
+    
+    it "finds matches with case-insensitive matching directories" do
+      touch("baZ/baR/foo")
+      File.case_insensitive_canonical_name(testfile("baz/bar/foo")).should == testfile("baZ/baR/foo")
+    end
+    
+    it "finds matches with case-insensitive matching filenames" do
+      touch("baz/bar/fOz")
+      File.case_insensitive_canonical_name(testfile("baz/bar/FOZ")).should == testfile("baz/bar/fOz")
+    end
+    
+    it "finds no match for non-existent files" do
+      File.case_insensitive_canonical_name(testfile("quux")).should be_nil
+    end
+    
+    it "handles path navigation" do
+      touch("baz/bar/foo/quux")
+      File.case_insensitive_canonical_name(testfile("baz/bar/quod/../fOO/quux")).should == testfile("baz/bar/foo/quux")
+    end
+  end
+end

data/spec/reference_spec.rb

@@ -0,0 +1,52 @@
+require 'fileutils'
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe CaseCheck::Reference do
+  class SampleReference < CaseCheck::Reference
+    attr_accessor :expected_path, :resolved_to
+    
+    def initialize(expected_path, resolved_to, line=0, text=nil)
+      self.expected_path = expected_path
+      self.resolved_to = resolved_to
+      self.line = line
+      self.text = text
+    end
+  end
+  
+  describe 'default resolution' do
+    it 'is exact when resolved_to ends with expected_path' do
+      SampleReference.new("/foo/patient.cfm", "/home/cfcode/apps/notis/foo/patient.cfm").resolution.should == :exact
+    end
+  
+    it 'is exact when resolved_to ends with expected_path, disregarding ../.' do
+      SampleReference.new(".././foo/patient.cfm", "/home/cfcode/apps/notis/foo/patient.cfm").resolution.should == :exact
+    end
+  
+    it 'is case sensitive when resolved_to ends with something else' do
+      SampleReference.new("/foo/Patient.cfm", "/home/cfcode/apps/notis/foo/patient.cfm").resolution.should == :case_insensitive
+    end
+  
+    it 'is unresolved without resolved_to' do
+      SampleReference.new("/foo/patient.cfm", nil).resolution.should be_nil
+    end
+  end
+  
+  describe 'default message' do
+    it "indicates when it is unresolved" do
+      SampleReference.new("/foo/patient.cfm", nil, 11, "FOO_Patient").message.should == 
+        "Unresolved sample reference on line 11: FOO_Patient"
+    end
+
+    it "indicates when it is exactly resolved" do
+      SampleReference.new("/foo/patient.cfm", "/home/cfcode/apps/notis/foo/patient.cfm", 11, "foo_patient").message.should == 
+        "Exactly resolved sample reference on line 11 from foo_patient to /home/cfcode/apps/notis/foo/patient.cfm"
+    end
+
+    it "indicates when it is only case-insensitively resolved" do
+      SampleReference.new("/foo/Patient.cfm", "/home/cfcode/apps/notis/foo/patient.cfm", 11, "foo_Patient").message.should == 
+        "Case-insensitively resolved sample reference on line 11 from foo_Patient to /home/cfcode/apps/notis/foo/patient.cfm"
+    end
+  end
+end
+

data/spec/references/cfc_spec.rb

@@ -0,0 +1,62 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+describe CaseCheck::Cfc do
+  before(:each) do
+    CaseCheck::Cfc.directories = %w(/tmp/cfc_specs/components)
+    @source = create_test_source('/tmp/cfc_specs/theapp/quux.cfm', <<-CFM)
+      <cfparam name="url.summaryType">
+      <cfparam name="url.patient_id">
+      <cfparam name="url.summaryId" default="0">
+
+      <cfscript>
+              utilsObj = CreateObject("component","bspore.Utils").init(datasource=application.personnel_db,username=session.netid,userIP=cgi.remote_addr);
+              summaryObj = createObject("component","bspore.Summary").init(datasource=application.db,username=session.netid,userIP=cgi.remote_addr);
+      </cfscript>
+    CFM
+  end
+  
+  after(:each) do
+    FileUtils.rm_r '/tmp/cfc_specs'
+  end
+  
+  def actual_search
+    CaseCheck::Cfc.search(@source)
+  end
+  
+  it "has a human-readable name" do
+    actual_search.first.type_name.should == 'cfc'
+  end
+  
+  it "finds multiple invocations" do
+    actual_search.should have(2).references
+  end
+  
+  it "finds lower case createObject style" do
+    actual_search.last.expected_path.should == "bspore/Summary.cfc"
+  end
+  
+  it "finds upper case CreateObject style" do
+    actual_search.first.expected_path.should == "bspore/Utils.cfc"
+  end
+  
+  it "resolves against an exact match" do
+    expected_file = CaseCheck::Cfc.directories.last + "/bspore/Utils.cfc"
+    touch expected_file
+    actual_search.first.resolved_to.should == expected_file
+    actual_search.first.resolution.should == :exact
+  end
+  
+  it "resolves against an all-lowercase match as exact" do
+    expected_file = CaseCheck::Cfc.directories.last + "/bspore/utils.cfc"
+    touch expected_file
+    actual_search.first.resolved_to.should == expected_file
+    actual_search.first.resolution.should == :exact
+  end
+  
+  it "resolves against an differently cased version as inexact" do
+    expected_file = CaseCheck::Cfc.directories.last + "/BSpore/Utils.cfc"
+    touch expected_file
+    actual_search.first.resolved_to.should == expected_file
+    actual_search.first.resolution.should == :case_insensitive
+  end
+end

data/spec/references/cfinclude_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+describe CaseCheck::Cfinclude do
+  before(:each) do
+    @source = create_test_source("/tmp/cfinc_specs/theapp/quux.cfm", <<-CFM)
+      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
+            "http://www.w3.org/TR/REC-html40/loose.dtd">
+      <HTML>
+      <HEAD>
+        <TITLE>Pick Permissions Report Options</TITLE>
+        <META NAME="generator" CONTENT="BBEdit 5.1.1">
+
+      <CFPARAM NAME="Session.Output_Type" DEFAULT="Browser">
+
+      <cfinclude template="../header_plain.html">
+      <h1>Pick Permissions Report Options</h1>
+
+    CFM
+  end
+  
+  after(:each) do
+    FileUtils.rm_r '/tmp/cfinc_specs'
+  end
+  
+  def actual_search
+    CaseCheck::Cfinclude.search(@source)
+  end
+  
+  it "has a human-readable name" do
+    actual_search.first.type_name.should == 'cfinclude'
+  end
+  
+  it "uses the template path as the path" do
+    actual_search.first.expected_path.should == "../header_plain.html"
+  end
+  
+  it "resolves against file directory" do
+    expected_file = "/tmp/cfinc_specs/header_plain.html"
+    touch expected_file
+    actual_search.first.resolved_to.should == expected_file
+    actual_search.first.resolution.should == :exact
+  end
+  
+  it "resolves against file directory case-insensitively" do
+    expected_file = "/tmp/cfinc_specs/headER_plain.html"
+    touch expected_file
+    actual_search.first.resolved_to.should == expected_file
+    actual_search.first.resolution.should == :case_insensitive
+  end
+  
+  it "finds multiple cfincludes" do
+    @source.content = <<-CFM
+      <cfinclude template="etc"/>
+      And then something else happened.
+      <cfinclude template="etal">
+    CFM
+    actual_search.should have(2).references
+  end
+  
+  it "finds the cfinclude tag without regard to case" do
+    @source.content = <<-CFM
+      <CFInclude template="whatever">
+    CFM
+    actual_search.should have(1).reference
+  end
+end