context 0.0.16 → 0.0.22

data/lib/Context/ExecutionProxy.rb

@@ -1,61 +0,0 @@
-module Context
-
-    # A Proxy for carrying on conditional execution.
-    class ExecutionProxy
-        # Set the true object on which to execute and the condition to execute.
-        # NOTE: The condition is a bool.  In other words it has *already*
-        # been evaluated before we get to this point.
-        def initialize(object, cond)
-            @object = object
-            @cond = cond
-        end
-        
-        # Conditionally execute the block.  If the condition is true,
-        # execute the block.  Otherwise return the true object.
-        # NOTE: Crazy name is so that you don't have something with
-        # the same name and accidently call it with method_missing.
-        def execute_if_you_can(&block)
-            if @cond
-                @object.instance_eval(&block)
-            else
-                @object
-            end
-        end
-        
-        # Conditionally evaluate the symbol.  If the condition is true,
-        # evaluate the symbol.  Otherwise return the true object.
-        def method_missing(symbol)
-            if @cond
-                @object.instance_eval(symbol.to_s)
-            else
-                @object
-            end
-        end
-    end
-end
-
-class Object
-
-    # Execute the block if the condition is *true*.  Or if there is no
-    # block, then return the proxy object.  Usually this is so you
-    # can say something like:
-    # * object.execute_if(condition).property
-    # If the condition is *false*, execution of the block, or evaluation
-    # of the property will return the original object.
-    def execute_if(cond, &block)
-        proxy = Context::ExecutionProxy.new(self, cond)
-        # Note: Wouldn't it be nice if the following could be replaced by
-        # proxy.execute_if(!block.nil) do execute_if_you_can(&block) end
-        proxy_if_block_exists = Context::ExecutionProxy.new(proxy, !block.nil?)
-        proxy_if_block_exists.execute_if_you_can() do 
-            execute_if_you_can(&block) 
-        end
-    end
-    
-    # If the object is not nil, execute the block (or evaluate
-    # the property).  Otherwise return nil.
-    def unless_nil(&block)
-        execute_if(!nil?, &block)
-    end
-end
-

data/lib/Context/Gtk/Key.rb

@@ -1,54 +0,0 @@
-require 'Context/Key'
-require 'gtk2'
-
-module Context::Gtk
-
-	class Key < Context::Key
-		
-		def Key::getModifierFromEvent(event)
-			case event.state
-                when 0
-                    Context::Key::Modifier::NONE
-				when Gdk::Window::CONTROL_MASK
-					Context::Key::Modifier::CONTROL
-				else
-					Context::Key::Modifier::ERROR
-			end
-		end
-		
-		def getGtkState
-			case @modifier
-				when Context::Key::Modifier::CONTROL
-					Gdk::Window::CONTROL_MASK
-				else
-				    0
-			end
-		end
-		
-		def Key::getCharacterFromEvent(event)
-            Gdk::Keyval::to_name(event.keyval)
-		end
-		
-		def getGtkKeyval
-            Gdk::Keyval::from_name(@character)
-		end
-		
-		def Key::createFromGtkEvent(event)
-			modifier = getModifierFromEvent(event)
-			character = getCharacterFromEvent(event)
-			if((modifier != Context::Key::Modifier::ERROR) && 
-               (!character.nil?))
-				Key.new(modifier, character)
-			else
-				Key.null
-			end
-		end
-		
-		def createGtkEvent
-			event = Gdk::EventKey.new(Gdk::Event::KEY_PRESS)
-			event.set_state(getGtkState)
-			event.set_keyval(getGtkKeyval)
-			event
-		end					
-	end
-end

data/lib/Context/Key.rb

@@ -1,57 +0,0 @@
-require 'Context/EnumeratedType'
-
-module Context
-
-    # Represents a keypress.  Each key is represented
-    # by a character and a modifier (e.g., the control
-    # key)
-    #
-    # One could argue that this doesn't deserve to be
-    # here at all.  It is possible that some UI types
-    # won't have a keyboard at all.  However given that
-    # most will operate the same way indicates that
-    # it should have some level of abstraction.  I have
-    # a feeling that this is YAGNI, though.  And as such
-    # it might disappear at any point.
-	class Key
-	    # Types of key modifiers. Currently only
-	    # control or none is supported.
-		class Modifier < EnumeratedType
-			start_at 0
-			symbols [:ERROR, :NONE, :CONTROL]
-		end
-	
-		attr_reader :modifier, :character
-		
-		def initialize(modifier, character)
-			@modifier = modifier
-			@character = character
-		end	
-		
-		# A non key that can be used as an error condition.
-		# Note: Perhaps this should be a constant???  Currently
-		# key.eql?(Key.null) will work, but key == Key.null
-		# won't.  FIXME
-		def Key.null
-			Key.new(Modifier.NONE, '\0')
-		end	
-		
-		# Returns true if the two keys have the same character and modifier.
-		def eql?(key)
-			(@modifier == key.modifier) && (@character == key.character)
-		end
-
-        # Creates a hash for the key.  This is needed for the KeyMap
-        # which is implemented as a hash.		
-		def hash
-			hashValue = @modifier.to_s
-			hashValue += @character
-			hashValue.hash
-		end
-
-        # Returns true if the key is equal to Key.null.		
-		def null?
-			eql?(Key.null)
-		end
-	end
-end

