mohawk 0.1.4 → 0.2

data/lib/mohawk/accessors/menu_item.rb

@@ -1,21 +0,0 @@
-module Mohawk
-  module Accessors
-    class MenuItem
-      def initialize(adapter, locator)
-        @adapter = adapter
-        @locator = locator
-      end
-
-      def select
-        menu_item.open
-      end
-
-      private
-      def menu_item
-        @locator[:path].reduce(@adapter.window) do |the_menu, menu_item|
-          the_menu.menu :text => menu_item
-        end
-      end
-    end
-  end
-end

data/lib/mohawk/accessors/radio.rb

@@ -1,19 +0,0 @@
-module Mohawk
-  module Accessors
-    class Radio
-      attr_reader :view
-
-      def initialize(adapter, locator)
-        @view = adapter.window.radio(locator)
-      end
-
-      def set
-        @view.set
-      end
-
-      def set?
-        @view.set?
-      end
-    end
-  end
-end

data/lib/mohawk/accessors/spinner.rb

@@ -1,27 +0,0 @@
-module Mohawk
-  module Accessors
-    class Spinner
-      attr_reader :view
-
-      def initialize(adapter, locator)
-        @view = adapter.window.spinner(locator)
-      end
-
-      def value
-        @view.value
-      end
-
-      def value=(value)
-        @view.set value
-      end
-
-      def increment
-        @view.increment
-      end
-
-      def decrement
-        @view.decrement
-      end
-    end
-  end
-end

data/lib/mohawk/accessors/table.rb

@@ -1,69 +0,0 @@
-module Mohawk
-  module Accessors
-    class Table
-      attr_reader :view
-
-      include Enumerable
-
-      def initialize(adapter, locator)
-        @view = adapter.window.table(locator)
-      end
-
-      def select(which_item)
-        find_row_with(which_item).select
-      end
-
-      def add(which_item)
-        find_row_with(which_item).add_to_selection
-      end
-
-      def clear_all
-        view.selected_rows.each(&:clear)
-      end
-
-      def clear(which_item)
-        find_row_with(which_item).clear
-      end
-
-      def find_row_with(row_info)
-        found_row = case row_info
-                      when Hash
-                        find_by_hash(row_info)
-                      when Fixnum
-                        find_by_index(row_info)
-                      when String
-                        find_by_value(row_info)
-                    end
-        raise "A row with #{row_info} was not found" unless found_row
-        found_row
-      end
-
-      def headers
-        RAutomation::Adapter::MsUia::UiaDll.table_headers(view.search_information)
-      end
-
-      def [](row)
-        TableRow.new(self, row)
-      end
-
-      def each
-        view.row_count.times.map do |row|
-          yield TableRow.new(self, row)
-        end
-      end
-
-      private
-      def find_by_index(which_item)
-        self[which_item]
-      end
-
-      def find_by_value(which_item)
-        find { |r| r.row.value == which_item }
-      end
-
-      def find_by_hash(row_info)
-        find { |r| r.all_match? row_info }
-      end
-    end
-  end
-end

data/lib/mohawk/accessors/table_row.rb

@@ -1,62 +0,0 @@
-module Mohawk
-  module Accessors
-    class TableRow
-      include RAutomation::Adapter::MsUia
-
-      attr_reader :row
-
-      def initialize(table, row_index)
-        @table = table
-        @row = Row.new(@table.view, :index => row_index)
-      end
-
-      def selected?
-        row.selected?
-      end
-
-      def select
-        UiaDll::table_single_select(@table.view.search_information, row.row)
-        self
-      end
-
-      def add_to_selection
-        row.select
-        self
-      end
-
-      def clear
-        row.clear
-        self
-      end
-
-      def cells
-        row.cells.map &:text
-      end
-
-      def all_match?(hash)
-        hash.all? do |key, value|
-          send(key) == "#{value}"
-        end
-      end
-
-      def value_from_header(name)
-        which_column = header_methods.index(name)
-        raise ArgumentError, "#{name} column does not exist in #{header_methods}" if which_column.nil?
-        Cell.new(row, :index => which_column).text
-      end
-      
-      def method_missing(name, *args)
-        value_from_header name
-      end
-
-      def to_hash
-        {:text => row.text, :row => row.row }
-      end
-
-      private
-      def header_methods
-        @headers ||= @table.headers.map(&:to_method)
-      end
-    end
-  end
-end

data/lib/mohawk/accessors/tabs.rb

