nobbie-wx-preview 0.0.1

data/lib/nobbie/wx/command/type_into.rb

@@ -0,0 +1,79 @@
+module Nobbie
+  module Wx
+    module Command
+
+      class TypeIntoCommand < ComponentAwareCommand #:nodoc:
+        def initialize(path, value)
+          super(path)
+          @value = value
+        end
+        
+        def execute
+          highlight {
+            if component.is_a?(TextCtrl) || component.is_a?(ComboBox)
+              handle_text_ctrl_or_combo_box
+            else
+              handle_unsupported_operation_for_component
+            end
+          }
+        end
+        
+        def describe
+          "Type #{@value} into #{@value}"
+        end
+        
+        private
+
+        def handle_text_ctrl_or_combo_box
+          ensure_enabled
+
+          Kernel.raise(ComponentReadOnlyException,
+            "cannot type, component is readonly") if readonly
+
+          #todo: resolve issue with events when value does not change
+          #this is required because windows raises the event when the value is the same, OSX does not.
+          #return if component.value == @value
+
+          #todo: consider using 'clear' .. but symantics different for ComboBox (ControlWithItems)
+          type('')
+
+          @value.length.times {|n| type(@value[0..n]) }
+
+          #todo: this looks like a windows wx issue .. the docs state that set_value does nothing if the combo is readonly
+          Kernel.raise(ComponentReadOnlyException,
+            "cannot type, component is readonly") if component.value != @value && component.is_a?(ComboBox)
+        end
+
+        def readonly
+          if component.is_a?(TextCtrl)
+            return !component.is_editable 
+          end
+          
+          if component.is_a?(ComboBox)
+            #todo: fix ComboBox readonly
+            #there doesnt seem to be a method of determining when a combobox is readonly ...
+            #in theory you can try setting it to a value thats not in the list and see if that changes
+            #which doesnt work as expected on windows (see above))
+            return false
+          end
+        end
+
+        def type(text)
+          #todo: this isnt quite right .. should really use append (but combo's don't support it)
+
+          #todo: find a nicer way to handle OS specific bits ...
+          if Platform.windows?
+            event = CommandEvent.new(EVT_COMMAND_TEXT_UPDATED, component.get_id)
+            event.string = text
+            event.event_object = component
+            component.command(event) if component.is_a?(ComboBox)
+          end
+          component.value = text
+          component.refresh
+          component.update
+        end
+      end
+
+    end    
+  end
+end  

data/lib/nobbie/wx/command_executor.rb

@@ -0,0 +1,25 @@
+module Nobbie
+  module Wx
+    module Command  
+
+      class Executor #:nodoc:
+        def execute(command)
+          puts "\n> #{command.describe}"
+          result = command.execute
+          puts "< #{render(result)}"
+          result
+        end
+        
+        private
+        
+        def render(component)
+          #todo: this needs improving to support other components    
+          return '' if component.nil?
+          return component.value if component.respond_to?(:get_value)
+          return component
+        end
+      end
+
+    end
+  end
+end       

data/lib/nobbie/wx/command_factory.rb

@@ -0,0 +1,48 @@
+require 'nobbie/wx/command'
+
+command = File.dirname(__FILE__) + File::SEPARATOR + 'command'
+Dir.glob("#{command}/**/*.rb") {|f| require "#{f}" }
+
+require 'nobbie/wx/command_executor'
+
+module Nobbie
+  module Wx
+    module Command  
+
+      class Factory
+        def create_type_into_command(path, value)
+          TypeIntoCommand.new(path, value)
+        end
+        
+        def create_get_component_command(path)
+          GetComponentCommand.new(path)
+        end
+        
+        def create_click_on_command(path)
+          ClickOnCommand.new(path)
+        end
+        
+        def create_get_selected_values_command(path)
+          GetSelectedValuesCommand.new(path)
+        end
+        
+        def create_select_command(path, value)
+          SelectCommand.new(path, value)
+        end
+        
+        def create_is_chosen_command(path)
+          IsChosenCommand.new(path)
+        end
+        
+        def create_choose_command(path)
+          ChooseCommand.new(path)
+        end
+        
+        def create_is_enabled_command(path)
+          IsEnabledCommand.new(path)
+        end
+      end
+
+    end    
+  end
+end

data/lib/nobbie/wx/driven.rb

@@ -0,0 +1,7 @@
+require 'nobbie/wx/operations'
+
+include Nobbie::Wx::Operations
+
+def with_application
+  Nobbie::Wx::ApplicationLauncher.new.with_application { yield }
+end

