rleber-textmate 0.9.7.1

data/spec/locations_spec.rb

@@ -0,0 +1,91 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe TextMateBundleManager do
+  describe "locations" do
+    
+    def run_locations
+      @location_list = capture(:stdout) { TextMateBundleManager.start(["locations"]) }.split("\n").map{|line| line.strip.split(/\s{2,}/)}
+    end
+    
+    def locations_for_zone(zone)
+      @location_list.select {|l| l[0] == zone}.map{|l| l[1]}
+    end
+    
+    context "with stubbed locations" do
+      before :each do
+        stub_github_user "foo"
+        stub_remote_locations
+        stub_local_locations
+        run_locations
+      end
+
+      it "lists locations beginning with column titles" do
+        @location_list.first.should == %w{Zone Short Name Location}
+      end
+    
+      it "lists all the locations" do
+        @location_list.shift
+        @location_list.size.should == 9 # 4 "standard" overridden remote locations, plus 5 "standard" overridden local locations
+      end
+    
+      it "lists all location information" do
+        @location_list[1].size.should == 4
+      end
+    
+      it "lists local locations before remote ones" do
+        list = @location_list[1..-1].map {|l| l[0]}
+        compressed_list = []
+        last_element = nil
+        list.each do |l|
+          compressed_list << l if l != last_element
+          last_element = l
+        end
+        compressed_list.should == %w{Local Remote}
+      end
+    
+      it "lists all local locations from highest to lowest precedence" do
+        locations_for_zone('Local').should == %w{user user_p system system_p app}
+      end
+    
+      it "lists all remote locations from highest to lowest precedence" do
+        locations_for_zone('Remote').should == %w{personal github trunk review}
+      end
+    
+      it "lists the correct location fields" do
+        @location_list[1].should == %w{Local user User User\ path}
+      end
+    
+      it "always has 4 columns" do
+        @location_list.should always_have_n_columns(4)
+      end
+    end
+    
+    context "when github_user is not defined" do
+      before :each do
+        stub_github_user nil
+        run_locations
+      end
+      
+      it "does not include a personal github location" do
+        @location_list.map{|l| l[1]}.should_not include('personal')
+      end
+    end
+    
+    context "when github_user is defined" do
+      before :each do
+        stub_github_user "foo"
+        run_locations
+      end
+      
+      it "includes a personal github location" do
+        @location_list.map{|l| l[1]}.should include('personal')
+      end
+      
+      it "sets github url to include 'foo'" do
+        l = @location_list.find {|l| l[1] == "personal" }
+        l.should_not be_nil
+        l[3].should match(/foo/)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,394 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rspec'
+require 'textmate'
+require 'pp'
+require 'mocha'
+
+RSPEC_REMOTE_LOCATIONS = [
+  {:name => :'Personal',          :short => :personal, :scm => :github, :path => 'Personal path'},
+  {:name => :'GitHub',            :short => :github,   :scm => :github, :path => 'Github path'},
+  {:name => :'Macromates Trunk',  :short => :trunk,    :scm => :svn,    :path => 'Trunk path'},
+  {:name => :'Macromates Review', :short => :review,   :scm => :svn,    :path => 'Macromates Review path'},
+]
+
+RSPEC_LOCAL_LOCATIONS = [
+  {:name => :User,              :short=>:user,     :path=>"User path"},
+  {:name => :'User Pristine',   :short=>:user_p,   :path=>"User Pristine path"},
+  {:name => :System,            :short=>:system,   :path=>'System path'},
+  {:name => :'System Pristine', :short=>:system_p, :path=>'System Pristine path'},
+  {:name => :Application,       :short=>:app,      :path=>"Application path"},
+]
+
+RSPEC_REMOTE_BUNDLES = {
+}
+
+
+RSPEC_LOCAL_BUNDLES = {
+  :user => [
+    {:name=>"user_bundle1"},
+    {:name=>"user_bundle2"},
+  ]
+}
+
+class String
+  def blank?
+    !!(self =~ /^\s*$/)
+  end
+end
+
+# A hack:
+# Disable Thor [WARNING] Attempted to create task "..." without usage or description
+class Mocha::AnyInstanceMethod
+  alias original_define_new_method define_new_method
+  def define_new_method
+    if stubbee <= Thor
+      stubbee.class_eval(%{
+        no_tasks do
+          def #{method}(*args, &block)
+            self.class.any_instance.mocha.method_missing(:#{method}, *args, &block)
+          end
+        end
+      }, __FILE__, __LINE__)
+    else
+      original_define_new_method
+    end
+  end
+end
+
+# def stub_local_bundles(bundles=nil)
+#   stub_local_locations
+#   bundles ||= RSPEC_LOCAL_BUNDLES
+#   
+#   TextMateBundleManager.class_eval <<-END
+#     private
+#     
+#     def bundle_status_table
+#       @bundle_status_table ||= #{bundles.inspect}
+#     end
+#     
+#     def bundle_status(path)
+#       basename = File.basename(path, '.*')
+#       res = {}
+#       bundles = get_local_bundle_details(File.dirname(path))
+#       if bundles
+#         res = bundles.find {|b| File.basename(b[:name], '.*') == basename }
+#         res ||= {}
+#       end
+#       res
+#     end
+#     
+#     def get_local_bundle_details(path)
+#       l = find_local_location_by(:path, path)
+#       return [] unless l
+#       bundles = bundle_status_table[l[:short]]
+#       return [] unless bundles
+#       bundles
+#     end
+# 
+#     def get_local_bundles(path)
+#       get_local_bundle_details(path).map {|b| b[:name] + '.tmbundle'}
+#     end
+#   END
+# end
+
+RSpec.configure do |config|
+  config.mock_framework = :mocha
+
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+
+    result
+  end
+  alias :silence :capture
+  
+  def stub_github_user(user)
+    TextMateBundleManager.any_instance.stubs(:current_github_user).returns(user)
+  end
+
+  def stub_local_locations(location_specs=nil)
+    location_specs ||= RSPEC_LOCAL_LOCATIONS
+    TextMateBundleManager.any_instance.stubs(:local_locations).returns(location_specs)
+    location_specs
+  end
+  
+  def stub_remote_locations(location_specs=nil)
+    location_specs ||= RSPEC_REMOTE_LOCATIONS
+    TextMateBundleManager.any_instance.stubs(:remote_locations).returns(location_specs)
+    location_specs
+  end
+  
+  def bundle_details_by_path(locations, bundles)
+    locations.inject({}) do |hsh, l|
+      location_bundles = bundles[l[:short]]
+      hsh[l[:path]] = location_bundles if location_bundles && location_bundles.size > 0
+      hsh
+    end
+  end
+  
+  def bundle_status_table_for(locations, bundles)
+    bundle_status_table = {}
+    bundle_details_by_path(locations, bundles).each do |path, bundle_detail_array|
+      bundle_detail_array.each do |bundle_detail|
+        name = bundle_detail[:name]
+        name += '.tmbundle' unless name =~ /\./
+        bundle_status_table[File.join(path, name)] = bundle_detail
+      end
+    end
+    bundle_status_table
+  end
+  
+  def bundle_names_by_path(locations, bundles)
+    bundle_names_table = {}
+    bundle_details_by_path(locations, bundles).each do |path, bundle_detail_array|
+      bundle_names_table[path] = bundle_detail_array.map do |b|
+        name = b[:name]
+        name += '.tmbundle' unless name =~ /\./
+        name
+      end
+    end
+    bundle_names_table
+  end
+
+  def stub_remote_bundles(locations=nil,bundles=nil)
+    locs = stub_remote_locations(locations)
+    bundles ||= RSPEC_REMOTE_BUNDLES
+    
+    # A total hack, but the only way I can figure out to make this work...
+    TextMateBundleManager.class_eval <<-END
+      no_tasks do
+        def get_remote_bundles(path)
+          #{bundle_names_by_path(locs, bundles).inspect}[path] || []
+      end
+    END
+  end
+
+  def stub_local_bundles(locations=nil, bundles=nil)
+    locs = stub_local_locations(locations)
+    bundles ||= RSPEC_LOCAL_BUNDLES
+    
+    # A total hack, but the only way I can figure out to make this work...
+    TextMateBundleManager.class_eval <<-END
+      no_tasks do
+        def get_local_bundles(path)
+          #{bundle_names_by_path(locs, bundles).inspect}[path] || []
+        end
+        
+        def bundle_status(path)
+          #{bundle_status_table_for(locs, bundles).inspect}[path] || {}
+        end
+      end
+    END
+  end
+
+  module CustomMatchers
+    
+    class ArrayRowMatcher
+      def initialize(expected)
+        @expected = expected
+      end
+      
+      def matches?(actual)
+        matches_all?(actual)
+      end
+
+      def matches_all?(actual)
+        @actual = actual
+        failed = false
+        actual.each do |row|
+          return false unless matches_row?(row)
+        end
+        return true
+      end
+
+      def matches_row?(row)
+        raise "#{self}#matches_row? not implemented"
+      end
+
+      def format_row_groups(rows)
+        last_row = -1
+        row_groups = []
+        rows.each do |row|
+          if row == last_row + 1 
+            if row_groups.size == 0 # Shouldn't happen, but why not?
+              row_groups << [row, row]
+            else
+              last_group = row_groups.pop
+              row_groups << [last_group.first, row]
+            end
+          else
+            row_groups << [row, row]
+          end
+          last_row = row
+        end
+        formatted_groups = row_groups.map do |group|
+          if group.first == group.last
+            group.first.to_s
+          else
+            "#{group.first}..#{group.last}"
+          end
+        end
+        formatted_rows = formatted_groups.join(',')
+      end
+      
+      def classify_rows
+        bad_rows = []
+        good_rows = []
+        @actual.each_with_index do |row, i|
+          if matches_row?(row)
+            good_rows << i
+          else
+            bad_rows << i
+          end
+        end
+        [good_rows, bad_rows]
+      end
+    end
+    
+    class AlwaysHasNColumns < ArrayRowMatcher
+         
+      def column_counts
+        @actual.map {|row| row.size }
+      end
+      
+      def max_columns
+        column_counts.max
+      end
+      
+      def min_columns
+        column_counts.min
+      end
+      
+      def matches_row?(row)
+        @expected == row.size
+      end
+
+      def failure_message_for_should
+        max = max_columns
+        min = min_columns
+        good_rows, bad_rows = classify_rows
+        if max == min
+          "expected table to have #{@expected} columns. It actually has #{min} columns. Row[0]=#{@actual[0].inspect}\n"
+        elsif bad_rows.size > 0
+          msg = "expected table to have #{@expected} columns. It actually has #{min}..#{max} columns.\n" \
+            "Bad rows: #{format_row_groups(bad_rows)}\n" \
+            "Row[#{bad_rows[0]}] is bad, for instance: #{@actual[bad_rows[0]].inspect}"
+          if good_rows.size > 0
+            good_rows_msg = "\nGood rows: #{format_row_groups(good_rows)}\n" \
+              "Row[#{good_rows[0]}] is good, for instance: #{@actual[good_rows[0]].inspect}"
+          else
+            good_rows_msg = "\nNo good rows"
+          end
+          msg << good_rows_msg
+        else
+          "expected table to have #{@expected} columns. It actually has #{min}..#{max} columns, but I can't find a bad row."
+        end
+      end
+
+      def failure_message_for_should_not
+        max = max_columns
+        min = min_columns
+        if max == min
+          "expected table not to have #{@expected} columns, but it does. Row[0]=#{@actual[0].inspect}\n"
+        else
+          "expected table not to have #{@expected} columns. It actually has #{min}..#{max} columns, which shouldn't have caused this example to fail."
+        end
+      end
+    end
+
+    def always_have_n_columns(expected)
+      AlwaysHasNColumns.new(expected)
+    end
+    
+    class AlwaysMatcher < ArrayRowMatcher
+          
+      def matches_row?(row)
+        row.match(@expected)
+      end
+    
+      def failure_message_for_should
+        good_rows, bad_rows = classify_rows
+        msg = "expected rows of table to always match #{@expected.inspect}, but it doesn't."
+        if bad_rows.size > 0
+          msg << "\nBad rows: #{format_row_groups(bad_rows)}" \
+            "\nRow[#{bad_rows[0]}] is bad, for instance: #{@actual[bad_rows[0]].inspect}"
+        else
+          msg << "\nNo bad rows."
+        end
+        if good_rows.size > 0
+          msg << "\nGood rows: #{format_row_groups(good_rows)}" \
+            "\nRow[#{good_rows[0]}] is good, for instance: #{@actual[good_rows[0]].inspect}"
+        else
+          msg << "\nNo good rows"
+        end
+        msg
+      end
+    
+      def failure_message_for_should_not
+        "expected rows of table to never match #{@expected.inspect}, but they do. Row[0]=#{@actual[0].inspect}"
+      end
+    end
+
+    def always_match(expected)
+      AlwaysMatcher.new(expected)
+    end
+    
+    class AlwaysColumnMatcher < ArrayRowMatcher
+      
+      def initialize(n, match)
+        super(match)
+        @n = n
+      end
+          
+      def matches_row?(row)
+        # puts "Checking row: #{format_row(row)}"
+        row[@n].match(@expected)
+      end
+      
+      def format_row(row)
+        res = []
+        row.each_with_index do |cell, i|
+          res << (i==@n ? "<<#{cell.inspect}>>" : cell.inspect)
+        end
+        "[#{res.join(',')}]"
+      end
+    
+      def failure_message_for_should
+        good_rows, bad_rows = classify_rows
+        msg = "expected column #{@n} of table to always match #{@expected.inspect}, but it doesn't."
+        if bad_rows.size > 0
+          msg << "\nBad rows: #{format_row_groups(bad_rows)}" \
+            "\nRow[#{bad_rows[0]}] is bad, for instance: #{format_row(@actual[bad_rows[0]])}"
+        else
+          msg << "\nNo bad rows."
+        end
+        if good_rows.size > 0
+          msg << "\nGood rows: #{format_row_groups(good_rows)}" \
+            "\nRow[#{good_rows[0]}] is good, for instance: #{format_row(@actual[good_rows[0]])}"
+        else
+          msg << "\nNo good rows"
+        end
+        msg
+      end
+    
+      def failure_message_for_should_not
+        "expected column #{@n} of table to never match #{@expected.inspect}, but they do. Row[0]=#{format_row(@actual[0])}"
+      end
+    end
+    
+    def always_match_in_column(n, match)
+      AlwaysColumnMatcher.new(n, match)
+    end
+
+  end
+  config.include(CustomMatchers)
+
+end