context 0.0.16

data/lib/Context/KeyAssignment.rb

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,43 @@
+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/lib/Context/Version.rb

@@ -0,0 +1,5 @@
+module Context
+
+	VERSION = "0.0.16"
+
+end

data/lib/Context/View.rb

@@ -0,0 +1,49 @@
+module Context
+
+	# This is the abstract view class
+	class View
+		attr_reader :context
+		def initialize(context)
+			@context = context
+		end
+		
+		def addView(view)
+			myWidget = getWidget()
+			if(myWidget != nil)
+				newWidget = view.getWidget()
+				if !newWidget.nil?
+    				myWidget.add(newWidget)
+    				newWidget.addedTo(myWidget)
+    		    end
+			end
+		end
+
+        def removeView(view)
+            myWidget = getWidget()
+            if(myWidget != nil)
+                oldWidget = view.getWidget()
+                if !oldWidget.nil?
+                    myWidget.remove(oldWidget)
+                    oldWidget.removedFrom(myWidget)
+                end
+            end
+        end
+		
+		# Concrete classes should override this method
+		def open
+		end
+		
+		# Concrete classes should override this method
+		def close
+		end
+
+		# Concrete classes should override this method
+		def getWidget
+			return nil
+		end
+
+		def notifyKey(widget, key)
+			@context.notifyKey(self, key)
+		end
+	end
+end

data/lib/Context/Views/Gtk/PageView.rb

@@ -0,0 +1,50 @@
+require 'Context/Views/PageView'
+require 'Context/Gtk/Key'
+require 'Context/Gtk/Widget'
+require 'gtk2'
+
+module Context::Gtk
+
+	class PageView < Context::PageView
+	
+		class MainWindow < Gtk::Window
+			def initialize(title, view)
+				super(title)
+				@view = view
+				connectSignals unless @view.nil?
+			end
+			
+			def connectSignals
+				signal_connect('destroy') do
+					closeView
+				end
+			end
+
+			def closeView
+				@view.close
+			end
+        end
+		
+		attr_reader :mainWindow
+	
+		def initialize(context, title="No Title")
+			super(context)
+			@mainWindow = MainWindow.new(title, self)
+			@mainWindow.set_default_size(600, 400)
+			@widget = Context::Gtk::Widget.new(@mainWindow)
+		end
+		
+		def open
+			@mainWindow.show_all
+			@mainWindow.grab_focus
+		end
+				
+		def getWidget
+			@widget
+		end
+		
+		def emitDestroyEvent
+			@mainWindow.signal_emit("destroy")
+		end
+	end
+end

data/lib/Context/Views/PageView.rb

@@ -0,0 +1,17 @@
+require 'Context/View'
+
+module Context
+	class PageView < View
+		def initialize(context)
+			super(context)
+		end
+		
+		# The page view is meant to be the main view for a context
+		# (in Gtk it's a window).  So if the view closes, it should
+		# close the context.  Actually, I'm not sure if I like this
+		# idea.  It might change.
+		def close
+			@context.close
+		end
+	end
+end

data/lib/Context/Widget.rb

@@ -0,0 +1,40 @@
+module Context
+
+	class Widget
+	
+		attr_reader :delegate
+	
+		def initialize(delegate)
+			@delegate = delegate
+		end
+		
+		# This method is called after the widget has been
+		# successfully added to another widget
+		def addedTo(widget)
+			# This is an abstract method, the child classes should
+			# implement this		    
+		end
+		
+		# This method is called after the widget has been
+		# successfully removed from another widget
+		def removedFrom(widget)
+			# This is an abstract method, the child classes should
+			# implement this		    
+		end
+		
+		# Use this widget as a container for the passed widget
+		def add(widget)
+			# This is an abstract method, the child classes should
+			# implement this
+		end
+	
+		def remove(widget)
+			# This is an abstract method, the child classes should
+			# implement this
+		end
+
+		def eql?(widget)
+			@delegate.eql?(widget.delegate)
+		end
+	end
+end

data/lib/Context/require_all.rb