data/lib/nobbie/wx/impl/element/element_path_builder.rb

@@ -0,0 +1,41 @@
+module Nobbie
+  module Wx
+
+    class ComponentNotFoundException < RuntimeError; end
+    class ValueNotFoundException < RuntimeError; end
+    class ComponentDisabledException < RuntimeError; end
+    class UnsupportedOperationForComponentException < RuntimeError; end
+    class ComponentReadOnlyException < RuntimeError; end
+
+    class ElementPathBuilder
+      def initialize(name)
+        @name = name
+      end
+
+      # Finds the component specified in the path.  This implementation is about as dumb as its gets, but does
+      # handle named components and menus.
+      def find_component
+        #todo: make me properly navigate component tree
+        #todo: I should blow up if multiple windows with the same name are found ....
+
+        component = Window.find_window_by_name(@name)
+        return component unless component.nil?
+
+        menu_bar = APPLICATION_UNDER_TEST.get_top_window.get_menu_bar
+        unless menu_bar.nil?
+          component = menu_bar.get_menu(menu_bar.find_menu(@name))
+        end
+
+        #todo: pull this up ...
+        Kernel.raise(ComponentNotFoundException, "cannot find component with name: #{@name}") if component.nil?
+        
+        component
+      end
+      
+      def to_s
+        "#{@name}"
+      end
+    end
+
+  end
+end  

data/lib/nobbie/wx/impl/operation/choosable.rb

@@ -0,0 +1,31 @@
+module Nobbie
+  module Wx
+
+    class ChoosableOperations
+      def initialize(operations, path)
+        @operations = operations
+        @path = path    
+      end
+
+      # Chooses the component specified in the path.
+      #  Supported components: RadioButton, CheckBox
+      def choose
+        execute(@operations.command_factory.create_choose_command(@path))
+      end
+
+      # Determines if the component specified in the path is chosen.
+      #  Supported components: RadioButton, CheckBox
+      def chosen?
+        execute(@operations.command_factory.create_is_chosen_command(@path))
+      end
+
+      private
+
+      #todo: pullup execute
+      def execute(command)
+        Command::Executor.new.execute(command)
+      end
+    end
+
+  end
+end  

data/lib/nobbie/wx/impl/operation/select.rb

@@ -0,0 +1,31 @@
+module Nobbie
+  module Wx
+    
+    class SelectOperations
+      def initialize(operations, path)
+        @operations = operations
+        @path = path    
+      end
+
+      # Retrieves the currently selected value for the component specified in the path.
+      #  Supported components: Notebook, ComboBox, ListBox, Choice
+      def selected_value
+        execute(@operations.command_factory.create_get_selected_values_command(@path))
+      end
+
+      # Selects the given value for the component specified in the path.
+      #  Supported components: Notebook, Menu, ComboBox, ListBox, Choice
+      def choose(value)
+        execute(@operations.command_factory.create_select_command(@path, value))
+      end
+      
+      private
+      
+      #todo: pullup execute
+      def execute(command)
+        Command::Executor.new.execute(command)
+      end
+    end
+
+  end
+end  

data/lib/nobbie/wx/launcher.rb

@@ -0,0 +1,75 @@
+module Nobbie
+  module Wx
+
+    module ApplicationUnderTest #:nodoc:
+      def init_timer
+        @aut_timer = Timer.new(self, -1)
+        @aut_timer.start(10)
+        evt_timer(@aut_timer.object_id) {|e| self.yield; Thread.pass }
+      end
+
+      #todo: think about adding evt_idle here as well.
+    end
+
+    class ApplicationLauncher #:nodoc:
+
+      AUT_NOT_WX_APP = "APPLICATION_UNDER_TEST must be an instance of a Wx::App"
+      AUT_NOT_DEFINED = "APPLICATION_UNDER_TEST must be set to be an instance of the application you wish to test"
+
+      def initialize
+        begin
+          app = get_application
+          unless app.is_a?(Wxruby2::App)
+            handle(AUT_NOT_WX_APP)
+          end
+        rescue NameError => e
+          handle(AUT_NOT_DEFINED)
+        end
+        @app = app
+      end
+
+      def with_application
+        start
+        result = yield
+        stop
+        result
+      end
+
+      def start
+        puts "\n>> Starting application: #{@app.class}"
+        start = Time.now
+
+        @app_thread = Thread.new {
+          @app.extend(ApplicationUnderTest)
+          @app.init_timer
+          @app.main_loop
+        }
+
+        @app_thread.priority = -1
+
+        sleep 1
+        finish = Time.now
+        puts "\n>> Took #{finish-start} seconds to start application"
+        Thread.pass
+      end
+
+      def stop
+        puts "\n>> Stopping application: #{@app.class}\n"
+
+        #todo: tbis would seem a polite way to exit .. but causes Bus/Segmentation Errors on OSX.
+        #@app.top_window.destroy
+        #@app.exit_main_loop
+        #@app = nil
+      end
+
+      def handle(message)
+        Kernel.raise message
+      end
+
+      def get_application
+        APPLICATION_UNDER_TEST
+      end
+    end
+
+  end
+end

