lebowski 0.1.0

data/lib/lebowski/scui/views/linkit.rb

@@ -0,0 +1,36 @@
+module Lebowski
+  module SCUI
+    module Views
+
+      class CanvasView < Lebowski::Foundation::Views::CollectionView        
+        representing_sc_class 'LinkIt.CanvasView'
+        
+        def nodes
+          return item_views
+        end
+        
+        def empty?
+          return self['isEmpty']
+        end
+        
+        protected
+          def create_item_views_object_array()
+            return Support::NodeItemViewArray.new self
+          end
+      end
+
+      module Support
+        
+        class NodeItemViewArray < Lebowski::Foundation::Views::Support::CollectionItemViewArray
+          def mix_in_support_for_object(obj)
+            if not obj.class.ancestors.member? Lebowski::SCUI::Mixins::NodeItemViewSupport            
+              obj.extend Lebowski::SCUI::Mixins::NodeItemViewSupport
+            end
+          end
+        end
+        
+      end
+
+    end
+  end
+end

data/lib/lebowski/spec.rb

@@ -0,0 +1,17 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+require File.expand_path(File.dirname(__FILE__) + '/../lebowski')
+require File.expand_path(File.dirname(__FILE__) + '/spec/core')
+require File.expand_path(File.dirname(__FILE__) + '/spec/util')
+require File.expand_path(File.dirname(__FILE__) + '/spec/operators/operator')
+require File.expand_path(File.dirname(__FILE__) + '/spec/operators/that')
+require File.expand_path(File.dirname(__FILE__) + '/spec/matchers/match_supporters/match_supporter')
+require File.expand_path(File.dirname(__FILE__) + '/spec/matchers/match_supporters/has_object_function')
+require File.expand_path(File.dirname(__FILE__) + '/spec/matchers/match_supporters/has_predicate_with_no_prefix')
+require File.expand_path(File.dirname(__FILE__) + '/spec/matchers/match_supporters/has_predicate_with_prefix_has')
+require File.expand_path(File.dirname(__FILE__) + '/spec/matchers/be')
+require File.expand_path(File.dirname(__FILE__) + '/spec/matchers/has')
+require File.expand_path(File.dirname(__FILE__) + '/spec/matchers/method_missing')

data/lib/lebowski/spec/core.rb

@@ -0,0 +1,21 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+#
+# matcher is to only be applied to an object that derives from 
+# Lebowksi::Foundation::Object class otherwise an exception will
+# be raised
+#
+# Usage: 
+#
+#   myobject.should exist_in_app => myobject.exists? == true
+#   myobject.should_not exist_in_app => myobject.exists? == false
+#
+Spec::Matchers.define :exist_in_app do
+  match do |object|
+    object.exists?
+  end
+end
+    

data/lib/lebowski/spec/matchers/be.rb

@@ -0,0 +1,63 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+module Lebowski
+  module Spec
+    module Matchers
+      
+      #
+      # Create owr own Be class that inherits from RSpec's Be class. This class
+      # adds some logic to check for predicates that have a prefix is_. If
+      # there is no such prefix then we hand back control to parent class to
+      # apply the default pattern matching
+      #
+      # We are trying to accomplish the following:
+      #
+      #   myobject.should be_orange ==> myobject.is_orange? == true
+      #
+      # RSpec's default implementation of Be does not support checks for the is_
+      # prefix.
+      #
+      # Ideally, it would've been better if the original class had hooks in it
+      # to try custom patterns before ultimately applying the default pattern
+      # checks
+      #
+      class Be < ::Spec::Matchers::BePredicate
+        
+        def matches?(actual)
+          
+          begin
+            return @result = actual.__send__("is_#{@expected.to_s}?".to_sym, *@args)
+          rescue NoMethodError => nme
+          rescue ArgumentError => ae
+          end
+          
+          begin
+            return @result = actual.__send__("#{@expected.to_s}?".to_sym, *@args)
+          rescue NoMethodError => nme
+          rescue ArgumentError => ae
+          end
+          
+          begin
+            return @result = actual.__send__("is_#{@expected.to_s}".to_sym, *@args)
+          rescue NoMethodError => nme
+          rescue ArgumentError => ae
+          end
+          
+          begin
+            return @result = actual.__send__(@expected, *@args)
+          rescue NoMethodError => nme
+          rescue ArgumentError => ae
+          end
+          
+          # None of the above options worked. Now we can default back to the
+          # parent object's approach
+          super
+        end
+      
+      end
+    end
+  end
+end

