widget_wrapper 0.0.1

data/CHANGELOG

@@ -0,0 +1,3 @@
+*0.0.0*
+
+* Put into its own gem

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Lancelot Carlson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1 @@
+== Widget Wrapper

data/Rakefile

@@ -0,0 +1,84 @@
+require 'rake'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'spec/rake/spectask'
+
+require 'lib/version'
+
+NAME = "widget_wrapper"
+
+windows = (PLATFORM =~ /win32|cygwin/)
+SUDO = windows ? "" : "sudo"
+
+dist_files = [ "lib", "spec" ]
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = WidgetWrapper::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.summary = "A DSL Wrapper for GUI Toolkits"
+  s.description = "A Ruby style DSL framework that lets you build and interact with GUI toolkits."
+  s.author = "Lance Carlson"
+  s.email = "lancecarlson@gmail.com"
+  s.homepage = "http://anvil.rubyforge.org"
+  s.has_rdoc = true
+
+  s.add_dependency('wxruby')
+  s.add_dependency('rake')
+
+  s.files = [ "CHANGELOG", "MIT-LICENSE", "README", "Rakefile", "spec.opts", "spec_helper.rb" ]
+  dist_files.each do |dir|
+    s.files = s.files + Dir.glob("#{dir}/**/*")
+  end
+  
+  s.require_path = 'lib'
+  s.autorequire = 'widget_wrapper'
+  s.rubyforge_project = 'widget_wrapper'
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = 'Widget Wrapper'
+  rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+  rdoc.options << '--charset' << 'utf-8'
+  rdoc.rdoc_files.include('README', 'CHANGELOG', 'MIT-LICENSE')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Run :package and install the resulting .gem'
+task :install => :package do
+  sh %{#{SUDO} gem install pkg/#{NAME}-#{WidgetWrapper::VERSION} --no-rdoc --no-ri}
+end
+
+desc 'Run :clean and uninstall the .gem'
+task :uninstall => [:clean] do
+  sh %{#{SUDO} gem uninstall #{NAME}}
+end
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ['--options', 'spec.opts']
+end
+
+desc "Run all specs and generate an rcov report"
+Spec::Rake::SpecTask.new('spec:rcov') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ['--options', 'spec.opts']
+  t.rcov = true
+  t.rcov_dir = 'coverage'
+  t.rcov_opts = ['--exclude', 'gems', '--exclude', 'spec']
+end
+
+task :release => :package do
+  if ENV['RELEASE']
+    sh %{rubyforge add_release #{NAME} #{NAME} "#{ENV['RELEASE']}" pkg/#{NAME}-#{WidgetWrapper::VERSION}.gem}
+  else
+    puts 'Must specify release!'
+  end
+end

data/lib/controller.rb

@@ -0,0 +1,4 @@
+module WidgetWrapper
+  class Controller
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module WidgetWrapper
+  VERSION = '0.0.1' unless defined?(::WidgetWrapper::VERSION)
+end

data/lib/widget_wrapper.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), 'wx_wrapper')
+require File.join(File.dirname(__FILE__), 'controller')

data/lib/wx_wrapper.rb

@@ -0,0 +1,3 @@
+require 'wx'
+
+Dir[File.dirname(__FILE__) + "/wx_wrapper/*.rb"].sort.each{|file| require(file)}

data/lib/wx_wrapper/control.rb

@@ -0,0 +1,14 @@
+module WidgetWrapper
+  module Controls
+    def text_box(name, options={})
+      value = options[:value] ||= ""
+      position_array_to_instance(options)
+      size_array_to_instance(options)
+      style_array_to_constants(options) 
+       
+      Wx::TextCtrl.new(self, -1, value, options[:position], options[:size], options[:style])
+    end
+  end
+end
+
+Wx::Frame.send(:include, WidgetWrapper::Controls)

data/lib/wx_wrapper/event.rb

@@ -0,0 +1,8 @@
+module WidgetWrapper
+  module Events
+    def self.build
+      yield
+    end
+  
+  end
+end

data/lib/wx_wrapper/frame.rb

@@ -0,0 +1,49 @@
+
+module WidgetWrapper
+  module FrameMethods
+    # Creates a new frame for the application.
+    # Examples:
+    #
+    # This will create a new frame with the title "test frame"
+    #   frame "test frame", :position => [ 100, 100 ], :size => [ 640, 480 ]
+    # 
+    def frame(title="", options={})
+      # Option Setup
+      options[:title] = title
+      position_array_to_instance(options)
+      size_array_to_instance(options)
+      full_screen = options[:full_screen]
+      maximize = options[:maximize]
+      center = case options[:center]
+        when :vertical : Wx::VERTICAL
+        when :horizontal : Wx::HORIZONTAL
+        when :both : Wx::BOTH
+        when true : Wx::BOTH
+        else nil
+      end
+     
+      # Remove options that aren't supposed to be sent to wx ruby 
+      options.delete(:maximize)
+      options.delete(:full_screen)
+      options.delete(:center)
+      
+      # Create a new frame
+      frame = Wx::Frame.new(nil, options)
+      
+      # Handle method level calls
+      frame.show_full_screen(true) if full_screen
+      frame.maximize(true) if maximize
+      frame.centre(center) if center
+
+      # Yield the frame instance into a block
+      if block_given?
+        yield(frame)
+      end
+
+      # Display the frame
+      frame.show
+    end
+  end
+end
+
+include WidgetWrapper::FrameMethods

data/lib/wx_wrapper/initializer.rb

@@ -0,0 +1,34 @@
+# The application class is the initializer class for widgets
+
+module WidgetWrapper
+  module Initializer
+    # Initializes the application widgets.
+    # 
+    #   anvil "FirstApp" do
+    #     frame "Hello World!"
+    #   end
+    def anvil(name)
+      Wx::App.run do
+        yield if block_given?
+      end
+    end
+
+    def extract_options_from_args!(args) #nodoc
+      args.last.is_a?(Hash) ? args.pop : {}
+    end
+    
+    def position_array_to_instance(options) #nodoc
+      options[:position] = Wx::Point.new(options[:position][0], options[:position][1]) unless options[:position].nil?
+    end
+
+    def size_array_to_instance(options) #nodoc
+      options[:size] = Wx::Size.new(options[:size][0], options[:size][1]) unless options[:size].nil?
+    end
+
+    def style_array_to_constants(options) #nodoc
+      options[:style] = eval(options[:style].collect { |key| "Wx::TE_#{key.to_s.upcase}" }.join('|')) unless options[:style].nil?
+    end
+  end
+end
+
+include WidgetWrapper::Initializer

data/lib/wx_wrapper/menu.rb

@@ -0,0 +1,157 @@
+module WidgetWrapper
+  module Menus
+    module Frame
+      # Creates a menu bar for the frame. Example syntax:
+      #
+      #   frame.menu_bar do |menu_bar|
+      #     menu_bar.menu do |menu|
+      #     end
+      #   end
+      def menu_bar
+        new_menu_bar = Wx::MenuBar.new
+        yield(new_menu_bar) if block_given?
+        create_menu_events(new_menu_bar)
+        set_menu_bar(new_menu_bar)
+      end
+      
+      def create_menu_events(menu_bar)
+        menu_bar.menus.each do |menu|
+          menu.items.each do |item|
+            evt_menu(item.get_id) { send(menu_item_label_to_method(item.get_label)) }
+          end
+        end
+      end
+      
+      # Returns names for menu items prefixed with on_. ie on_save
+      def menu_item_label_to_method(label)
+        'on_' + label.downcase.gsub(/[^a-zA-Z0-9 ]/, '').gsub(/[ ]/, '_')
+      end
+    end
+
+    # Menu bar syntax (This code follows after a frame block):
+    # 
+    #   menu_bar.menu "&File" do |item|
+    #     item.add :new
+    #     item.add :open
+    #     item.separator
+    #     item.add :save
+    #     item.separator
+    #     item.add :quit
+    #   end
+    #   
+    #   menu_bar.menu "&Edit" do |item|
+    #     item.add :undo
+    #     item.add :redo
+    #   end
+    # 
+    # The & in the menu title (ie &File) is used underlined and used as a shortcut for referencing 
+    # alt command navigation for windows. You can move the ampersand in front of a different letter 
+    # if you would like another letter to be the shortcut for alt keys. (As of yet, I don't know how 
+    # this works in OS X if it has any effect at all).
+    module MenuBar
+      # Gets a list of menus in the menu bar
+      def menus
+        (0..(get_menu_count-1)).collect {|menu_id| get_menu(menu_id)}
+      end
+      
+      # Creates a menu inside of the menu bar. 
+      # 
+      #   menu_bar.menu "&File" do |item|
+      #     item.add :new
+      #   end
+      def menu(title, options = {})
+        new_menu = Wx::Menu.new
+        
+        if block_given?
+          yield(new_menu)
+        end
+        
+        append(new_menu, title)
+      end
+    end
+
+    # Menu Syntax (Called after a menu bar block)
+    # 
+    #   menu "&File" do |item|
+    #     item.add :new
+    #     item.add :open
+    #     item.separator
+    #     item.add :save
+    #     item.separator
+    #     item.add :preview
+    #     item.add :print
+    #     item.separator
+    #     item.add :close
+    #     item.add :quit
+    #   end
+    # 
+    # Default menu items you can add are: new, open, close, exit, quit, save, print, preview, about, undo,
+    # redo, cut, copy, paste, delete, selectall, preferences, find, replace
+    # 
+    # Default menu items have their operating system level icons loaded automatically.
+    module Menu
+      def default_items
+        { 
+          :new => { :icon => get_icon(:new), :item => "&New\tCtrl-N", :help => "Create a file" },
+          :open => { :icon => get_icon(:open), :item => "&Open\tCtrl-O", :help => "Open a file" }, 
+          :close => { :icon => get_icon(:close), :item => "&Close\tCtrl-W", :help => "Close the file" },
+          :exit => { :icon => get_icon(:exit), :item => "E&xit\tAlt-F4", :help => "Exit Application" },
+          :quit => { :icon => get_icon(:exit), :item => "&Quit\tCtrl-Q", :help => "Quit Application" },
+          :save => { :icon => get_icon(:save), :item => "&Save\tCtrl-S", :help => "Save the file" },
+          :print => { :icon => get_icon(:print), :item => "&Print...\tCtrl-P", :help => "Print the file" },
+          :preview => { :icon => get_icon(:preview), :item => "Print Previe&w\tShift-Ctrl-P", :help => "Print preview the file" },
+          :about => { :icon => get_icon(:about), :item => "&About\tF1", :help => "About" },
+          :undo => { :icon => get_icon(:undo), :item => "&Undo\tCtrl+Z", :help => "Undo" },
+          :redo => { :icon => get_icon(:redo), :item => "&Redo\tCtrl+Shift+Z", :help => "Redo" },
+          :cut => { :icon => get_icon(:cut), :item => "Cu&t\tCtrl+X", :help => "Undo" },
+          :copy => { :icon => get_icon(:copy), :item => "&Copy\tCtrl+C", :help => "Copy" },
+          :paste => { :icon => get_icon(:paste), :item => "&Paste\tCtrl+V", :help => "Paste" },
+          :delete => { :icon => get_icon(:delete), :item => "&Delete", :help => "Delete" },
+          :selectall => { :icon => get_icon(:selectall), :item => "Select &All\tCtrl+A", :help => "Select All" },
+          :preferences => { :icon => get_icon(:preferences), :item => "Pr&eferences", :help => "Preferences" },
+          :find => { :icon => get_icon(:find), :item => "&Find...\tCtrl+F", :help => "Find" },
+          :replace => { :icon => get_icon(:replace), :item => "&Replace...\tCtrl+H", :help => "Replace" }
+        }
+      end
+      
+      # Creates a menu item on the menu. Example syntax:
+      # 
+      #   item.add :close
+      def add(item, options={})
+        icon = options.include?(:icon) ? get_icon(options[:icon]) : default_items[item][:icon]
+        
+        # 1st argument is the icon id, the next is menu item text, and then the next is the help text
+        args = []
+        args << icon
+        args << (options.include?(:item) ? options[:item] : default_items[item][:item])
+        args << (options.include?(:help) ? options[:help] : default_items[item][:help])
+        
+        append(*args)
+      end
+      
+      # Creates a new separator for the menu
+      def separator
+        append_separator
+      end
+      
+      # Lists the menu item objects for a given menu
+      def items(options={})
+        items_list = (1..get_menu_item_count-1).collect do |position|
+          value = find_item_by_position(position)
+          value unless value.get_kind == -1 && !options.include?(:include_separators)
+        end
+        items_list.compact
+      end
+      
+      # TODO: PUT into another module
+      def get_icon(icon)
+        Wx.const_get("ID_#{icon.to_s.upcase}")
+      end
+
+   end
+  end
+end
+
+Wx::Frame.send(:include, WidgetWrapper::Menus::Frame)
+Wx::MenuBar.send(:include, WidgetWrapper::Menus::MenuBar)
+Wx::Menu.send(:include, WidgetWrapper::Menus::Menu)

data/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/wx_wrapper/control_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../../spec_helper' 
+
+require 'wx'
+require File.dirname(__FILE__) + '/../../lib/wx_wrapper/control' 
+
+describe WidgetWrapper::Controls do
+  before(:each) do
+    class MockControlParent; end
+    MockControlParent.send(:include, WidgetWrapper::Controls)
+    @parent = MockControlParent.new
+    @txtctrl = mock(Wx::TextCtrl)
+  end
+  
+  it "should have a text box control" do
+    Wx::TextCtrl.should_receive(:new).with(@parent, -1, "", nil, nil, nil).and_return(@txtctrl)
+    @parent.text_box(:editor).should == @txtctrl
+  end
+end

data/spec/wx_wrapper/event_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../../spec_helper' 
+
+require 'wx'
+require File.dirname(__FILE__) + '/../../lib/wx_wrapper/event' 
+
+describe WidgetWrapper::Events do
+  before(:each) do
+  
+  end
+
+  it "should have a build method that includes event class" do
+    WidgetWrapper::Events.build do
+    end
+  end
+  
+end

data/spec/wx_wrapper/frame_spec.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/../../spec_helper' 
+
+require 'wx'
+require File.dirname(__FILE__) + '/../../lib/wx_wrapper/initializer'
+require File.dirname(__FILE__) + '/../../lib/wx_wrapper/frame' 
+
+describe WidgetWrapper::FrameMethods do
+  before(:each) do
+    @frame = mock(Wx::Frame)
+    @point = mock(Wx::Point)
+    @size = mock(Wx::Size)
+  end
+
+  it "should instantiate a wx ruby frame and display it" do
+    Wx::Frame.should_receive(:new).with(nil, :title => 'test frame').and_return(@frame)
+    @frame.should_receive(:show)
+    
+    frame 'test frame'
+  end
+
+  it "should allow you to specify the position of the frame" do
+    Wx::Point.should_receive(:new).with(80, 100).and_return(@point)
+    Wx::Frame.should_receive(:new).with(nil, :title => 'test frame', :position => @point).and_return(@frame)
+    @frame.should_receive(:show) 
+    
+    frame 'test frame', :position => [ 80, 100 ] 
+  end
+
+  it "should allow you to specify the size of the frame" do
+    Wx::Size.should_receive(:new).with(640, 480).and_return(@size)
+    Wx::Frame.should_receive(:new).with(nil, :title => 'test frame', :size => @size).and_return(@frame)
+    @frame.should_receive(:show)
+    
+    frame 'test frame', :size => [ 640, 480 ]
+  end
+
+  it "should allow you to specify the style of the frame" do
+    pending("Need to figure out how this works")
+  end
+
+  it "should allow you to specify the name of the frame" do
+    pending("Not sure what this is for")
+  end
+
+  it "should allow you to stick the frame in full screen mode" do
+    Wx::Frame.should_receive(:new).with(nil, :title => 'Frame in full screen mode').and_return(@frame)
+    @frame.should_receive(:show_full_screen).with(true)
+    @frame.should_not_receive(:maximize)
+    @frame.should_receive(:show)
+    
+    frame "Frame in full screen mode", :full_screen => true
+  end
+  
+  it "should allow you to maximize the frame" do
+    Wx::Frame.should_receive(:new).with(nil, :title => 'Maximized Frame').and_return(@frame)
+    @frame.should_not_receive(:show_full_screen)
+    @frame.should_receive(:maximize).with(true)
+    @frame.should_receive(:show)
+    
+    frame "Maximized Frame", :maximize => true
+  end
+   
+  it "should allow you to center the frame horizontally" do
+    Wx::Frame.should_receive(:new).with(nil, :title => 'Centered Frame').and_return(@frame)
+    @frame.should_receive(:centre).with(Wx::HORIZONTAL)
+    @frame.should_receive(:show)
+    frame "Centered Frame", :center => :horizontal
+  end
+
+  it "should allow you to center the frame vertically" do
+    Wx::Frame.should_receive(:new).with(nil, :title => 'Centered Frame').and_return(@frame)
+    @frame.should_receive(:centre).with(Wx::VERTICAL)
+    @frame.should_receive(:show)
+    frame "Centered Frame", :center => :vertical
+  end
+
+  it "should allow you to center the frame horizontailly and vertically" do
+    Wx::Frame.should_receive(:new).with(nil, :title => 'Centered Frame').and_return(@frame)
+    @frame.should_receive(:centre).with(Wx::BOTH)
+    @frame.should_receive(:show)
+    frame "Centered Frame", :center => :both
+  end
+
+  it "should center the frame horizontailly and vertically when true is specified" do
+    Wx::Frame.should_receive(:new).with(nil, :title => 'Centered Frame').and_return(@frame)
+    @frame.should_receive(:centre).with(Wx::BOTH)
+    @frame.should_receive(:show)
+    frame "Centered Frame", :center => true
+  end
+
+  it "should yield the frame instance in a block" do
+    Wx::Frame.stub!(:new).and_return(@frame)
+    @frame.stub!(:show)
+
+    frame "Frame with block" do |frame|
+      frame.should == @frame
+    end
+  end
+end

data/spec/wx_wrapper/initializer_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/../../spec_helper' 
+
+require 'wx'
+require File.dirname(__FILE__) + '/../../lib/wx_wrapper/initializer' 
+
+describe WidgetWrapper::Initializer do
+  it "should run the application widgets" do
+    anvil "some cool app"
+  end
+
+  it "should have a method for extracting options from an arguments list" do
+    args = ["test", "test", {:test => 'test', :test2 => "test2"}]
+    extract_options_from_args!(args).should == {:test => 'test', :test2 => 'test2'}
+  end
+
+  it "should have a method that will scan options for a position array and change it to a point instance" do
+    @point = mock(Wx::Point)
+    options = {}
+    options[:position] = [ 100, 100 ]
+    Wx::Point.should_receive(:new).with(100, 100).and_return(@point)
+
+    position_array_to_instance(options).should == @point
+    options[:position].should == @point
+  end
+
+  it "should have a method that will scane options for a position array and do nothing if it can't" do
+    options = {}
+    Wx::Point.should_not_receive(:new)
+
+    position_array_to_instance(options)
+  end
+
+  it "should have a method that will scane options for a size array and change it to a size instance" do
+    @size = mock(Wx::Size)
+    options = {}
+    options[:size] = [ 100, 100 ]
+    Wx::Size.should_receive(:new).with(100, 100).and_return(@size)
+    
+    size_array_to_instance(options).should == @size
+    options[:size].should == @size
+  end
+  
+  it "should have a method that will scan options for a size array and do nothing if it can't" do
+    options = {}
+    Wx::Size.should_not_receive(:new)
+
+    size_array_to_instance(options)
+  end
+
+  it "should have a method that will scan options for a style array convert it to a constant" do
+    options = {}
+    options[:style] = [ :multiline, :rich ]
+    
+    style_array_to_constants(options).should == Wx::TE_MULTILINE | Wx::TE_RICH
+    options[:style].should == Wx::TE_MULTILINE | Wx::TE_RICH
+  end
+
+  it "should have a method that will scan options for a style array and do nothing if it can't" do
+    options = {}
+
+    style_array_to_constants(options).should be_nil
+    options[:style].should be_nil
+  end
+end

data/spec/wx_wrapper/menu_spec.rb

@@ -0,0 +1,121 @@
+require File.dirname(__FILE__) + '/../../spec_helper' 
+
+require 'wx'
+require File.dirname(__FILE__) + '/../../lib/wx_wrapper/menu' 
+
+describe WidgetWrapper::Menus::Frame do
+  before(:each) do
+    class MockFrame; end
+    MockFrame.send(:include, WidgetWrapper::Menus::Frame)
+    @frame = MockFrame.new
+    @menu_bar = mock(Wx::MenuBar)
+    @menu = mock(Wx::Menu)
+    @menu_item = mock(Wx::MenuItem)
+  end
+
+  it "should have a list of the menus inside of it" do
+    pending("Need to write test") 
+  end
+
+  it "should have a menu_bar method for creating menu bars that yields an instance of the menu_bar" do
+    Wx::MenuBar.should_receive(:new).and_return(@menu_bar) 
+    @frame.should_receive(:create_menu_events).with(@menu_bar)
+    @frame.should_receive(:set_menu_bar).with(@menu_bar)
+    
+    @frame.menu_bar do |menu_bar|
+      menu_bar.should == @menu_bar
+    end
+  end
+
+  it "should have a way to generate all of the menu events" do
+    @menu_bar.should_receive(:menus).and_return([@menu])
+    @menu.should_receive(:items).and_return([@menu_item])
+    @menu_item.should_receive(:get_id).and_return(1)
+    @frame.should_receive(:evt_menu).with(1)
+    
+    @frame.create_menu_events(@menu_bar)
+  end
+
+  it "should convert item labels to event methods" do
+    @frame.menu_item_label_to_method("New").should == 'on_new'
+  end
+end
+
+describe WidgetWrapper::Menus::MenuBar do
+  before(:each) do
+    class MockMenuBar; end
+    MockMenuBar.send(:include, WidgetWrapper::Menus::MenuBar) 
+    @menu_bar = MockMenuBar.new
+    @menu = mock(Wx::Menu)
+    @menu2 = mock(Wx::Menu)
+  end
+
+  it "should list menus attached" do
+    @menu_bar.should_receive(:get_menu_count).and_return(2)
+    @menu_bar.should_receive(:get_menu).with(0).and_return(@menu)
+    @menu_bar.should_receive(:get_menu).with(1).and_return(@menu2)
+    
+    @menu_bar.menus.should == [@menu, @menu2]
+  end
+
+  it "should return a menu if there is only one" do
+    @menu_bar.should_receive(:get_menu_count).and_return(1)
+    @menu_bar.should_receive(:get_menu).with(0).and_return(@menu)
+    
+    @menu_bar.menus.should == [@menu]
+  end
+
+  it "should return an empty array if no menus where found" do
+    @menu_bar.should_receive(:get_menu_count).and_return(0)
+    @menu_bar.should_not_receive(:get_menu)
+    
+    @menu_bar.menus.should == []
+  end
+
+  it "should create a menu on the menu bar" do
+    Wx::Menu.should_receive(:new).and_return(@menu)
+    @menu_bar.should_receive(:append).with(@menu, "&File")
+    
+    @menu_bar.menu "&File" do |menu|
+      menu.should == @menu
+    end
+  end
+end
+
+describe WidgetWrapper::Menus::Menu do
+  before(:each) do
+    class MockMenu; end
+    MockMenu.send(:include, WidgetWrapper::Menus::Menu) 
+    @menu = MockMenu.new
+    @item = mock(Wx::MenuItem)
+    @item2 = mock(Wx::MenuItem)
+  end
+
+  it "should have default menu items" do
+    @menu.default_items
+  end
+
+  it "should add a menu item to the menu" do
+    @menu.should_receive(:append).with(Wx::ID_NEW, "&New\tCtrl-N", "Create a file")
+    @menu.add :new
+  end
+
+  it "should add a separator to the menu" do
+    @menu.should_receive(:append_separator)
+    @menu.separator
+  end
+
+  it "should list the items in the menu" do
+    @menu.should_receive(:get_menu_item_count).and_return(3)
+    @menu.should_receive(:find_item_by_position).with(1).and_return(@item)
+    @menu.should_receive(:find_item_by_position).with(2).and_return(@item2)
+    @item.should_receive(:get_kind).and_return(Wx::ITEM_NORMAL)
+    @item2.should_receive(:get_kind).and_return(Wx::ITEM_NORMAL)
+    @menu.items.should == [@item, @item2]
+  end
+
+  it "should list the items in the menu without the separators" do
+    pending("NEed to write test")
+  end
+
+end

data/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+
+Spec::Runner.configure do |config|
+end
+

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: widget_wrapper
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Lance Carlson
+autorequire: widget_wrapper
+bindir: bin
+cert_chain: []
+
+date: 2007-12-25 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: wxruby
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A Ruby style DSL framework that lets you build and interact with GUI toolkits.
+email: lancecarlson@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- CHANGELOG
+- MIT-LICENSE
+- README
+- Rakefile
+- spec.opts
+- spec_helper.rb
+- lib/controller.rb
+- lib/version.rb
+- lib/widget_wrapper.rb
+- lib/wx_wrapper
+- lib/wx_wrapper/control.rb
+- lib/wx_wrapper/event.rb
+- lib/wx_wrapper/frame.rb
+- lib/wx_wrapper/initializer.rb
+- lib/wx_wrapper/menu.rb
+- lib/wx_wrapper.rb
+- spec/wx_wrapper
+- spec/wx_wrapper/control_spec.rb
+- spec/wx_wrapper/event_spec.rb
+- spec/wx_wrapper/frame_spec.rb
+- spec/wx_wrapper/initializer_spec.rb
+- spec/wx_wrapper/menu_spec.rb
+has_rdoc: true
+homepage: http://anvil.rubyforge.org
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: widget_wrapper
+rubygems_version: 1.0.0
+signing_key: 
+specification_version: 2
+summary: A DSL Wrapper for GUI Toolkits
+test_files: []
+