data/lib/Context/KeyAssignment.rb

@@ -1,31 +0,0 @@
-require 'Context/Key'
-
-module Context
-
-    # Represents the assignment of an action to a key press
-    class KeyAssignment
-        attr_reader :action
-        
-        # Creates an assignment where action will be called when key is pressed
-        def initialize(key, &action)
-            @key = key
-            @action = action
-        end
-        
-        # Returns true if this KeyAssignment has an action assigned for key
-        def handles?(key)
-            @key.eql?(key)
-        end
-        
-        # Run the action assigned to key if there is one.  Returns true if
-        # an action was run, false otherwise
-        def try(key)
-            if handles?(key)
-                @action.call
-                true
-            else
-                false
-            end
-        end
-    end
-end

data/lib/Context/KeyMap.rb

@@ -1,43 +0,0 @@
-require 'Context/Key'
-require 'Context/KeyAssignment'
-
-module Context
-
-    # Represents a map of key strokes to actions
-    class KeyMap
-
-        def initialize
-            @list = []
-        end
-
-        # Add a KeyAssignment to the map
-        def add(assignment)
-            @list.push(assignment)
-        end
-
-        # Returns the assignment that handles this key or nil if it doesn't
-        # exist
-        def findKey(key)
-            @list.find do |a|
-                a.handles?(key)
-            end
-        end
-        
-        # Returns true if this map can handle the key.  Otherwise false.
-        def handles?(key)
-            !findKey(key).nil?
-        end
-        
-        # Press the key and run the associated action, if it exits.
-        # Returns true if an action was run, false otherwise.
-        def press(key)
-            assignment = findKey(key)
-            if !assignment.nil?
-                assignment.try(key)
-            else
-                false
-            end
-        end
-    end
-
-end

data/spec/Context/EnumeratedType_spec.rb

@@ -1,51 +0,0 @@
-require 'Context/EnumeratedType'
-
-module Context
-
-	class A < EnumeratedType
-		symbols [:Zero]
-	end
-	
-	class B < EnumeratedType
-		symbols [:Zero,	:One, :Two]
-	end
-	
-	class C < EnumeratedType
-		start_at 5
-		symbols [:Five, :Six, :Seven]
-	end
-
-	describe EnumeratedType do
-
-		it "should start at 0 by default" do
-			A.Zero.should eql(0)
-		end
-		
-		it "should increment by one for each value" do
-			B.Zero.should eql(0)
-			B.One.should eql(1)
-			B.Two.should eql(2)
-		end
-		
-		it "should start at the number specified" do
-			C.Five.should eql(5)
-			C.Six.should eql(6)
-			C.Seven.should eql(7)
-		end
-		
-		it "should only respond to the names of the defined symbols" do
-			A.responds_to?(:Zero).should be(true)		
-			B.responds_to?(:Zero).should be(true)		
-			B.responds_to?(:One).should be(true)		
-			B.responds_to?(:Two).should be(true)		
-			C.responds_to?(:Five).should be(true)		
-			C.responds_to?(:Six).should be(true)
-			C.responds_to?(:Seven).should be(true)
-			# This is strange that it returns nil, but there isn't any
-			# documentation of responds_to?, so I guess that's what's supposed to
-			# happen.
-			A.responds_to?(:One).should be(nil)		
-			C.responds_to?(:Zero).should be(nil)		
-		end
-	end
-end

data/spec/Context/ExecutionProxy_spec.rb

@@ -1,28 +0,0 @@
-require 'Context/ExecutionProxy'
-
-module Context
-
-	describe ExecutionProxy do
-	
-	    it "should execute methods" do
-	        a = nil
-	        a.unless_nil.fake.should be(nil)
-	        
-	        a = 5
-	        a.unless_nil.self.should be(5)
-	    end
-	    
-	    it "should execute code blocks" do
-	        a = nil
-	        a.unless_nil do
-	            fake
-	        end.should be(nil)
-	        
-	        a = 5
-	        a.unless_nil do
-	            self
-	        end.should be(5)
-	    end
-	end
-end
-

data/spec/Context/Gtk/Key_spec.rb

