laser 0.7.0.pre1

data/spec/support_specs/acts_as_struct_spec.rb

@@ -0,0 +1,94 @@
+require_relative 'spec_helper'
+
+describe ActsAsStruct do
+  members = :first, :second, :third, :fourth, :fifth
+  values = 1, 2, 3, 4, 5
+  zipped = members.zip(values)
+  derived_members = members + [:sixth, :seventh]
+  derived_values = values + [6, 7]
+  derived_zipped = derived_members.zip(derived_values)
+  
+  before do
+    @class = Class.new do
+      extend ActsAsStruct
+      acts_as_struct *members
+    end
+    @instance = @class.new(*values)
+    @derived_class = Class.new(@class) do
+      acts_as_struct(*(derived_members - members))
+    end
+    @derived_instance = @derived_class.new(*derived_values)
+  end
+
+  describe '#acts_as_struct' do
+    it 'creates readers for all named attributes' do
+      members.each { |member| @instance.should respond_to(member) }
+    end
+
+    it 'creates writers for all named attributes' do
+      members.each { |member| @instance.should respond_to("#{member}=") }
+    end
+    
+    describe '#initialize' do
+      it 'allows initialization via positional arguments' do
+        zipped.each { |member, value| @instance.send(member).should == value }
+      end
+    
+      it 'allows initialization with a hash' do
+        instance = @class.new(Hash[zipped.flatten])
+        zipped.each { |member, value| @instance.send(member).should == value }
+      end
+    
+      it 'allows fewer positional arguments than the maximum' do
+        instance = @class.new(1)
+        instance.first.should == 1
+        instance.third.should == nil
+      end
+    
+      it 'raises on too many positional arguments' do
+        expect { @class.new(1,2,3,4,5,6) }.to raise_error(ArgumentError)
+      end
+    end
+    
+    describe '#keys' do
+      it 'returns the keys used in acts_as_struct' do
+        @instance.keys.should == members
+      end
+    end
+    
+    describe '#values' do
+      it 'returns the values in the same order as used in acts_as_struct' do
+        @instance.values.should == values
+      end
+    end
+    
+    describe '#keys_and_values' do
+      it 'returns the keys and values arrays zipped' do
+        @instance.keys_and_values.should == zipped
+      end
+    end
+    
+    describe '#each' do
+      it 'yields each key and value in order' do
+        yielded_values = []
+        @instance.each { |k, v| yielded_values << [k, v] }
+        yielded_values.should == zipped
+      end
+    end
+    
+    describe '#<=>' do
+      it 'compares the values pairwise, in the order given by the acts_as_struct call' do
+        @class.new(1,2,3).should be < @class.new(2,2,3)
+        @class.new(1,2,3).should be < @class.new(1,2,4)
+        @class.new(1,2,3).should be == @class.new(1,2,3)
+        @class.new(4,4,5).should be > @class.new(4,4,4)
+      end
+    end
+    
+    describe 'when used in a derived class that is also using acts_as_struct' do
+      it 'should simply append the new members to create a compatible subtype' do
+        @derived_instance.keys_and_values.should == derived_zipped
+      end
+    end
+  end
+end

data/spec/support_specs/frequency_spec.rb

@@ -0,0 +1,23 @@
+require_relative 'spec_helper'
+
+describe Frequency do
+  describe Frequency::NEVER do
+    it { Frequency::NEVER.should be == Frequency::NEVER }
+    it { Frequency::NEVER.should be < Frequency::MAYBE  }
+    it { Frequency::NEVER.should be < Frequency::ALWAYS }
+  end
+  
+  describe Frequency::MAYBE do
+    it { Frequency::MAYBE.should be > Frequency::NEVER  }
+    it { Frequency::MAYBE.should be == Frequency::MAYBE }
+    it { Frequency::MAYBE.should be < Frequency::ALWAYS }
+  end
+  
+  describe Frequency::ALWAYS do
+    it { Frequency::ALWAYS.should be > Frequency::NEVER   }
+    it { Frequency::ALWAYS.should be > Frequency::MAYBE   }
+    it { Frequency::ALWAYS.should be == Frequency::ALWAYS }
+  end
+  
+  it { Frequency.should_not respond_to(:new) }
+end