data/lib/nobbie/wx/operations.rb

@@ -0,0 +1,85 @@
+require 'nobbie/wx/platform'
+require 'nobbie/wx/command_factory'
+require 'nobbie/wx/launcher'
+
+impl = File.dirname(__FILE__) + File::SEPARATOR + 'impl'
+Dir.glob("#{impl}/**/*.rb") {|f| require "#{f}" }
+
+module Nobbie
+  module Wx
+
+    module Operations
+
+      # Types text into the component specified in the path.
+      #  Supported components: TextCtrl, ComboBox
+      def type(text, path)
+        execute(command_factory.create_type_into_command(coerce_path(path), text))
+      end
+
+      # Clicks the component specified in the path.
+      #  Supported components: Button
+      def click(path)
+        execute(command_factory.create_click_on_command(coerce_path(path)))
+      end
+
+      # Returns the component specified in the path.  Useful for performing operations that Nobbie does not
+      # currently support.
+      #  Supported components: Any
+      def component(path)
+        execute(command_factory.create_get_component_command(coerce_path(path)))
+      end
+
+      # Returns a SelectionOperations[link:classes/Nobbie/Wx/SelectOperations.html] for interacting with
+      # the component specified in the path
+      def selection(path)
+        SelectOperations.new(self, coerce_path(path))
+      end
+
+      # Returns a ChoosableOperations[link:classes/Nobbie/Wx/ChoosableOperations.html] for interacting with
+      # the component specified in the path
+      def choosable(path)
+        ChoosableOperations.new(self, coerce_path((path)))
+      end
+
+      # Determines if the component specified in the path is currently enabled.
+      #  Supported components: Any
+      def enabled?(path)
+        execute(command_factory.create_is_enabled_command(coerce_path(path)))
+      end
+
+      # Creates an instance of the default {path builder}[link:classes/Nobbie/Wx/ElementPathBuilder.html].
+      # Override this method if you wish to provide an alternative default path builder (because coerce_path
+      # uses in_() internally).
+      def in_(name)
+        ElementPathBuilder.new(name)
+      end
+
+      # Creates an instance of the default {command factory}[link:classes/Nobbie/Wx/CommandFactory.html].
+      # Override this method if you wish to provide an alternative command factory.
+      def command_factory
+        Command::Factory.new
+      end
+
+      private
+     
+      def coerce_path(path)
+        return path if path.respond_to?(:find_component)
+
+        if path.is_a?(Hash) && path.has_key?(:in)
+          return path[:in].is_a?(String) ? in_(path[:in]) : path[:in]
+        end
+
+        return in_(path.id2name) if path.is_a?(Symbol)
+        return in_(path) if path.is_a?(String)
+
+        Kernel.raise("Unable to coerce path: #{path}")
+      end
+     
+      #todo: pull up
+      def execute(command)
+        Command::Executor.new.execute(command)
+      end
+    end
+    
+  end
+end

data/lib/nobbie/wx/platform.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'wx'
+
+#todo: move this into Nobbie::Wx namespace ... once name clash is fixed
+class Platform #:nodoc:
+  include Wx
+
+  WINDOWS = 'WXMSW'
+  MAC = 'WXMAC'
+  SUPPORTED_PLATFORMS = [WINDOWS, MAC]
+
+  def self.windows?
+    name == WINDOWS
+  end
+
+  def self.ensure_supported
+    Kernel.raise "Sorry '#{name}' is not currently supported, Nobbie-Wx is only available for the following platforms: [#{SUPPORTED_PLATFORMS.join(',')}]" unless supported?
+  end
+
+  private
+
+  def self.supported?
+    SUPPORTED_PLATFORMS.include?(name)
+  end
+
+  def self.name
+    Wx::PLATFORM
+  end
+end
+
+Platform.ensure_supported