@@ -1,45 +0,0 @@
-require 'Context/Gtk/Key'
-
-module Context::Gtk
-
-	describe Key do
-	
-		it "should have a factory method to convert from a GTK KeyPressEvent and back" do
-			event = Gdk::EventKey.new(Gdk::Event::KEY_PRESS)
-			event.set_state(Gdk::Window::CONTROL_MASK)
-			event.set_keyval(Gdk::Keyval::GDK_o)
-			
-			key = Key.createFromGtkEvent(event)
-			key.should_not be_nil
-			key.should eql(Key.new(Context::Key::Modifier::CONTROL, 'o'))
-			key.getGtkState.should be_eql(Gdk::Window::CONTROL_MASK)
-			key.getGtkKeyval.should be_eql(Gdk::Keyval::GDK_o)
-			e = key.createGtkEvent
-			e.state.should be_eql(Gdk::Window::CONTROL_MASK)
-			e.keyval.should be_eql(Gdk::Keyval::GDK_o)
-		end
-
-		it "should convert characters with no modifier and back" do
-			event = Gdk::EventKey.new(Gdk::Event::KEY_PRESS)
-			event.set_state(0)
-			event.set_keyval(Gdk::Keyval::GDK_Tab)
-			
-			key = Key.createFromGtkEvent(event)
-			key.should_not be_nil
-			key.should eql(Key.new(Context::Key::Modifier::NONE, 'Tab'))
-			e = key.createGtkEvent
-			e.state.should be_eql(0)
-			e.keyval.should be_eql(Gdk::Keyval::GDK_Tab)
-		end
-		
-		it "should create a null character if it doesn't know how to make it" do
-			event = Gdk::EventKey.new(Gdk::Event::KEY_PRESS)
-			event.set_state(Gdk::Window::META_MASK)
-			event.set_keyval(Gdk::Keyval::GDK_q)
-
-			key = Key.createFromGtkEvent(event)
-			key.should_not be_nil
-			key.should be_null
-		end		
-	end
-end

data/spec/Context/KeyAssignment_spec.rb

@@ -1,26 +0,0 @@
-require 'Context/Key'
-require 'Context/KeyAssignment'
-
-module Context
-
-	describe KeyAssignment do
-
-        it "should have a key and a proc" do
-            run = false
-            ctlD = Key.new(Key::Modifier.CONTROL, 'd')
-            d = Key.new(Key::Modifier.NONE, 'd')
-            ka = KeyAssignment.new(ctlD) do
-                run = true
-            end
-            newCtlD = Key.new(Key::Modifier.CONTROL, 'd')
-            newD = Key.new(Key::Modifier.NONE, 'd')
-            ka.handles?(newD).should be(false)
-            ka.handles?(newCtlD).should be(true)
-            ka.try(newD).should be(false)
-            run.should be(false)
-            ka.try(newCtlD).should be(true)
-            run.should be(true)
-        end
-
-    end
-end

data/spec/Context/KeyMap_spec.rb

@@ -1,64 +0,0 @@
-require 'Context/Key'
-require 'Context/KeyAssignment'
-require 'Context/KeyMap'
-
-module Context
-
-	describe KeyMap do
-	    
-	    before(:each) do
-	        @map = KeyMap.new
-	        @ctlD = Key.new(Key::Modifier.CONTROL, 'd')
-	        @ctlDPressed = false
-	        @ctlDAssignment = KeyAssignment.new(@ctlD) do
-	            @ctlDPressed = true
-	        end
-	        @d = Key.new(Key::Modifier.NONE, 'd')
-	        @dPressed = false
-	        @dAssignment = KeyAssignment.new(@ctlD) do
-	            @dPressed = true
-	        end
-	        @newCtlD = Key.new(Key::Modifier.CONTROL, 'd')
-	        @newD = Key.new(Key::Modifier.NONE, 'd')
-	    end
-	    
-	    it "should be able to contain a KeyAssignment" do
-	        @map.handles?(@newCtlD).should be(false)
-	        @map.handles?(@newD).should be(false)
-	        @map.add(@ctlDAssignment)
-	        @map.handles?(@newCtlD).should be(true)
-	        @map.handles?(@newD).should be(false)
-	    end
-	    
-	    it "should be able to contain many KeyAssignments" do
-	        @map.handles?(@newCtlD).should be(false)
-	        @map.handles?(@newD).should be(false)
-	        @map.add(@ctlDAssignment)
-	        @map.handles?(@newCtlD).should be(true)
-	        @map.handles?(@newD).should be(false)
-	        @map.add(@dAssignment)
-	        @map.handles?(@newD).should be(false)
-	    end
-	    
-	    it "should be able to press a key" do
-	        @map.add(@ctlDAssignment)
-	        @map.add(@dAssignment)
-	        @ctlDPressed.should be(false)
-	        @dPressed.should be(false)
-	        @map.press(@newCtlD).should be(true)
-	        @ctlDPressed.should be(true)
-	        @dPressed.should be(false)
-	    end
-	    
-	    it "should return false if a non-handled key is pressed" do
-	        @map.add(@ctlDAssignment)
-	        @ctlDPressed.should be(false)
-	        @dPressed.should be(false)
-            @map.handles?(@d).should be(false)
-            @map.press(@d).should be(false)	    
-	        @dPressed.should be(false)
-	        @ctlDPressed.should be(false)
-	    end
-	    
-    end
-end