data/lib/lebowski/spec/matchers/has.rb

@@ -0,0 +1,40 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+module Lebowski
+  module Spec
+    module Matchers
+      
+      #
+      # Create owr own Has class that inherits from RSpec's Has class. This class
+      # adds some logic to check if the given "actual" object has a property with
+      # the name extracted from @expected. If not, then pass control back to the
+      # parent class.
+      #
+      # Ideally it would have been better if the original Has class provided hooks
+      # to include custom pattern checks that are used before the default pattern
+      # checks are performed.
+      #
+      class Has < ::Spec::Matchers::Has
+      
+        def matches?(actual)
+          support = HasPredicateWithPrefixHas.new(actual, @expected, *@args)
+          return support.result if support.has_match? 
+
+          support = HasPredicateWithNoPrefix.new(actual, @expected, *@args)
+          return support.result if support.has_match?
+          
+          support = HasObjectFunction.new(actual, @expected, *@args)
+          return support.result if support.has_match?
+          
+          # None of the above options worked. Now we can default back to the
+          # parent object's approach
+          super
+        end
+        
+      end
+    end
+  end
+end

data/lib/lebowski/spec/matchers/match_supporters/has_object_function.rb

@@ -0,0 +1,67 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+module Lebowski
+  module Spec
+    module Matchers
+      
+      class HasObjectFunction < MatchSupporter
+      
+        def has_match?()
+          
+          return false if @args.length == 0 
+          
+          method_name = obj_property(@expected)
+          
+          ret_val = nil
+          invoked_method = false
+          
+          # Try with arguments
+          begin
+            args = @args.clone; args.pop
+            ret_val = @object.__send__(method_name, *args)
+            invoked_method = true
+          rescue NoMethodError => nme
+          rescue ArgumentError => ae
+          end
+          
+          # Try with no arguments
+          begin
+            if not invoked_method
+              ret_val = @object.__send__(method_name)
+              invoked_method = true
+            end
+          rescue NoMethodError => nme
+          rescue ArgumentError => ae
+          end
+            
+          return false if not invoked_method
+          
+          operator = @args[@args.length - 1]
+          if operator.kind_of? Lebowski::Spec::Operators::Operator
+            @result = operator.evaluate(ret_val) 
+            return true
+          end
+          
+          @result = Lebowski::Spec::Util.match?(@args[@args.length - 1], ret_val)
+          
+          return true
+          
+        end
+        
+      private
+      
+        def obj_property(sym)
+          ["has_", "have_"].each do |prefix|
+            if sym.to_s =~ /^#{prefix}/
+              return sym.to_s.sub(prefix, "").to_sym
+            end
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/lebowski/spec/matchers/match_supporters/has_predicate_with_no_prefix.rb

@@ -0,0 +1,50 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+module Lebowski
+  module Spec
+    module Matchers
+      
+      class HasPredicateWithNoPrefix < MatchSupporter
+        
+        def has_match?()
+          
+          executed_method = false
+          
+          method_name = predicate_with_no_prefix(@expected)
+          
+          # Try with arguments
+          begin
+            @result = @object.__send__(method_name, *@args)
+            executed_method = true
+          rescue NoMethodError => nme
+          rescue ArgumentError => ae
+          end
+          
+          return true if executed_method
+          
+          # Try with no arguments
+          begin
+            @result = @object.__send__(method_name)
+            executed_method = true
+          rescue NoMethodError => nme
+          rescue ArgumentError => ae
+          end
+          
+          return executed_method
+          
+        end
+    
+      private
+      
+        def predicate_with_no_prefix(sym)
+          return (sym.to_s.sub('have_', '') << '?').to_sym
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/lebowski/spec/matchers/match_supporters/has_predicate_with_prefix_has.rb

@@ -0,0 +1,50 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+module Lebowski
+  module Spec
+    module Matchers
+      
+      class HasPredicateWithPrefixHas < MatchSupporter
+        
+        def has_match?()
+          
+          executed_method = false
+          
+          method_name = predicate_with_prefix_has(@expected)
+          
+          # Try with arguments
+          begin
+            @result = @object.__send__(method_name, *@args)
+            executed_method = true
+          rescue NoMethodError => nme
+          rescue ArgumentError => ae
+          end
+          
+          return true if executed_method
+          
+          # Try with no arguments
+          begin
+            @result = @object.__send__(method_name)
+            executed_method = true
+          rescue NoMethodError => nme
+          rescue ArgumentError => ae
+          end
+          
+          return executed_method
+          
+        end
+        
+      private
+        
+        def predicate_with_prefix_has(sym)
+          return (sym.to_s.sub('have_', 'has_') << '?').to_sym
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/lebowski/spec/matchers/match_supporters/match_supporter.rb