data/spec/support_specs/module_extensions_spec.rb

@@ -0,0 +1,117 @@
+require_relative 'spec_helper'
+
+describe ModuleExtensions do
+  before do
+    @class = Class.new do
+      extend ModuleExtensions
+      attr_accessor_with_default :acc, {a: 2}
+      cattr_reader :read1, :read2
+      cattr_writer :write1, :write2
+      cattr_accessor :both1, :both2
+      cattr_accessor_with_default :arr1, []
+      def even?(x)
+        x % 2 == 0
+      end
+      opposite_method :odd?, :even?
+    end
+  end
+
+  describe 'attr_accessor_with_default' do
+    it 'creates an reader that defaults to the provided value' do
+      @class.new.acc.should == {a: 2}
+    end
+    
+    it 'creates a writer that causes the default to be lost forever' do
+      x = @class.new
+      x.acc = {b: 3}
+      x.acc.should == {b: 3}
+    end
+  end
+
+  describe '#cattr_reader' do
+    it 'creates reading methods for the given variables' do
+      @class.__send__(:instance_variable_set, :@read1, 'hello')
+      @class.read1.should == 'hello'
+      @class.__send__(:instance_variable_set, :@read2, 5)
+      @class.read2.should == 5
+    end
+  end
+
+  describe '#cattr_writer' do
+    it 'creates writing methods for the given variables' do
+      @class.write1 = 'hello'
+      @class.__send__(:instance_variable_get, :@write1).should == 'hello'
+      @class.write2 = 5
+      @class.__send__(:instance_variable_get, :@write2).should == 5
+    end
+  end
+
+  describe '#cattr_accessor' do
+    it 'creates reading and writing methods for the given variables' do
+      @class.both1 = 'hello'
+      @class.both1.should == 'hello'
+      @class.__send__(:instance_variable_get, :@both1).should == 'hello'
+      @class.__send__(:instance_variable_set, :@both1, 'world')
+      @class.both1.should == 'world'
+      @class.both2 = 5
+      @class.both2.should == 5
+      @class.__send__(:instance_variable_get, :@both2).should == 5
+      @class.__send__(:instance_variable_set, :@both2, 10)
+      @class.both2.should == 10
+    end
+  end
+
+  describe '#cattr_accessor_with_default' do
+    it 'creates reading and writing methods, but defaults the ivar value' do
+      @class.arr1.should == []
+      @class.__send__(:instance_variable_get, :@arr1).should == []
+      @class.arr1.should == [] # second invocation, after default value set
+      @class.arr1 = [1, 2]
+      @class.arr1.should == [1, 2]
+      @class.__send__(:instance_variable_get, :@arr1).should == [1, 2]
+    end
+  end
+
+  describe '#cattr_get_and_setter' do
+    before do
+      @base = Class.new do
+        extend ModuleExtensions
+        cattr_get_and_setter :type
+        type :silly
+      end
+    end
+
+    it 'acts a setter and getter on the base class' do
+      @base.type.should == :silly
+    end
+
+    it 'is not inherited' do
+      @derived = Class.new(@base)
+      @derived.type.should_not == :silly
+    end
+
+    it 'can be used by inherited classes' do
+      @derived = Class.new(@base) do
+        type :laughable
+      end
+      @derived.type.should == :laughable
+      @base.type.should == :silly
+    end
+
+    it 'turns a block into a proc and sets it' do
+      @derived = Class.new(@base) do
+        type { 5 + 3 }
+      end
+      @derived.type.call.should == 8
+    end
+  end
+  
+  describe '#opposite_method' do
+    it 'creates a new method that is the opposite of the specified method' do
+      @class.new.even?(4).should be true
+      @class.new.odd?(4).should be false
+      @class.new.even?(1).should be false
+      @class.new.odd?(1).should be true
+    end
+  end
+end

data/spec/support_specs/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../spec_helper'

data/spec/type_specs/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../spec_helper'

data/spec/type_specs/types_spec.rb

