jdzak-cf_case_check 0.1.1

data/lib/case_check/references/cfmodule.rb

@@ -0,0 +1,48 @@
+module CaseCheck
+  
+  # Reference as <cfmodule name= or <cfmodule template=
+  class Cfmodule < Reference
+    attr_reader :expected_path, :resolved_to
+
+    class << self
+      def search(source)
+        source.scan_for_tag('cfmodule') do |text, attributes, line_number|
+          if attributes.keys.include?(:name)
+            Name.new(source, attributes[:name], line_number)
+          elsif attributes.keys.include?(:template)
+            Template.new(source, attributes[:template], line_number)
+          else
+            $stderr.puts "Neither name nor template for cfmodule on line #{line_number} of #{source.filename}"
+          end
+        end.compact
+      end
+    end
+    
+    class Name < Cfmodule
+      def initialize(source, text, line)
+        super
+        @expected_path = substituted_text.gsub('.', '/') + ".cfm"
+        @resolved_to = CustomTag.directories.inject(nil) do |resolved, dir|
+          resolved || resolve_in(dir)
+        end
+      end
+      
+      def type_name
+        "cfmodule with name"
+      end
+    end
+    
+    class Template < Cfmodule
+      def initialize(source, text, line)
+        super
+        @expected_path = substituted_text
+        @resolved_to = resolve_in(File.dirname(source.filename))
+      end
+      
+      def type_name
+        "cfmodule with template"
+      end
+    end
+  end
+  
+end

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.1.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
+    Kernel::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,130 @@
+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.source_directory.should == @dirname
+    end
+    
+    it "defaults the directory to the current" do
+      actual_params.source_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 "--auto-configure directory" do
+    class Coldfusion8ConfigStub
+      def initialize(root)
+        apply
+      end
+      
+      def apply
+        CaseCheck::Cfc.directories = %w(/mock/cfc/directory)
+      end 
+    end
+    
+    before do
+      @cf_root = '/coldfusion_root'
+
+      File.should_receive(:exist?).with(@cf_root).any_number_of_times.and_return(true)
+
+      @config = Coldfusion8ConfigStub.new(@cf_root)
+    end
+    
+    it "load the coldfusion 8 configuration" do
+      CaseCheck::Coldfusion8Configuration.should_receive(:new).and_return(@config)
+      actual_params('--auto-configure', @cf_root)
+      CaseCheck::Cfc.directories.should ==  %w(/mock/cfc/directory)
+    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,61 @@
+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
+  
+  it "reads substitutions" do
+    config_file <<-YAML
+      substitutions:
+        '#application.cfcPath#': /var/www/cfcs
+    YAML
+    read_config
+    CaseCheck::Reference.should have(1).substitutions
+  end
+  
+  it "interprets substitution patterns as case insensitive REs" do
+    config_file <<-YAML
+      substitutions:
+        '#application.cfcPath#': /var/www/cfcs
+    YAML
+    read_config
+    CaseCheck::Reference.substitutions.first.should == [/#application.cfcPath#/i, '/var/www/cfcs']
+    CaseCheck::Reference.substitutions.first.first.should be_casefold
+  end
+end

data/spec/core_ext_spec.rb

@@ -0,0 +1,99 @@
+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
+    
+    describe "with symlinks" do
+      before do
+        @actual_dir = File.join(@tmpdir, "A")
+        FileUtils.mkdir_p @actual_dir
+        @linked_dir = File.join(@tmpdir, "B")
+        FileUtils.ln_s(@actual_dir, @linked_dir)
+      end
+      
+      it "finds exact matches" do
+        expected = File.join(@linked_dir, "foo.cfm")
+        FileUtils.touch expected
+        File.case_insensitive_canonical_name(expected).should == expected
+      end
+      
+      it "finds case-insensitive matches where the filename case differs" do
+        expected = File.join(@linked_dir, "Foo.cfm")
+        FileUtils.touch expected
+        File.case_insensitive_canonical_name(File.join(@linked_dir, "foo.cfm")).should == expected
+      end
+      
+      it "finds case-insensitive matches where the symlink case differs" do
+        expected = File.join(@linked_dir, "foo.cfm")
+        FileUtils.touch expected
+        File.case_insensitive_canonical_name(File.join(@tmpdir, 'b', "foo.cfm")).should == expected
+      end
+    end
+  end
+end

data/spec/reference_spec.rb

@@ -0,0 +1,67 @@
+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 "text substitution" do
+    it "has none by default" do
+      CaseCheck::Reference.substitutions.should == []
+    end
+    
+    it "subs in the first matching option" do
+      CaseCheck::Reference.substitutions << [/#application#/i, 'foo'] << [/#app.*?#/i, 'bar']
+      SampleReference.new(nil, nil, 0, "#application#/quux").substituted_text.should == "foo/quux"
+    end
+    
+    it "returns the original text if there are no matching subs" do
+      SampleReference.new(nil, nil, 0, "#application#/quux").substituted_text.should == "#application#/quux"
+    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
+