@@ -0,0 +1,29 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+module Lebowski
+  module Spec
+    module Matchers
+      
+      class MatchSupporter
+        
+        attr_reader :result
+        
+        def initialize(object, expected, *args)
+          @object = object
+          @expected = expected
+          @args = args
+          @result = nil
+        end
+        
+        def has_match?()
+          return false
+        end
+        
+      end
+    
+    end
+  end
+end

data/lib/lebowski/spec/matchers/method_missing.rb

@@ -0,0 +1,24 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+module Spec
+  module Matchers
+    
+    #
+    # Replacing RSpec's default method_missing implementation so that we can 
+    # include our own special default hooks that allows spec tests to look
+    # more readable. 
+    #
+    # Ideally it would have been better if RSpec provided some nice hooks to 
+    # try other default pattern matchers
+    #
+    def method_missing(sym, *args, &block)
+      return Lebowski::Spec::Matchers::Be.new(sym, *args) if sym.to_s =~ /^be_/
+      return Lebowski::Spec::Matchers::Has.new(sym, *args) if sym.to_s =~ /^have_/
+      return Lebowski::Spec::Operators::That.new(sym, *args) if sym.to_s =~ /^that_/      
+      super
+    end
+  end
+end

data/lib/lebowski/spec/operators/operator.rb

@@ -0,0 +1,20 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+module Lebowski
+  module Spec
+    module Operators
+      
+      class Operator
+        
+        def evaluate(value)
+          
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/lebowski/spec/operators/that.rb

@@ -0,0 +1,116 @@
+# ==========================================================================
+# Project:   Lebowski Framework - The SproutCore Test Automation Framework
+# License:   Licensed under MIT license (see License.txt)
+# ==========================================================================
+
+module Lebowski
+  module Spec
+    module Operators
+
+      class That < Operator
+        
+        def initialize(sym, *args)
+          @sym = sym
+          @args = args
+        end
+        
+        def evaluate(value)
+          case operator
+          when :not_empty
+            return not_empty? value
+          when :empty
+            return empty? value
+          when :between
+            return between? value
+          when :at_most
+            return at_most? value
+          when :at_least
+            return at_least? value
+          when :greater_than
+            return greater_than? value
+          when :less_than
+            return less_than? value
+          when :contains
+            return contains? value
+          when :matches
+            return matches? value
+          when :equals
+            return equals? value
+          when :equal_to
+            return equals? value
+          else
+            raise ArgumentError "Invalid that operator: #{operator}"
+          end
+        end
+        
+        def operator()
+          ["that_is_", "that_"].each do |prefix|
+            if @sym =~ /^#{prefix}/
+              return @sym.to_s.sub(prefix, "").to_sym
+            end
+          end
+        end
+        
+        def method_missing(sym, *args, &block)
+          return self
+        end
+        
+      private
+        
+        def not_empty?(value)
+          return (not empty? value)
+        end
+        
+        def empty?(value)
+          return true if value.nil?
+          return value.length == 0 if value.kind_of?(Array) or value.kind_of?(String)
+          return false
+        end
+        
+        def between?(value)
+          return false if not value.kind_of? Numeric
+          min = @args[0]
+          max = @args[1]
+          return ((value >= min) and (value <= max))
+        end
+        
+        def at_least?(value)
+          return false if not value.kind_of? Numeric
+          return value >= @args[0]
+        end
+        
+        def at_most?(value)
+          return false if not value.kind_of? Numeric
+          return value <= @args[0]
+        end
+        
+        def greater_than?(value)
+          return false if not value.kind_of? Numeric
+          return value > @args[0]
+        end
+        
+        def less_than?(value)
+          return false if not value.kind_of? Numeric
+          return value < @args[0]
+        end
+          
+        def contains?(value)
+          return false if value.nil?
+          @args.all? do |x|
+            value.member? x
+          end
+        end
+        
+        def matches?(value)
+          return Lebowski::Spec::Util.match?(@args[0], value)
+        end
+        
+        def equals?(value)
+          return @args[0] == value
+        end
+        
+      end
+
+    end
+  end
+end