@@ -0,0 +1,133 @@
+require_relative 'spec_helper'
+
+describe Types do
+  describe '.subtype?' do
+    describe 'invariant class types' do
+      it 'should include itself' do
+        Types.subtype?(Types::ClassType.new('Integer', :invariant),
+                       Types::ClassType.new('Integer', :invariant)).should be true
+      end
+      
+      it 'should not include subclasses' do
+        Types.subtype?(Types::ClassType.new('Fixnum', :invariant),
+                       Types::ClassType.new('Integer', :invariant)).should be false
+      end
+      
+      it 'should not include superclasses' do
+        Types.subtype?(Types::ClassType.new('Numeric', :invariant),
+                       Types::ClassType.new('Integer', :invariant)).should be false
+      end
+    end
+    
+    describe 'covariant class types' do
+      it 'should include itself' do
+        Types.subtype?(Types::ClassType.new('Integer', :invariant),
+                       Types::ClassType.new('Integer', :covariant)).should be true
+      end
+      
+      it 'should include subclasses' do
+        Types.subtype?(Types::ClassType.new('Fixnum', :invariant),
+                       Types::ClassType.new('Integer', :covariant)).should be true
+      end
+      
+      it 'should not include superclasses' do
+        Types.subtype?(Types::ClassType.new('Numeric', :invariant),
+                       Types::ClassType.new('Integer', :covariant)).should be false
+      end
+      
+      it 'should include a union of subclasses' do
+        Types.subtype?(Types::UnionType.new(
+                         [Types::ClassType.new('Integer', :invariant),
+                          Types::ClassType.new('Float',  :invariant)]),
+                       Types::ClassType.new('Numeric', :covariant)).should be true
+      end
+    end
+
+    describe 'contravariant class types' do
+      it 'should include itself' do
+        Types.subtype?(Types::ClassType.new('Integer', :invariant),
+                       Types::ClassType.new('Integer', :contravariant)).should be true
+      end
+      
+      it 'should not include subclasses' do
+        Types.subtype?(Types::ClassType.new('Fixnum', :invariant),
+                       Types::ClassType.new('Integer', :contravariant)).should be false
+      end
+      
+      it 'should include superclasses' do
+        Types.subtype?(Types::ClassType.new('Numeric', :invariant),
+                       Types::ClassType.new('Integer', :contravariant)).should be true
+      end
+    end
+    
+    describe 'union types' do
+      it 'should include member types' do
+        Types.subtype?(Types::ClassType.new('Integer', :invariant),
+                       Types::UnionType.new(
+                         [Types::ClassType.new('Integer', :invariant),
+                          Types::ClassType.new('String',  :invariant)])).should be true
+      end
+    end
+  end
+  describe Types::TOP do
+    it 'should be equal to a covariant BasicObject instance' do
+      Types::TOP.should == Types::ClassType.new('BasicObject', :covariant)
+    end
+  end
+  
+  describe Types::UnionType do
+    it 'should compare equal despite member type ordering' do
+      Types::UnionType.new([Types::STRING, Types::FIXNUM, Types::ARRAY]).should ==
+        Types::UnionType.new([Types::ARRAY, Types::STRING, Types::FIXNUM])
+    end
+  end
+
+  describe Types::ClassType do
+    describe '#possible_classes' do
+      it 'should find subclasses if the ClassType is covariant and is a Class' do
+        Types::ClassType.new('Integer', :covariant).possible_classes.should be_superset(
+            ::Set[ClassRegistry['Integer'], ClassRegistry['Fixnum'], ClassRegistry['Bignum']])
+      end
+      
+      it 'should find the exact class ClassType is invariant and is a Class' do
+        Types::ClassType.new('Integer', :invariant).possible_classes.should ==
+            ::Set[ClassRegistry['Integer']]
+      end
+      
+      it 'should find superclasses if the ClassType is invariant and is a Class' do
+        Types::ClassType.new('Fixnum', :contravariant).possible_classes.should ==
+            ::Set[ClassRegistry['Fixnum'], ClassRegistry['Integer'], ClassRegistry['Numeric'],
+                  ClassRegistry['Object'], ClassRegistry['BasicObject']]
+      end
+      
+      it 'should find classes including the module if the ClassType is covariant and is a Module' do
+        Types::ClassType.new('Kernel', :covariant).possible_classes.should ==
+            ::Set.new(ClassRegistry['Object'].subset)
+        comparables = Types::ClassType.new('Comparable', :covariant).possible_classes
+        %w(String Numeric Integer Fixnum Bignum Float).each do |comparable|
+          comparables.should include(ClassRegistry[comparable])
+        end
+      end
+    end
+    
+    describe '#matching_methods' do
+      it 'should search the possible classes for instance methods of the same name (covariant)' do
+        Types::ClassType.new('Integer', :covariant).matching_methods('modulo').should ==
+            [ClassRegistry['Numeric'].instance_method(:modulo),
+             ClassRegistry['Fixnum'].instance_method(:modulo),
+             ClassRegistry['Bignum'].instance_method(:modulo)]
+      end
+      
+      it 'should search the possible classes for instance methods of the same name (invariant)' do
+        Types::ClassType.new('Integer', :invariant).matching_methods('odd?').should ==
+            [ClassRegistry['Integer'].instance_method(:odd?)]
+      end
+      
+      it 'should search the possible classes for instance methods of the same name (contravariant)' do
+        Types::ClassType.new('Bignum', :contravariant).matching_methods('odd?').should ==
+            [ClassRegistry['Bignum'].instance_method(:odd?),
+             ClassRegistry['Integer'].instance_method(:odd?)]
+      end
+    end
+  end
+end