@@ -1,30 +0,0 @@
-module Mohawk
-  module Accessors
-    class Tabs
-      attr_reader :view
-
-      def initialize(adapter, locator)
-        @view = adapter.window.tab_control(locator)
-      end
-
-      def value
-        view.value
-      end
-
-      def selected_tab=(which)
-        case which
-          when String
-            view.set(which)
-          when Regexp
-            view.set items.find {|t| t.match which }
-          else
-            view.select(which)
-        end
-      end
-
-      def items
-        @view.items.map(&:text)
-      end
-    end
-  end
-end

data/lib/mohawk/accessors/text.rb

@@ -1,29 +0,0 @@
-module Mohawk
-  module Accessors
-    class Text
-      attr_reader :view 
-
-      def initialize(adapter, locator)
-        @adapter = adapter
-        @view = adapter.window.text_field(locator)
-      end
-
-      def value
-        @view.value
-      end
-
-      def set(text)
-        @view.set text
-      end
-
-      def clear
-        @view.clear
-      end
-
-      def enter(text)
-        text_window = @adapter.window.child(:hwnd => @view.hwnd)
-        text_window.send_keys text.split(//)
-      end
-    end
-  end
-end

data/lib/mohawk/accessors/tree_view.rb

@@ -1,32 +0,0 @@
-module Mohawk
-  module Accessors
-    class TreeView
-      attr_reader :view
-
-      def initialize(adapter, locator)
-        @view = adapter.window.select_list(locator)
-      end
-
-      def value
-        @view.value
-      end
-
-      def items
-        @view.options.map &:text
-      end
-
-      def expand(which_item)
-        @view.expand which_item
-      end
-
-      def collapse(which_item)
-        @view.collapse which_item
-      end
-
-      def select(which_item)
-        @view.options[which_item].select if which_item.is_a? Integer
-        @view.option(text: which_item).select if which_item.is_a? String
-      end
-    end
-  end
-end

data/spec/lib/mohawk/accessors/button_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-class ButtonScreen
-  include Mohawk
-  window(:id => nil)
-
-  button(:easy, :id => "easyButton")
-end
-
-describe Mohawk::Accessors::Button do
-  let(:screen) { ButtonScreen.new }
-  let(:window) { double("RAutomation Window") }
-  let(:button_field) { double("Button Field") }
-
-  before(:each) do
-    RAutomation::Window.stub(:new).and_return(window)
-    window.should_receive(:button).with(:id => "easyButton").and_return(button_field)
-  end
-
-  context "accessing buttons" do
-
-    it "clicks buttons" do
-      button_field.should_receive(:click).and_yield
-      screen.easy
-    end
-
-    it "clicks buttons and yields to a block" do
-      button_field.should_receive(:click).and_yield
-      result = false
-      screen.easy do
-        result = true
-      end
-      result.should be_true
-    end
-
-    it "knows the value of the button" do
-      button_field.should_receive(:value).and_return "Button Value"
-      screen.easy_value.should eq("Button Value")
-    end
-
-    it "can dish out the view" do
-      screen.easy_view.should be(button_field)
-    end
-  end
-end

data/spec/lib/mohawk/accessors/checkbox_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-class CheckboxScreen
-  include Mohawk
-  window(:id => nil)
-
-  checkbox(:check_yourself, :id => "checkboxId")
-end
-
-describe Mohawk::Accessors::CheckBox do
-  let(:screen) { CheckboxScreen.new }
-  let(:window) { double("RAutomation Window") }
-  let(:checkbox_field) { double("CheckBox Field") }
-
-  before(:each) do
-    RAutomation::Window.stub(:new).and_return(window)
-    window.should_receive(:checkbox).with(:id => "checkboxId").and_return(checkbox_field)
-  end
-
-  context "accessing checkbox controls" do
-
-    it "knows if something is checked" do
-      checkbox_field.should_receive(:set?).and_return(true)
-      screen.check_yourself.should be_true
-    end
-
-    it "can get the text of the checkbox" do
-      checkbox_field.should_receive(:value).and_return("CheckBox Text")
-      screen.check_yourself_value.should eq("CheckBox Text")
-    end
-
-    it "can check items" do
-      checkbox_field.should_receive(:set)
-      screen.check_yourself = true
-    end
-
-    it "can uncheck items" do
-      checkbox_field.should_receive(:clear)
-      screen.check_yourself = false
-    end
-
-    it "can dish out the raw control" do
-      screen.check_yourself_view.should be(checkbox_field)
-    end
-  end
-end

data/spec/lib/mohawk/accessors/combo_spec.rb

@@ -1,119 +0,0 @@
-require 'spec_helper'
-
-class ComboBoxScreen
-  include Mohawk
-  window(:id => nil)
-  
-  combo_box(:nacho_combos, :id => "comboBoxId")
-  dropdown(:my_default, :id => "defaultAliasId")
-  dropdown(:my_combobox, :id => "comboboxAliasId")
-  dropdown(:my_dropdown, :id => "dropdownAliasId")
-  dropdown(:my_drop_down, :id => "drop_downAliasId")
-  dropdown(:my_select_list, :id => "select_listAliasId")
-end
-
-class Option
-  def initialize(text)
-    @text = text
-  end
-
-  def text
-    @text
-  end
-end
-
-describe Mohawk::Accessors::Combo do
-  let(:screen) { ComboBoxScreen.new }
-  let(:window) { double("RAutomation Window") }
-  let(:combo_box_field) { double("ComboBox Field") }
-  let(:options) { double("ComboBox::Options").as_null_object }
-
-  before(:each) do
-    RAutomation::Window.stub(:new).and_return(window)
-    combo_box_field.stub(:options).and_return(options)
-  end
-
-  context "accessing combo box controls" do
-
-    before(:each) do
-      window.should_receive(:select_list).with(:id => "comboBoxId").and_return(combo_box_field)
-    end
-
-    it "knows the current selected item" do
-      combo_box_field.should_receive(:value).and_return("Selected Item")
-      screen.nacho_combos.should eq("Selected Item")
-    end
-
-    it 'knows the currently selected items' do
-      combo_box_field.should_receive(:values).and_return(['first', 'second'])
-      screen.nacho_combos_selections.should eq(['first', 'second'])
-    end
-
-    it "selects items by index" do
-      options.should_receive(:[]).with(3).and_return(double.as_null_object)
-      screen.nacho_combos = 3
-    end
-
-    it "selects items by value" do
-      option = double('combo option')
-      combo_box_field.should_receive(:option).with(text: "Desired Value").and_return(option)
-      option.should_receive(:select)
-
-      screen.nacho_combos = "Desired Value"
-    end
-
-    it 'select is an alias for equals' do
-      option = double('combo option')
-      combo_box_field.should_receive(:option).with(text: 'Desired Value').and_return(option)
-      option.should_receive(:select)
-
-      screen.select_nacho_combos 'Desired Value'
-    end
-
-    it 'clears items by index' do
-      option = double('combo option')
-      options.should_receive(:[]).with(3).and_return(option)
-      option.should_receive(:clear)
-
-      screen.clear_nacho_combos 3
-    end
-
-    it 'clears items by value' do
-      option = double('combo option')
-      combo_box_field.should_receive(:option).with(text: 'Desired Value').and_return(option)
-      option.should_receive(:clear)
-
-      screen.clear_nacho_combos 'Desired Value'
-    end
-
-    it "is aware of the available options" do
-      options = [Option.new("first"), Option.new("second"), Option.new("third")]
-      combo_box_field.should_receive(:options).and_return(options)
-      screen.nacho_combos_options.should eq(["first", "second", "third"])
-    end
-
-    it "can dish out the combo view" do
-      screen.nacho_combos_view.should be(combo_box_field)
-    end
-  end
-
-  context "aliases for combo_box" do
-    let(:null_combo) { double("Null ComboBox Field").as_null_object }
-    let(:combo_aliases) { ["default", "combobox", "dropdown", "drop_down", "select_list"] }
-
-    def expected_alias(id)
-      window.should_receive(:select_list).with(:id => "#{id}AliasId").ordered.and_return(null_combo)
-    end
-
-    it "has many aliases" do
-      combo_aliases.each do |which_alias|
-        expected_alias which_alias
-      end
-
-      combo_aliases.each do |which_alias|
-        screen.send "my_#{which_alias}"
-      end
-    end
-  end
-end
-

data/spec/lib/mohawk/accessors/control_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-class ControlScreen
-  include Mohawk
-  window(:id => nil)
-
-  control(:control_yourself, :id => "controlId")
-end
-
-describe Mohawk::Accessors::Control do
-  let(:screen) { ControlScreen.new }
-  let(:window) { double("RAutomation Window") }
-  let(:control) { double("Control Window") }
-
-  before(:each) do
-    RAutomation::Window.stub(:new).and_return(window)
-    window.should_receive(:value_control).with(:id => 'controlId').and_return(control)
-  end
-
-  it "can get the value" do
-    control.should_receive(:value).and_return('expected value')
-    screen.control_yourself_value.should eq('expected value')
-  end
-
-  it "can set the value" do
-    control.should_receive(:set).with('new value')
-    screen.control_yourself = 'new value'
-  end
-
-  it "can click the control" do
-    control.should_receive(:click).and_yield
-    screen.click_control_yourself
-  end
-
-  it "can give a custom block to the click method" do
-    control.should_receive(:click).and_yield
-    result = false
-    screen.click_control_yourself do
-      result = true
-    end
-    result.should be_true
-  end
-
-  it "can work with the raw view" do
-    screen.control_yourself_view.should be(control)
-  end
-end

data/spec/lib/mohawk/accessors/label_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-class LabelScreen
-	include Mohawk
-	
-	window(:title => nil)
-	label(:label_control, :id => "labelID")
-end
-
-describe Mohawk::Accessors::Label do
-	let(:screen) { LabelScreen.new }
-	let(:window) { double("RAutomation Window") }
-	let(:label_control) { double("Label Control") }
-	
-	before(:each) do
-		RAutomation::Window.stub(:new).and_return(window)
-		window.should_receive(:label).with(:id => "labelID").and_return(label_control)
-	end
-	
-	it "can retrieve the label value" do
-		label_control.should_receive(:value).and_return("some string")
-		screen.label_control.should eq("some string")
-	end
-
-  it "can dish out the view" do
-    screen.label_control_view.should eq(label_control)
-  end
-
-end

data/spec/lib/mohawk/accessors/link_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-class LinkScreen
-  include Mohawk
-
-  window(:title => nil)
-  link(:link_control, :id => "linkID")
-end
-
-describe Mohawk::Accessors::Link do
-  let(:screen) { LinkScreen.new }
-  let(:window) { double("RAutomation Window") }
-  let(:link_control) { double("Link Control") }
-
-  before(:each) do
-    RAutomation::Window.stub(:new).and_return(window)
-    window.should_receive(:label).with(:id => "linkID").and_return(link_control)
-  end
-
-  it "can retrieve the link text" do
-    link_control.should_receive(:value).and_return("some string")
-    screen.link_control_text.should eq("some string")
-  end
-
-  it "can click on the link" do
-    link_control.should_receive(:click)
-    screen.click_link_control
-  end
-
-  it "can dish out the view" do
-    screen.link_control_view.should be(link_control)
-  end
-
-end

data/spec/lib/mohawk/accessors/menu_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-class MenuItemScreen
-  include Mohawk
-  window(:id => nil)
-  
-  menu_item(:the_menu_item, :path => ["Path", "To", "Some Menu", "Item"])
-end
-
-describe Mohawk::Accessors::MenuItem do
-  let(:screen) { MenuItemScreen.new }
-  let(:window) { double("RAutomation Window") }
-  let(:menu) { double("RAutomation Menu Item") }
-
-  before(:each) do
-    RAutomation::Window.stub(:new).and_return(window)
-  end
-
-  context "selecting menu items" do
-    before(:each) do
-      window.should_receive(:menu).with(:text => "Path").and_return(menu)
-    end
-
-    it "can open a menu item" do
-      menu.should_receive(:menu).with(:text => "To").and_return(menu)
-      menu.should_receive(:menu).with(:text => "Some Menu").and_return(menu)
-      menu.should_receive(:menu).with(:text => "Item").and_return(menu)
-      menu.should_receive(:open)
-      screen.the_menu_item
-    end
-  end
-end

data/spec/lib/mohawk/accessors/radio_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-class RadioScreen
-  include Mohawk
-  window(:id => nil)
-
-  radio(:radio_radio, :id => "radioId")
-end
-
-describe Mohawk::Accessors::Radio do
-  let(:screen) { RadioScreen.new }
-  let(:window) { double("RAutomation Window") }
-  let(:radio_control) { double("Elvis Costello's Radio Radio") }
-
-  before(:each) do
-    RAutomation::Window.stub(:new).and_return(window)
-    window.should_receive(:radio).with(:id => "radioId").and_return(radio_control)
-  end
-
-  context "working with radio controls" do
-    it "can set the radio control" do
-      radio_control.should_receive(:set)
-      screen.radio_radio
-    end
-
-    it "knows if the radio is selected" do
-      radio_control.should_receive(:set?)
-      screen.radio_radio?
-    end
-
-    it "can dish out the raw view" do
-      screen.radio_radio_view.should be(radio_control)
-    end
-  end
-end