@@ -0,0 +1,13 @@
+module Kernel
+
+	# Requires all the files that match the glob in the
+	# current load-path
+	def require_all(glob)
+		$:.each do |path|
+			Dir.glob(path + "/" + glob) do |file|
+				name = file.to_s.sub(path + "/", "")
+				require name
+			end
+		end
+	end
+end

data/spec/Context/Bridge_spec.rb

@@ -0,0 +1,40 @@
+require 'Context/Bridge'
+
+module Other
+    module Special
+        class Fun
+        end
+
+        class In
+        end
+    end
+end
+
+module Context::Special
+    class Fun
+    end
+end
+
+module Context
+    class Fun
+    end
+end
+
+module Excluded
+    class Sun
+    end    
+end
+
+module Context
+
+	describe Bridge do
+
+		it "should reference classes in the namespace provided" do
+			bridge = Bridge.new([Special, Other::Special])
+			
+			bridge.Fun.should be(Special::Fun)
+			bridge.In.should be(Other::Special::In)
+			bridge.Sun.should_not be(Excluded::Sun)
+		end
+	end
+end

data/spec/Context/Context_spec.rb

@@ -0,0 +1,102 @@
+require 'Context/Context'
+require 'Context/Bridge'
+require 'Context/View'
+
+module Context
+
+    class TestContext < Context
+        def initialize(bridge)
+            super(bridge)
+        end
+    
+        def createViews
+            @mainView = View.new(self)
+        end
+    end
+
+	describe Context do
+
+		before(:each) do
+		    @bridge = Bridge.new(TestContext)
+		    @parent = TestContext.new(@bridge)
+			@context = TestContext.new(@bridge)
+		end
+		
+		it "should not have a parent set on creation" do
+			@context.parent.should be_nil
+		end
+		
+		it "should set the parent on entry" do
+			@parent.createViews
+			@parent.should_receive(:addView)
+			@context.enter(@parent)
+			@context.parent.should equal(@parent)
+		end
+		
+		it "should add new views to the main view" do
+			newContext = TestContext.new(@bridge)
+			newContext.createViews
+			@context.createViews
+			@context.mainView.should_receive(:addView).with(newContext.mainView)
+
+			@context.addView(newContext.mainView)
+		end
+
+        it "should remove views on exit" do
+            @parent.createViews
+            @parent.mainView.should_receive(:removeView).with(@context.peekAtView)
+			@parent.should_receive(:addView)
+            @context.enter(@parent)
+            @context.exit
+        end
+        
+        it "should be able to set key bindings" do
+            key = Key.new(Key::Modifier.Control, 'k')
+            exit = Proc.new do
+                @context.exit
+            end
+            @context.getKeyBinding(key).should be_nil
+            @context.setKeyBinding(key, &exit)
+            @context.getKeyBinding(key).should be(exit)
+            @context.should_receive(:exit)
+            @context.notifyKey(mock("View"), key)
+        end
+        
+        it "should create the views on entry" do
+			@context.should_receive(:setupViews) do
+			    @context.createViews
+			end
+			@parent.should_receive(:addView)
+			@parent.createViews
+			@context.enter(@parent)
+        end
+
+        it "should destroy the views on exit" do
+            @parent.createViews
+			@context.should_receive(:setupViews).exactly(2).times do
+			    @context.createViews
+			end
+			@parent.should_receive(:addView)
+			@context.enter(@parent)
+            @parent.mainView.should_receive(:removeView).with(@context.peekAtView)
+			@context.should_receive(:destroyViews)
+			@context.exit
+        end
+        
+        it "should keep track if the context has been entered or not" do
+            @parent.createViews            
+			@context.should_receive(:setupViews).exactly(2).times do
+			    @context.createViews
+			end
+			@parent.should_receive(:addView)
+            @context.isEntered?.should be(false)
+            @context.enter(@parent)
+            @context.isEntered?.should be(true)
+            @parent.mainView.should_receive(:removeView).with(@context.peekAtView)
+			@context.should_receive(:destroyViews)
+            @context.exit
+            @context.isEntered?.should be(false)
+        end
+
+	end
+end

data/spec/Context/EnumeratedType_spec.rb

@@ -0,0 +1,51 @@
+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