data/spec/warning_spec.rb

@@ -0,0 +1,95 @@
+require_relative 'spec_helper'
+
+describe Warning do
+  describe 'when subclassed' do
+    it 'registers the new class in all_warnings' do
+      klass = Class.new(Warning)
+      Warning.all_warnings.should include(klass)
+    end
+  end
+
+  it 'does not match anything' do
+    Warning.should_not warn('hello(world)')
+    Warning.should_not warn(' a +b  ')
+  end
+
+  describe 'short names in warnings' do
+    before do
+      @real_warnings = Warning.all_warnings.select do |x|
+        x.name && x != Warning && x != FileWarning && x != LineWarning
+      end
+    end
+
+    it 'exist for every warning class' do
+      @real_warnings.select {|x| x.name && x.short_name == nil}.should be_empty
+    end
+
+    it 'do not conflict with each other' do
+      short_names = @real_warnings.map {|x| x.short_name}.uniq
+      short_names.size.should == @real_warnings.size
+    end
+  end
+
+  it 'does not change lines when it fixes them' do
+    Warning.should correct_to('a+b', 'a+b')
+    Warning.should correct_to(' b **   c+1 eval(string) ', ' b **   c+1 eval(string) ')
+  end
+
+  describe '#concrete_warnings' do
+    before { @concrete = Warning.concrete_warnings }
+    it 'returns a list of classes that are subclasses of Warning' do
+      @concrete.should_not be_empty
+      @concrete.each {|w| w.ancestors.should include(Warning) }
+    end
+    
+    it 'returns a list that does not contain Warning, FileWarning, or LineWarning' do
+      @concrete.should_not include(Warning)
+      @concrete.should_not include(FileWarning)
+      @concrete.should_not include(LineWarning)
+    end
+  end
+
+  describe '#desc' do
+    it "defaults to the class's name with all info" do
+      warning = Warning.new('hello.rb', 'a+b')
+      warning.severity = 7
+      warning.line_number = 3
+      warning.desc.should == 'Laser::Warning hello.rb:3 (7)'
+    end
+
+    it 'when specified in a subclass as a string, just uses the string' do
+      subclass = Class.new(Warning) { desc 'hello' }
+      subclass.new('a', 'b').desc.should == 'hello'
+    end
+
+    it 'when specified in a subclass as a block, runs that proc as the instance' do
+      subclass = Class.new(Warning) do
+        severity 1024
+        desc { self.class.severity.to_s }
+      end
+      subclass.new('a', 'b').desc.should == '1024'
+    end
+  end
+
+  describe '#type' do
+    it 'returns the current type when no args are provided' do
+      klass = Class.new(Warning) do
+        def self.set_type
+          @type = 'hai'
+        end
+      end
+      klass.set_type
+      klass.type.should == 'hai'
+    end
+
+    it 'sets the type when an argument is provided' do
+      klass = Class.new(Warning) { type :silly }
+      klass.type.should == 'silly'
+    end
+
+    it 'sets a short name based on the type provided' do
+      klass = Class.new(Warning) { type :silly }
+      klass.short_name.should =~ /SI\d/
+    end
+  end
+end