shortcut 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-version

@@ -0,0 +1 @@
+jruby

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in shortcut.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', cli: '--color' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Décio Ferreira
+
+MIT License
+
+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.md

@@ -0,0 +1,47 @@
+# Shortcut
+
+Make your own Bot.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'shortcut'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install shortcut
+
+## Usage
+
+### Ubuntu 12.04 with Unity-2D
+
+Ubuntu has a bug related to how unity-2d draws itself on screen.
+To fix this issue run the following command before you run shortcut:
+
+    $ gconftool --set --type bool /apps/metacity/general/compositing_manager false
+
+And then log out/in to apply the changes. To restore the default configuration run:
+
+    $ gconftool --set --type bool /apps/metacity/general/compositing_manager true
+
+And again log out/in to apply the changes.
+
+See more information about this [bug](https://bugs.launchpad.net/unity-2d/+bug/1081674).
+
+## Development
+
+    $ ruby --ng-server &
+    $ ruby --ng -S rspec spec
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+task test: :spec

data/lib/shortcut/errors.rb

@@ -0,0 +1,4 @@
+module Shortcut
+  class UndefinedActionError < StandardError
+  end
+end

data/lib/shortcut/point.rb

@@ -0,0 +1,13 @@
+module Shortcut
+  class Point
+    attr_reader :x, :y
+
+    def initialize(x, y)
+      @x, @y = x, y
+    end
+
+    def to_s
+      "#{@x}, #{@y}"
+    end
+  end
+end

data/lib/shortcut/screen.rb

@@ -0,0 +1,57 @@
+require 'java'
+
+import java.awt.Rectangle
+import java.awt.Toolkit
+
+import javax.imageio.ImageIO
+
+module Shortcut
+  class Screen
+    def initialize(opts = {})
+      dim = Toolkit.get_default_toolkit.get_screen_size
+      opts = {:x => 0, :y => 0, :width => dim.get_width, :height => dim.get_height}.merge(opts)
+      rectangle = Rectangle.new(opts[:x], opts[:y], opts[:width], opts[:height])
+
+      @robot = Robot.new
+      @image = @robot.create_screen_capture(rectangle)
+    end
+
+    def save_image(pathname)
+      file = java::io::File.new(pathname)
+      ImageIO.write(@image, "PNG", file)
+    end
+
+    def get_color(x, y)
+      @image.getRGB(x, y)
+    end
+
+    def get_color_hex(x, y)
+      color = get_color(x, y)
+      sprintf("%02X%02X%02X", (color >> 16) & 0xFF, (color >> 8) & 0xFF, color & 0xFF)
+    end
+
+    def find_template(template)
+      for x in 0...(@image.getWidth - template.getWidth)
+        for y in 0...(@image.getHeight - template.getHeight)
+          if loop_through_template(template, x, y)
+            return Point.new(x, y)
+          end
+        end
+      end
+
+      raise "Couldn't find the game board!\nIs the game on the screen?"
+    end
+
+    private
+
+    def loop_through_template(template, x, y)
+      for i in 0...template.getWidth
+        for j in 0...template.getHeight
+          return false if get_color(x+i, y+j) - template.getRGB(i, j) != 0
+        end
+      end
+
+      return true
+    end
+  end
+end

data/lib/shortcut/version.rb

@@ -0,0 +1,3 @@
+module Shortcut
+  VERSION = "0.0.1"
+end

data/lib/shortcut/window.rb

@@ -0,0 +1,157 @@
+require 'java'
+require 'jar/JNativeHook.jar'
+
+import java.awt.Color
+import java.awt.event.ActionListener
+import java.awt.event.InputEvent
+import java.awt.event.WindowListener
+import java.awt.Robot
+
+import java.io.ByteArrayInputStream
+
+import javax.swing.JButton
+import javax.swing.JFrame
+import javax.swing.JScrollPane
+import javax.swing.JTextArea
+
+import javax.imageio.ImageIO
+
+import org.jnativehook.GlobalScreen
+import org.jnativehook.keyboard.NativeKeyListener
+import org.jnativehook.NativeHookException
+
+# https://github.com/jruby/jruby/wiki/Persistence
+Color.__persistent__ = true
+GlobalScreen.__persistent__ = true
+JScrollPane.__persistent__ = true
+JTextArea.__persistent__ = true
+
+module Shortcut
+  class Window < JFrame
+    include ActionListener
+    include NativeKeyListener
+    include WindowListener
+
+    def create_button(text, action, options = {})
+      options = {enabled: true}.merge(options)
+      JButton.new(text).tap do |btn|
+        btn.setActionCommand(action)
+        btn.addActionListener(self)
+        btn.setEnabled(options[:enabled])
+      end
+    end
+
+    def robot
+      @robot ||= Robot.new
+    end
+
+    def click(x, y)
+      robot.mouseMove(x, y)
+      robot.mousePress(InputEvent::BUTTON1_MASK)
+      robot.mouseRelease(InputEvent::BUTTON1_MASK)
+    end
+
+    def feedback_text_area(start_text = '')
+      @feedback_text_area ||= JTextArea.new.tap do |text_area|
+        text_area.setEditable(false)
+        text_area.setText(start_text)
+        text_area.setBackground(Color::WHITE)
+        text_area.setForeground(Color::BLACK)
+      end
+    end
+
+    def feedback_scroll_panel(text_area, dimension)
+      JScrollPane.new(text_area).tap do |scroll_panel|
+        scroll_panel.setPreferredSize(dimension)
+      end
+    end
+
+    def display_info(text)
+      feedback_text_area.append("\n#{text}")
+      feedback_text_area.setCaretPosition(feedback_text_area.getLineStartOffset(feedback_text_area.getLineCount() - 1))
+    end
+
+    def load_image(path)
+      buffer_array = ByteArrayInputStream.new(File.read(path).to_java_bytes)
+      image_input_stream = ImageIO.createImageInputStream(buffer_array)
+      ImageIO.read(image_input_stream)
+    end
+
+    def operative_system
+      java.lang.System.getProperty("os.name").downcase
+    end
+
+    def run
+      setTitle(respond_to?(:default_title) ? default_title : 'Shortcut App')
+
+      always_on_top if respond_to?(:always_on_top)
+      GlobalScreen.getInstance.addNativeKeyListener(self)
+      addWindowListener(self)
+      setVisible true
+    end
+
+    class << self
+      def title(text)
+        send :define_method, :default_title do
+          text
+        end
+      end
+
+      def always_on_top(bool_value)
+        send :define_method, :always_on_top do
+          setAlwaysOnTop(bool_value)
+        end
+      end
+
+      def key_pressed(code, action = nil, &block)
+        send :define_method, "key_#{code}_pressed".to_sym do
+          if action
+            method_name = "action_#{action}_handler".to_sym
+            raise UndefinedActionError.new("undefined action `#{action}'") unless respond_to?(method_name)
+            self.send(method_name)
+          else
+            self.instance_eval(&block)
+          end
+        end
+      end
+
+      def action(name, &block)
+        send :define_method, "action_#{name}_handler".to_sym do
+          self.instance_eval(&block)
+        end
+      end
+    end
+
+    [:windowClosing, :windowIconified,
+      :windowDeiconified, :windowActivated, :windowDeactivated].each do |name|
+      define_method(name) { |e| }
+    end
+
+    def windowOpened(e)
+      requestFocusInWindow
+      GlobalScreen.registerNativeHook
+    rescue NativeHookException => e
+      display_info(e.toString)
+    end
+
+    def windowClosed(e)
+      GlobalScreen.unregisterNativeHook
+      java.lang.System.runFinalization
+      java.lang.System.exit(0)
+    end
+
+    [:nativeKeyReleased, :nativeKeyTyped].each do |name|
+      define_method(name) { |e| }
+    end
+
+    def nativeKeyPressed(event)
+      method_name = "key_#{event.getKeyCode}_pressed".to_sym
+      send(method_name) if respond_to?(method_name)
+    end
+
+    def actionPerformed(event)
+      method_name = "action_#{event.getActionCommand}_handler".to_sym
+      send(method_name) if respond_to?(method_name)
+    end
+  end
+end

data/lib/shortcut.rb

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

data/shortcut.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shortcut/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "shortcut"
+  spec.version       = Shortcut::VERSION
+  spec.authors       = ["Décio Ferreira"]
+  spec.email         = ["decioferreira@decioferreira.com"]
+  spec.description   = %q{Make your own Bot}
+  spec.summary       = %q{Make your own Bot}
+  spec.homepage      = "https://github.com/decioferreira/shortcut"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_development_dependency "warbler"
+  spec.add_development_dependency "guard-rspec"
+end

data/spec/lib/shortcut_point_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+require "shortcut/point"
+
+describe Shortcut::Point do
+end

data/spec/lib/shortcut_window_spec.rb

@@ -0,0 +1,395 @@
+require "spec_helper"
+require "shortcut/errors"
+require "shortcut/window"
+require "ostruct"
+
+import java.awt.Dimension
+import java.awt.event.KeyEvent
+
+# https://github.com/jruby/jruby/wiki/Persistence
+Dimension.__persistent__ = true
+
+# Title property
+class TitleClass < Shortcut::Window; title 'Test title'; end
+
+# AlwaysOnTop property
+class AlwaysOnTopTrueClass < Shortcut::Window; always_on_top true; end
+class AlwaysOnTopFalseClass < Shortcut::Window; always_on_top false; end
+class AlwaysOnTopNoneClass < Shortcut::Window; end
+
+# NativeKeyListener
+class ListenerExampleClass < Shortcut::Window
+  attr_accessor :called_actions, :key_pressed_events
+
+  action 'some_action' do
+    self.called_actions ||= []
+    self.called_actions << 'some_action'
+  end
+
+  action 'action_q_key' do
+    self.called_actions ||= []
+    self.called_actions << 'action_q_key'
+  end
+
+  key_pressed KeyEvent::VK_Q, :action_q_key
+  key_pressed KeyEvent::VK_W, :undefined_action
+
+  key_pressed KeyEvent::VK_ESCAPE do
+    self.key_pressed_events ||= []
+    self.key_pressed_events << KeyEvent::VK_ESCAPE
+  end
+end
+
+describe Shortcut::Window do
+  let(:window) { Shortcut::Window.new }
+
+  it 'inherits from JFrame' do
+    window.should be_a(JFrame)
+  end
+
+  it 'includes NativeKeyListener' do
+    window.should be_a(NativeKeyListener)
+  end
+
+  it 'includes WindowListener' do
+    window.should be_a(WindowListener)
+  end
+
+  describe :create_button do
+    let(:jbutton) { double('jbutton').as_null_object }
+
+    it 'returns an instance of JButton' do
+      window.create_button('text', 'action').should be_a(JButton)
+    end
+
+    it 'creates a button with text' do
+      JButton.should_receive(:new).with('text').and_return(jbutton)
+      window.create_button('text', anything())
+    end
+
+    it 'creates a button with action' do
+      JButton.should_receive(:new).and_return(jbutton)
+      jbutton.should_receive(:setActionCommand).with('action')
+      window.create_button(anything(), 'action')
+    end
+
+    it 'returns the created button' do
+      JButton.should_receive(:new).and_return(jbutton)
+      window.create_button(anything(), anything()).should eq(jbutton)
+    end
+
+    it 'enables the button by default' do
+      JButton.should_receive(:new).and_return(jbutton)
+      jbutton.should_receive(:setEnabled).with(true)
+      window.create_button(anything(), anything())
+    end
+
+    it 'accepts an enabled option to disable the button' do
+      JButton.should_receive(:new).and_return(jbutton)
+      jbutton.should_receive(:setEnabled).with(false)
+      window.create_button(anything(), anything(), {enabled: false})
+    end
+
+    it 'adds self as action listener' do
+      JButton.should_receive(:new).and_return(jbutton)
+      jbutton.should_receive(:addActionListener).with(window)
+      window.create_button(anything(), anything())
+    end
+  end
+
+  describe :robot do
+    let(:robot) { double('robot') }
+
+    it 'returns an instance of Robot' do
+      window.robot.should be_a(Robot)
+    end
+
+    it 'creates and returns a Robot' do
+      Robot.should_receive(:new).and_return(robot)
+      window.robot.should eq(robot)
+    end
+
+    it 'caches result' do
+      Robot.should_receive(:new).once.and_return(robot)
+      window.robot.should eq(robot)
+      window.robot.should eq(robot)
+    end
+  end
+
+  describe :click do
+    let(:robot) { double('robot') }
+
+    before(:each) do
+      window.stub(:robot) { robot }
+    end
+
+    it 'moves mouse to correct position, presses and releases left mouse button, all in the correct order' do
+      robot.should_receive(:mouseMove).with(1, 2).ordered
+      robot.should_receive(:mousePress).with(InputEvent::BUTTON1_MASK).ordered
+      robot.should_receive(:mouseRelease).with(InputEvent::BUTTON1_MASK).ordered
+      window.click(1, 2)
+    end
+  end
+
+  describe :feedback_text_area do
+    let(:text_area) { double('text area').as_null_object }
+
+    it 'returns an instance of JTextArea' do
+      window.feedback_text_area.should be_a(JTextArea)
+    end
+
+    it 'sets the text' do
+      JTextArea.should_receive(:new).and_return(text_area)
+      text_area.should_receive(:setText).with('Text')
+      window.feedback_text_area('Text')
+    end
+
+    it 'disables the returned area' do
+      JTextArea.should_receive(:new).and_return(text_area)
+      text_area.should_receive(:setEditable).with(false)
+      window.feedback_text_area
+    end
+
+    it 'sets the background white' do
+      JTextArea.should_receive(:new).and_return(text_area)
+      text_area.should_receive(:setBackground).with(Color::WHITE)
+      window.feedback_text_area
+    end
+
+    it 'sets the foreground black' do
+      JTextArea.should_receive(:new).and_return(text_area)
+      text_area.should_receive(:setForeground).with(Color::BLACK)
+      window.feedback_text_area
+    end
+
+    it 'caches result' do
+      JTextArea.should_receive(:new).once.and_return(text_area)
+      window.feedback_text_area.should eq(text_area)
+      window.feedback_text_area.should eq(text_area)
+    end
+  end
+
+  describe :feedback_scroll_panel do
+    let(:text_area) { JTextArea.new }
+    let(:dimension) { Dimension.new }
+
+    it 'returns an instance of JScrollPane' do
+      window.feedback_scroll_panel(text_area, dimension).should be_a(JScrollPane)
+    end
+
+    it 'creates the scroll panel with the text_area argument' do
+      scroll_panel = JScrollPane.new
+      JScrollPane.should_receive(:new).with(text_area).and_return(scroll_panel)
+      window.feedback_scroll_panel(text_area, dimension)
+    end
+
+    it 'sets preferred size' do
+      scroll_panel = JScrollPane.new
+      JScrollPane.should_receive(:new).with(text_area).and_return(scroll_panel)
+      scroll_panel.should_receive(:setPreferredSize).with(dimension)
+      window.feedback_scroll_panel(text_area, dimension)
+    end
+  end
+
+  describe :display_info do
+    it 'append message to feedback text area' do
+      window.display_info('A')
+      window.display_info('B')
+      window.feedback_text_area.getText.should eq("\nA\nB")
+    end
+
+    it 'scrolls down' do
+      window.display_info('A')
+      window.feedback_text_area.getCaretPosition.should eq(1)
+      window.display_info('B')
+      window.feedback_text_area.getCaretPosition.should eq(3)
+      window.display_info('C')
+      window.feedback_text_area.getCaretPosition.should eq(5)
+    end
+  end
+
+  describe :load_image do
+    let(:reader) { double('reader').as_null_object }
+    let(:java_bytes_reader) { double('java bytes reader') }
+    let(:input_stream) { double('input stream') }
+    let(:image_input_stream) { double('image input stream') }
+    let(:image) { double('image') }
+
+    it 'loads an image' do
+      File.should_receive(:read).with('path').and_return(reader)
+      reader.should_receive(:to_java_bytes).and_return(java_bytes_reader)
+      ByteArrayInputStream.should_receive(:new).with(java_bytes_reader).and_return(input_stream)
+      ImageIO.should_receive(:createImageInputStream).with(input_stream).and_return(image_input_stream)
+      ImageIO.should_receive(:read).with(image_input_stream).and_return(image)
+
+      window.load_image('path').should eq(image)
+    end
+  end
+
+  describe :operative_system do
+    it 'returns lowercased os.name property' do
+      java.lang.System.should_receive(:getProperty).with("os.name").and_return('Linux')
+      window.operative_system.should eq('linux')
+    end
+  end
+
+  describe :run do
+    before(:each) do
+      Shortcut::Window.any_instance.stub(:setVisible)
+    end
+
+    describe :title do
+      it 'sets the JFrame title' do
+        title = TitleClass.new
+        title.run
+        title.getTitle.should eq('Test title')
+      end
+
+      it 'sets a JFrame default title of "Shortcut App"' do
+        window.run
+        window.getTitle.should eq('Shortcut App')
+      end
+    end
+
+    describe 'always on top property' do
+      it 'sets property to true' do
+        on_top_true = AlwaysOnTopTrueClass.new
+        on_top_true.should_receive(:setAlwaysOnTop).with(true)
+        on_top_true.run
+      end
+
+      it 'sets property to false' do
+        on_top_false = AlwaysOnTopFalseClass.new
+        on_top_false.should_receive(:setAlwaysOnTop).with(false)
+        on_top_false.run
+      end
+
+      it 'does not set property' do
+        on_top_none = AlwaysOnTopNoneClass.new
+        on_top_none.should_not_receive(:setAlwaysOnTop)
+        on_top_none.run
+      end
+    end
+
+    it 'adds a window listener' do
+      window.should_receive(:addWindowListener).with(window)
+      window.run
+    end
+
+    it 'adds a native key listener' do
+      GlobalScreen.getInstance.should_receive(:addNativeKeyListener).with(window)
+      window.run
+    end
+
+    it 'sets visibility to true' do
+      window.should_receive(:setVisible).with(true)
+      window.run
+    end
+  end
+
+  describe 'window listeners' do
+    [:windowOpened, :windowClosed, :windowClosing, :windowIconified,
+      :windowDeiconified, :windowActivated, :windowDeactivated].each do |event|
+      it { window.should respond_to(event).with(1).argument }
+    end
+
+    describe :windowOpened do
+      it 'requests focus in window' do
+        window.should_receive(:requestFocusInWindow)
+        window.windowOpened(anything())
+      end
+
+      it 'registers native hook' do
+        GlobalScreen.should_receive(:registerNativeHook)
+        window.windowOpened(anything())
+      end
+
+      it 'handles exception when registering native hook' do
+        GlobalScreen.should_receive(:registerNativeHook).and_raise(NativeHookException.new('error message!'))
+        window.should_receive(:display_info).with('org.jnativehook.NativeHookException: error message!')
+        window.windowOpened(anything())
+      end
+    end
+
+    describe :windowClosed do
+      before(:each) do
+        java.lang.System.stub(:exit)
+      end
+
+      it 'unregisters native hook' do
+        GlobalScreen.should_receive(:unregisterNativeHook)
+        window.windowClosed(anything())
+      end
+
+      it 'runs system finalization' do
+        java.lang.System.should_receive(:runFinalization)
+        window.windowClosed(anything())
+      end
+
+      it 'exit system with value 0' do
+        java.lang.System.should_receive(:exit).with(0)
+        window.windowClosed(anything())
+      end
+    end
+  end
+
+  describe 'native key listeners' do
+    [:nativeKeyReleased, :nativeKeyTyped, :nativeKeyPressed].each do |event|
+      it { window.should respond_to(event).with(1).argument }
+    end
+
+    describe :nativeKeyPressed do
+      it 'executes block from key_pressed function' do
+        key_event = OpenStruct.new(getKeyCode: KeyEvent::VK_ESCAPE)
+
+        listener_example = ListenerExampleClass.new
+        listener_example.nativeKeyPressed(key_event)
+
+        listener_example.key_pressed_events.should eq([KeyEvent::VK_ESCAPE])
+      end
+
+      it 'does not raise exception when handler not defined' do
+        key_event = OpenStruct.new(getKeyCode: KeyEvent::VK_0)
+
+        listener_example = ListenerExampleClass.new
+        expect { listener_example.nativeKeyPressed(key_event) }.not_to raise_exception
+      end
+
+      it 'works with an action' do
+        key_event = OpenStruct.new(getKeyCode: KeyEvent::VK_Q)
+
+        listener_example = ListenerExampleClass.new
+        listener_example.nativeKeyPressed(key_event)
+
+        listener_example.called_actions.should eq(['action_q_key'])
+      end
+
+      it 'works with an action' do
+        key_event = OpenStruct.new(getKeyCode: KeyEvent::VK_W)
+
+        listener_example = ListenerExampleClass.new
+        expect { listener_example.nativeKeyPressed(key_event) }.to raise_exception(Shortcut::UndefinedActionError, "undefined action `undefined_action'")
+      end
+    end
+  end
+
+  describe :actionPerformed do
+    it { window.should respond_to(:actionPerformed).with(1).argument }
+
+    it 'executes block from action function' do
+      action_event = OpenStruct.new(getActionCommand: 'some_action')
+
+      listener_example = ListenerExampleClass.new
+      listener_example.actionPerformed(action_event)
+
+      listener_example.called_actions.should eq(['some_action'])
+    end
+
+    it 'does not raise exception when handler not defined' do
+      action_event = OpenStruct.new(getActionCommand: 'undefined_action')
+
+      listener_example = ListenerExampleClass.new
+      expect { listener_example.actionPerformed(action_event) }.not_to raise_exception
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: shortcut
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease:
+platform: ruby
+authors:
+- Décio Ferreira
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-05-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: warbler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+description: Make your own Bot
+email:
+- decioferreira@decioferreira.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/jar/JNativeHook.jar
+- lib/shortcut.rb
+- lib/shortcut/errors.rb
+- lib/shortcut/point.rb
+- lib/shortcut/screen.rb
+- lib/shortcut/version.rb
+- lib/shortcut/window.rb
+- shortcut.gemspec
+- spec/lib/shortcut_point_spec.rb
+- spec/lib/shortcut_window_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/decioferreira/shortcut
+licenses:
+- MIT
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      version: !binary |-
+        MA==
+      hash: 2
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      version: !binary |-
+        MA==
+      hash: 2
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Make your own Bot
+test_files:
+- spec/lib/shortcut_point_spec.rb
+- spec/lib/shortcut_window_spec.rb
+- spec/spec_helper.rb