AXElements 0.7.6 → 0.7.7

data/lib/accessibility/core.rb

@@ -378,8 +378,8 @@ module Accessibility::Core
   # events).
   #
   # This is just a magic number from trial and error. Both the repeat
-  # interval (NXKeyRepeatInterval) and threshold (NXKeyRepeatThreshold),
-  # but both were way too big.
+  # interval (NXKeyRepeatInterval) and threshold (NXKeyRepeatThreshold)
+  # were tried, but were way too big.
   #
   # @return [Number]
   KEY_RATE = case ENV['KEY_RATE']

data/lib/accessibility/dsl.rb

@@ -210,7 +210,7 @@ module Accessibility::DSL
   #
   # @param [AX::Element]
   def set_focus_to element
-    element.set(:focused, true) if element.respond_to? :focused
+    element.set(:focused, true) if element.writable? :focused
   end
   alias_method :set_focus, :set_focus_to
 
@@ -242,15 +242,13 @@ module Accessibility::DSL
   #
   # @return [nil] do not rely on a return value
   def set element, change
-    if element.respond_to? :focused
-      if element.writable? :focused
-        element.set :focused, true
-      end
-    end
+    set_focus_to element
 
-    return element.set :value, change unless change.kind_of? Hash
-    key, value = change.first
-    return element.set key, value
+    if change.kind_of? Hash
+      element.set *change.first
+    else
+      element.set :value, change
+    end
   end
 
   ##
@@ -267,9 +265,10 @@ module Accessibility::DSL
   #   Send input to a specific application
   #   @param [#to_s]
   #   @param [AX::Application]
+  #
   def type string, app = system_wide
     sleep 0.1
-    app.type_string string.to_s
+    app.type string.to_s
   end
 
   ##

data/lib/accessibility/enumerators.rb

@@ -18,13 +18,11 @@ module Accessibility::Enumerators
     #
     # @yieldparam [AX::Element]
     def each
-      # @todo Lazy-wrap element refs, might make things a bit faster
-      #       for fat trees; what is impact on thin trees?
-      # @todo See if we can implement the method in a single loop
+      # @todo Mutate the queue less
       queue = [@root]
       until queue.empty?
         queue.shift.attribute(:children).each do |x|
-          queue << x if x.attributes.include? :children
+          queue << x
           yield x
         end
       end
@@ -61,10 +59,8 @@ module Accessibility::Enumerators
       until stack.empty?
         current = stack.shift
         yield current
-        if current.attributes.include? :children
-          # need to reverse it since child ordering seems to matter in practice
-          stack.unshift *current.attribute(:children)
-        end
+        # needed to reverse it since child ordering seems to matter in practice
+        stack.unshift *current.attribute(:children)
       end
     end
 
@@ -92,10 +88,8 @@ module Accessibility::Enumerators
     # @param [#call]
     def recursive_each_with_level element, depth, block
       block.call element, depth
-      if element.respond_to? :children
-        element.attribute(:children).each do |x|
-          recursive_each_with_level x, depth + 1, block
-        end
+      element.attribute(:children).each do |x|
+        recursive_each_with_level x, depth + 1, block
       end
     end
 

data/lib/accessibility/factory.rb

@@ -66,11 +66,16 @@ module Accessibility::Factory
   # @param [AXUIElementRef]
   # @return [AX::Element]
   def process_element ref
-    role = TRANSLATOR.unprefix ref.role
-
-    # Some objects claim to have a subrole but return nil
-    klass = if subrole = ref.subrole
-              class_for TRANSLATOR.unprefix(subrole), and: role
+    role  = TRANSLATOR.unprefix ref.role
+    attrs = ref.attributes
+    klass = if attrs.include? KAXSubroleAttribute
+              subrole = ref.subrole
+              # Some objects claim to have a subrole but return nil
+              if subrole
+                class_for TRANSLATOR.unprefix(subrole), and: role
+              else
+                class_for role
+              end
             else
               class_for role
             end
@@ -82,9 +87,9 @@ module Accessibility::Factory
   #
   # @return [Array]
   def process_array vals
-    (vals.empty? && vals)                         ||
-    (CFGetTypeID(vals.first) != REF_TYPE && vals) ||
-    vals.map { |val| process_element val }
+    return vals if vals.empty?
+    return vals if CFGetTypeID(vals.first) != REF_TYPE
+    return vals.map { |val| process_element val }
   end
 
   ##
@@ -132,7 +137,7 @@ module Accessibility::Factory
 
   ##
   # Create a new class in the {AX} namesapce that has the given
-  # `superklass` as the superclass.
+  # `superklass` as the superclass..
   #
   # @param [#to_s] name
   # @param [#to_s] superklass

data/lib/accessibility/graph.rb

@@ -56,11 +56,11 @@ class Accessibility::Graph
     end
 
     def enabled
-      FILL if @element.respond_to?(:enabled) && !@element.enabled?
+      FILL if @element.enabled?
     end
 
     def focus
-      BOLD if @element.respond_to?(:focused) && @element.focused?
+      BOLD if @element.focused?
     end
 
     OVAL = '[shape = oval]'

data/lib/accessibility/qualifier.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require 'accessibility/translator'
 
 ##
@@ -37,9 +38,7 @@ class Accessibility::Qualifier
   #
   # @param [AX::Element]
   def qualifies? element
-    return false unless the_right_type? element
-    return false unless meets_criteria? element
-    return true
+    the_right_type?(element) && meets_criteria?(element)
   end
 
   # @return [String]
@@ -65,18 +64,18 @@ class Accessibility::Qualifier
   def compile criteria
     @filters = criteria.map do |key, value|
       if value.kind_of? Hash
-        [:children, [:subsearch, key, value]]
+        [:subsearch, key, value]
       elsif key.kind_of? Array
         filter = value.kind_of?(Regexp) ?
           :parameterized_match : :parameterized_equality
-        [key.first, [filter, *key, value]]
+        [filter, *key, value]
       else
         filter = value.kind_of?(Regexp) ?
           :match : :equality
-        [key, [filter, key, value]]
+        [filter, key, value]
       end
     end
-    @filters << [:role, [:block_check]] if @block
+    @filters << [:block_check] if @block
   end
 
   ##
@@ -92,7 +91,7 @@ class Accessibility::Qualifier
         return false
       end
     end
-    return element.kind_of? @const
+    element.kind_of? @const
   end
 
   ##
@@ -102,9 +101,7 @@ class Accessibility::Qualifier
   # @param [AX::Element]
   def meets_criteria? element
     @filters.all? do |filter|
-      if element.respond_to? filter.first
-        self.send *filter.last, element
-      end
+      self.send *filter, element
     end
   end
 
@@ -113,7 +110,7 @@ class Accessibility::Qualifier
   end
 
   def match attr, regexp, element
-    element.attribute(attr).match regexp
+    element.attribute(attr).to_s.match regexp
   end
 
   def equality attr, value, element
@@ -121,7 +118,7 @@ class Accessibility::Qualifier
   end
 
   def parameterized_match attr, param, regexp, element
-    element.attribute(attr, for_parameter: param).match regexp
+    element.attribute(attr, for_parameter: param).to_s.match regexp
   end
 
   def parameterized_equality attr, param, value, element

data/lib/accessibility/translator.rb

@@ -27,8 +27,8 @@ class Accessibility::Translator
   # Initialize the caches.
   def initialize
     init_unprefixes
-    init_normalizations
     init_rubyisms
+    init_cocoaifications
     init_classifications
     init_singularizations
   end
@@ -54,32 +54,18 @@ class Accessibility::Translator
     @unprefixes[key]
   end
 
-  ##
-  # Given a symbol, return the equivalent accessibility constant.
-  #
-  # @param [#to_sym]
-  # @param [Array<String>]
-  # @return [String]
-  def lookup key, values
-    @values = values
-    @rubyisms[key.to_sym]
-  end
-
   # @return [Array<Symbol>]
   def rubyize keys
-    keys.map { |x| @normalizations[x] }
+    keys.map { |x| @rubyisms[x] }
   end
 
   ##
-  # Try to turn an arbitrary symbol into a notification constant, and
-  # then get the value of the constant.
+  # Given a symbol, return the equivalent accessibility constant.
   #
-  # @param [#to_s]
+  # @param [#to_sym]
   # @return [String]
-  def guess_notification_for name
-    name  = name.to_s.gsub /(?:^|_)(.)/ do $1.upcase! || $1 end
-    const = "KAX#{name}Notification"
-    Object.const_defined?(const) ? Object.const_get(const) : name
+  def cocoaify key
+    @cocoaifications[key.to_sym]
   end
 
   ##
@@ -114,36 +100,46 @@ class Accessibility::Translator
     @singularizations[klass]
   end
 
+  ##
+  # Try to turn an arbitrary symbol into a notification constant, and
+  # then get the value of the constant.
+  #
+  # @param [#to_s]
+  # @return [String]
+  def guess_notification name
+    name  = name.to_s.gsub /(?:^|_)(.)/ do $1.upcase! || $1 end
+    const = "KAX#{name}Notification"
+    Object.const_defined?(const) ? Object.const_get(const) : name
+  end
+
 
   private
 
   # @return [Hash{String=>String}]
   def init_unprefixes
     @unprefixes = Hash.new do |hash, key|
-      hash[key] = key.sub /^[A-Z]*?AX(?:Is)?|\s+/, EMPTY_STRING
+      hash[key] = key.sub /^[A-Z]*?AX|\s+/, EMPTY_STRING
     end
   end
 
   # @return [Hash{String=>Symbol}]
-  def init_normalizations
-    @normalizations = Hash.new do |hash, key|
+  def init_rubyisms
+    @rubyisms = Hash.new do |hash, key|
       hash[key] = Accessibility::Inflector.underscore(@unprefixes[key]).to_sym
     end
   end
 
   # @return [Hash{Symbol=>String}]
-  def init_rubyisms
-    @rubyisms = Hash.new do |hash, key|
-      @values.each do |v| hash[@normalizations[v]] = v end
-      hash.fetch(key) do |k|
-        chomped_key = k.chomp(QUESTION_MARK).to_sym
-        chomped_val = hash.fetch(chomped_key, nil)
-        hash[key]   = chomped_val if chomped_val
-      end
+  def init_cocoaifications
+    @cocoaifications = Hash.new do |hash, key|
+      hash[key] = "AX#{Accessibility::Inflector.camelize(key.chomp QUESTION_MARK)}"
     end
     # preload the table
-    @rubyisms[:id]          = KAXIdentifierAttribute
-    @rubyisms[:placeholder] = KAXPlaceholderValueAttribute
+    @cocoaifications[:id]          = KAXIdentifierAttribute
+    @cocoaifications[:placeholder] = KAXPlaceholderValueAttribute
+    # workaround the one known case where AX uses "Is" for a boolean attribute
+    @cocoaifications[:application_running]  = # let the value all fall through
+    @cocoaifications[:application_running?] = KAXIsApplicationRunningAttribute
   end
 
   # @return [Hash{String=>String}]

data/lib/accessibility/version.rb

@@ -1,6 +1,6 @@
 module Accessibility
   # @return [String]
-  VERSION   = '0.7.6'
+  VERSION   = '0.7.7'
 
   # @return [String]
   CODE_NAME = 'Clefairy'

data/lib/ax/application.rb

@@ -47,15 +47,23 @@ class AX::Application < AX::Element
   # @group Attributes
 
   ##
-  # Overridden to handle the {Accessibility::Language#set_focus} case.
+  # Overridden to handle the {Accessibility::DSL#set_focus} case.
   #
   # (see AX::Element#attribute)
   def attribute attr
     case attr
     when :focused?, :focused then active?
     when :hidden?,  :hidden  then hidden?
-    else
-      super
+    else super
+    end
+  end
+
+  ##
+  # Overridden to handle the {Accessibility::DSL#set_focus_to} case.
+  def writable? attr
+    case attr
+    when :focused?, :focused, :hidden?, :hidden then true
+    else super
     end
   end
 
@@ -136,7 +144,7 @@ class AX::Application < AX::Element
   # {file:docs/KeyboardEvents.markdown Keyboard} documentation.
   #
   # @return [Boolean]
-  def type_string string
+  def type string
     @ref.post keyboard_events_for string
     true
   end
@@ -199,7 +207,7 @@ class AX::Application < AX::Element
   # @return [AX::Window]
   def show_preferences_window
     windows = self.children.select { |x| x.kind_of? AX::Window }
-    type_string "\\COMMAND+,"
+    type "\\COMMAND+,"
     wait_for(:window, parent: self) { |window| !windows.include?(window) }
   end
 

data/lib/ax/element.rb

@@ -49,10 +49,8 @@ class AX::Element
   #   element.attribute :position # => #<CGPoint x=123.0 y=456.0>
   #
   # @param [#to_sym]
-  def attribute name
-    if rattr = TRANSLATOR.lookup(name, @ref.attributes)
-      process @ref.attribute(rattr)
-    end
+  def attribute attr
+    process @ref.attribute TRANSLATOR.cocoaify attr
   end
 
   ##
@@ -77,11 +75,7 @@ class AX::Element
   # @param [#to_sym]
   # @return [Number]
   def size_of attr
-    if rattr = TRANSLATOR.lookup(attr, @ref.attributes)
-      @ref.size_of rattr
-    else
-      0
-    end
+    @ref.size_of TRANSLATOR.cocoaify attr
   end
 
   ##
@@ -107,11 +101,7 @@ class AX::Element
   #
   # @param [#to_sym]
   def writable? attr
-    if rattr = TRANSLATOR.lookup(attr, @ref.attributes)
-      @ref.writable? rattr
-    else
-      false
-    end
+    @ref.writable? TRANSLATOR.cocoaify attr
   end
 
   ##
@@ -129,7 +119,7 @@ class AX::Element
       raise NoMethodError, "#{attr} is read-only for #{inspect}"
     end
     value = value.relative_to(@ref.value.size) if value.kind_of? Range
-    @ref.set TRANSLATOR.lookup(attr, @ref.attributes), value
+    @ref.set TRANSLATOR.cocoaify(attr), value
   end
 
 
@@ -158,7 +148,7 @@ class AX::Element
   #
   # @param [#to_sym]
   def attribute attr, for_parameter: param
-    if rattr = TRANSLATOR.lookup(attr, @ref.parameterized_attributes)
+    if rattr = TRANSLATOR.cocoaify(attr)
       param = param.relative_to(@ref.value.size) if value.kind_of? Range
       process @ref.attribute(rattr, for_parameter: param)
     end
@@ -197,7 +187,7 @@ class AX::Element
   # @param [#to_sym]
   # @return [Boolean] true if successful
   def perform action
-    if raction = TRANSLATOR.lookup(action, @ref.actions)
+    if raction = TRANSLATOR.cocoaify(action)
       @ref.perform raction
     else
       false
@@ -298,17 +288,17 @@ class AX::Element
   #   window.application # => SearchFailure is raised
   #
   def method_missing method, *args, &block
-    if method[-1] == EQUALS
-      return set(method.chomp(EQUALS), args.first)
+    return set(method.chomp(EQUALS), args.first) if method[-1] == EQUALS
 
-    elsif attributes.include? method
+    key = TRANSLATOR.cocoaify method
+    if @ref.attributes.include? key
       return attribute method
 
-    elsif parameterized_attributes.include? method
-      return attribute method, for_parameter: args.first
+    elsif @ref.parameterized_attributes.include? key
+      return attribute(method, for_parameter: args.first)
 
-    elsif attributes.include? :children
-      if (result = search method, *args, &block).blank?
+    elsif @ref.attributes.include? KAXChildrenAttribute
+      if (result = search(method, *args, &block)).blank?
         raise Accessibility::SearchFailure.new(self, method, args.first)
       else
         return result
@@ -359,7 +349,7 @@ class AX::Element
   # @yieldreturn [Boolean]
   # @return [Array(Observer, String, CFRunLoopSource)]
   def on_notification name, &block
-    notif    = TRANSLATOR.guess_notification_for name
+    notif    = TRANSLATOR.guess_notification name
     observer = @ref.observer &notif_callback_for(&block)
     source   = @ref.run_loop_source_for observer
     @ref.register observer, to_receive: notif
@@ -396,11 +386,10 @@ class AX::Element
   # @return [String]
   def inspect
     msg  = "#<#{self.class}" << pp_identifier
-    attrs = @ref.attributes
-    msg << pp_position if attrs.include? KAXPositionAttribute
-    msg << pp_children if attrs.include? KAXChildrenAttribute
-    msg << pp_checkbox(:enabled) if attrs.include? KAXEnabledAttribute
-    msg << pp_checkbox(:focused) if attrs.include? KAXFocusedAttribute
+    msg << pp_position if attributes.include? :position
+    msg << pp_children if attributes.include? :children
+    msg << pp_checkbox(:enabled) if attributes.include? :enabled
+    msg << pp_checkbox(:focused) if attributes.include? :focused
     msg << '>'
   end
 
@@ -418,9 +407,12 @@ class AX::Element
   ##
   # Overriden to respond properly with regards to dynamic attribute
   # lookups, but will return false for potential implicit searches.
+  #
+  # This does not work for predicate methods at the moment.
   def respond_to? name
-    attributes.include?(name)               ||
-    parameterized_attributes.include?(name) ||
+    key = TRANSLATOR.cocoaify name.chomp(EQUALS)
+    @ref.attributes.include?(key)               ||
+    @ref.parameterized_attributes.include?(key) ||
     super
   end
 

data/lib/ax/systemwide.rb

@@ -18,7 +18,7 @@ class AX::SystemWide < AX::Element
   end
 
   ##
-  # @note With the `SystemWide` class, using {#type_string} will send the
+  # @note With the `SystemWide` class, using {#type} will send the
   #       events to which ever app has focus.
   #
   # Generate keyboard events by simulating keyboard input.
@@ -27,7 +27,7 @@ class AX::SystemWide < AX::Element
   # more information on how to format strings.
   #
   # @return [Boolean]
-  def type_string string
+  def type string
     @ref.post keyboard_events_for string
     true
   end

data/rakelib/ext.rake

@@ -24,7 +24,7 @@ end
 namespace :ext do
   extend ExtHelpers
 
-  desc 'Compile C extensions'
+  desc 'Compile the key_coder C extension'
   task :key_coder do
     dir = 'ext/accessibility/key_coder'
     ext = "#{dir}/key_coder"

data/test/integration/accessibility/test_dsl.rb

@@ -12,29 +12,15 @@ class TestAccessibilityDSL < MiniTest::Unit::TestCase
     @dsl ||= DSL.new
   end
 
-  def app
-    @@app ||= AX::Application.new REF
-  end
-
-  def text_area
-    @@text_area ||= app.main_window.text_area
-  end
-
-  def pref_window
-    app.children.find { |x|
-      x.attributes.include?(:title) && x.title == 'Preferences'
-    }
-  end
-
-  def spelling_window
-    app.children.find { |x|
-      x.attributes.include?(:title) && x.title.match(/^Spelling/)
-    }
-  end
+  def app;             @@app       ||= AX::Application.new REF                               end
+  def text_area;       @@text_area ||= app.main_window.text_area                             end
+  def pref_window;     app.children.find { |x| x.attribute(:title) == 'Preferences'   }      end
+  def spelling_window; app.children.find { |x| x.attribute(:title).to_s.match(/^Spelling/) } end
 
   def try_typing string, expected = nil
     expected = string unless expected
     text_area.set :focused, true
+    assert text_area.focused?
     dsl.type string
     assert_equal expected, text_area.value
   ensure # reset for next test
@@ -219,16 +205,16 @@ class TestAccessibilityDSL < MiniTest::Unit::TestCase
     pop_up = app.main_window.pop_up_button
 
     pop_up.perform :press
-    expected = pop_up.menu_item(title: '49')
-    dsl.scroll_menu_to expected
-    assert_equal expected, element_under_mouse
+    item = wait_for :menu_item, ancestor: pop_up, title: '49'
+    dsl.scroll_menu_to item
+    assert_equal item, element_under_mouse
     dsl.click
     assert_equal '49', pop_up.value
 
     pop_up.perform :press
-    expected = pop_up.menu_item(title: 'Togusa')
-    dsl.scroll_menu_to expected
-    assert_equal expected, element_under_mouse
+    item = wait_for :menu_item, ancestor: pop_up, title: 'Togusa'
+    dsl.scroll_menu_to item
+    assert_equal item, element_under_mouse
     dsl.click
     assert_equal 'Togusa', pop_up.value
 

data/test/integration/accessibility/test_enumerators.rb

@@ -26,7 +26,7 @@ class TestAccessibilityEnumeratorsBreadthFirst < MiniTest::Unit::TestCase
     def enum.first
       each { |x| return x }
     end
-    assert_instance_of AX::StandardWindow, enum.first
+    refute_instance_of AX::Application, enum.first
   end
 
   # this was a big performance issue, so we should make sure it
@@ -119,4 +119,3 @@ class TestAccessibilityEnumeratorsDepthFirst < MiniTest::Unit::TestCase
   end
 
 end
-

data/test/integration/accessibility/test_qualifier.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require 'test/integration/helper'
 
 class TestAccessibilityQualifier < MiniTest::Unit::TestCase
@@ -99,7 +100,7 @@ class TestAccessibilityQualifier < MiniTest::Unit::TestCase
 
   def test_qualifiers_can_use_aliased_attributes
     id = "I'm a little teapot"
-    q = qualifier(:Button, id: id)
+    q  = qualifier(:Button, id: id)
     app.main_window.children.each do |kid|
       if kid.attributes.include?(:identifier) && kid.id == id
         assert q.qualifies? kid

data/test/integration/ax/test_element.rb

@@ -39,4 +39,8 @@ class TestAXElement < MiniTest::Unit::TestCase
     box.set :value, '' if box
   end
 
+  #  @todo test setting selected text
+  #  def test_setting
+  #  end
+
 end

data/test/sanity/accessibility/test_core.rb

@@ -220,7 +220,7 @@ class TestAccessibilityCore < MiniTest::Unit::TestCase
   ##
   # The keyboard simulation stuff is a bit weird...
 
-  def test_post_events_to
+  def test_post
     events = [[0x56,true], [0x56,false], [0x54,true], [0x54,false]]
     string = '42'
 

data/test/sanity/accessibility/test_translator.rb

@@ -12,49 +12,35 @@ class TestAccessibilityTranslator < MiniTest::Unit::TestCase
   end
 
   def test_unprefixing
-    def prefix_test before, after
-      assert_equal after, TRANSLATOR.unprefix(before)
-    end
-
-    prefix_test 'AXButton',               'Button'
-    prefix_test 'MCAXButton',             'Button'
-    prefix_test 'AXURL',                  'URL'
-    prefix_test 'AXTitleUIElement',       'TitleUIElement'
-    prefix_test 'AXIsApplicationRunning', 'ApplicationRunning'
-    prefix_test 'AXAX',                   'AX'
-    prefix_test 'Quick Look',             'QuickLook'
+    assert_equal 'Button',         TRANSLATOR.unprefix('AXButton')
+    assert_equal 'URL',            TRANSLATOR.unprefix('AXURL')
+    assert_equal 'TitleUIElement', TRANSLATOR.unprefix('AXTitleUIElement')
+    assert_equal 'AX',             TRANSLATOR.unprefix('AXAX')
+    assert_equal 'QuickLook',      TRANSLATOR.unprefix('Quick Look')
   end
 
-  def test_lookup
-    def lookup_test key, values, expected
-      assert_equal expected, TRANSLATOR.lookup(key, values)
-    end
-
-    lookup_test :children,         [KAXChildrenAttribute],       KAXChildrenAttribute
-    lookup_test :title_ui_element, [KAXTitleUIElementAttribute], KAXTitleUIElementAttribute
-    lookup_test :focused?,         [KAXFocusedAttribute],        KAXFocusedAttribute
-    lookup_test :flabbergast,      [],                           nil
-    lookup_test :totally_fake,     ['AXTotallyFake'],            'AXTotallyFake'
-  end
-
-  def test_lookup_aliases
-    def lookup_test key, values, expected
-      assert_equal expected, TRANSLATOR.lookup(key, values)
-    end
-
-    lookup_test :id,          [], KAXIdentifierAttribute
-    lookup_test :placeholder, [], KAXPlaceholderValueAttribute
+  def test_cocoaification
+    assert_equal KAXChildrenAttribute,       TRANSLATOR.cocoaify(:children)
+    assert_equal KAXTitleUIElementAttribute, TRANSLATOR.cocoaify(:title_ui_element)
+    assert_equal KAXFocusedAttribute,        TRANSLATOR.cocoaify(:focused?)
+    assert_equal 'AXTotallyFake',            TRANSLATOR.cocoaify(:totally_fake)
+
+    # also check the aliases we have added
+    assert_equal KAXIdentifierAttribute,       TRANSLATOR.cocoaify(:id)
+    assert_equal KAXPlaceholderValueAttribute, TRANSLATOR.cocoaify(:placeholder)
+
+    # cover this edge case :/
+    assert_equal KAXIsApplicationRunningAttribute, TRANSLATOR.cocoaify(:is_application_running?)
+    assert_equal KAXIsApplicationRunningAttribute, TRANSLATOR.cocoaify(:is_application_running)
+    assert_equal KAXIsApplicationRunningAttribute, TRANSLATOR.cocoaify(:application_running?)
+    assert_equal KAXIsApplicationRunningAttribute, TRANSLATOR.cocoaify(:application_running)
   end
 
   def test_rubyize
-    def rubyize_test given, expected
-      assert_equal Array(expected), TRANSLATOR.rubyize(Array(given))
-    end
-
-    rubyize_test KAXMainWindowAttribute,                      :main_window
-    rubyize_test KAXRoleAttribute,                            :role
-    rubyize_test KAXStringForRangeParameterizedAttribute,     :string_for_range
-    rubyize_test [KAXSubroleAttribute, KAXChildrenAttribute], [:subrole, :children]
+    assert_equal [:role],               TRANSLATOR.rubyize([KAXRoleAttribute])
+    assert_equal [:main_window],        TRANSLATOR.rubyize([KAXMainWindowAttribute])
+    assert_equal [:string_for_range],   TRANSLATOR.rubyize([KAXStringForRangeParameterizedAttribute])
+    assert_equal [:subrole, :children], TRANSLATOR.rubyize([KAXSubroleAttribute, KAXChildrenAttribute])
   end
 
   def test_rubyize_doesnt_eat_original_data
@@ -63,73 +49,63 @@ class TestAccessibilityTranslator < MiniTest::Unit::TestCase
     assert_equal [KAXTitleAttribute, KAXMainWindowAttribute], array
   end
 
-  def test_guess_notification_for
-    def notif_test actual, expected
-      assert_equal expected, TRANSLATOR.guess_notification_for(actual)
-    end
-
-    notif_test 'window_created',            KAXWindowCreatedNotification
-    notif_test :window_created,             KAXWindowCreatedNotification
-    notif_test KAXValueChangedNotification, KAXValueChangedNotification
-    notif_test 'Cheezburger',               'Cheezburger'
-  end
-
   def test_classify
-    def classify_test actual, expected
-      assert_equal expected, TRANSLATOR.classify(actual)
-    end
-
-    classify_test :buttons,          'Button'
-    classify_test :button,           'Button'
-    classify_test :menu_item,        'MenuItem'
-    classify_test 'floating_window', 'FloatingWindow'
-    classify_test 'outline_rows',    'OutlineRow'
+    assert_equal 'Button',         TRANSLATOR.classify(:buttons)
+    assert_equal 'Button',         TRANSLATOR.classify(:button)
+    assert_equal 'MenuItem',       TRANSLATOR.classify(:menu_item)
+    assert_equal 'FloatingWindow', TRANSLATOR.classify('floating_window')
+    assert_equal 'OutlineRow',     TRANSLATOR.classify('outline_rows')
   end
 
   def test_singularize
-    def singularize_test actual, expected
-      assert_equal expected, TRANSLATOR.singularize(actual)
-    end
-
-    singularize_test :buttons,     'button'
-    singularize_test :button,      'button'
-    singularize_test :windows,     'window'
-    singularize_test :check_boxes, 'check_box'
-    singularize_test 'classes',    'class'
+    assert_equal 'button',    TRANSLATOR.singularize(:buttons)
+    assert_equal 'button',    TRANSLATOR.singularize('button')
+    assert_equal 'window',    TRANSLATOR.singularize(:windows)
+    assert_equal 'check_box', TRANSLATOR.singularize(:check_boxes)
+    assert_equal 'class',     TRANSLATOR.singularize('classes')
   end
 
+  def test_guess_notification
+    assert_equal KAXWindowCreatedNotification, TRANSLATOR.guess_notification('window_created')
+    assert_equal KAXWindowCreatedNotification, TRANSLATOR.guess_notification(:window_created)
+    assert_equal KAXValueChangedNotification,  TRANSLATOR.guess_notification(KAXValueChangedNotification)
+    assert_equal 'Cheezburger',                TRANSLATOR.guess_notification('Cheezburger')
+  end
 
   def test_unprefixes_are_cached
     unprefixes = TRANSLATOR.instance_variable_get :@unprefixes
+
     unprefixed = unprefixes['AXPieIsTheTruth']
     assert_includes unprefixes.keys, 'AXPieIsTheTruth'
     assert_equal    unprefixed, unprefixes['AXPieIsTheTruth']
   end
 
-  def test_normalizations_are_cached
-    normalizations = TRANSLATOR.instance_variable_get :@normalizations
-    normalized     = normalizations['AXTheAnswer']
-    assert_includes normalizations.keys, 'AXTheAnswer'
-    assert_equal    normalized, normalizations['AXTheAnswer']
-  end
-
   def test_rubyisms_are_cached
     rubyisms = TRANSLATOR.instance_variable_get :@rubyisms
-               TRANSLATOR.instance_variable_set :@values, ['AXChocolatePancake']
-    rubyized = rubyisms[:chocolate_pancake]
-    assert_includes rubyisms.keys, :chocolate_pancake
-    assert_equal    rubyized, rubyisms[:chocolate_pancake]
-
-    rubyized = rubyisms[:chocolate_pancake?]
-    assert_includes rubyisms.keys, :chocolate_pancake?
-    assert_equal    rubyized, rubyisms[:chocolate_pancake]
-    assert_equal    rubyized, rubyisms[:chocolate_pancake?]
+
+    rubyized = rubyisms['AXTheAnswer']
+    assert_includes rubyisms.keys, 'AXTheAnswer'
+    assert_equal    rubyized,      rubyisms['AXTheAnswer']
+  end
+
+  def test_cocoaifications_are_cached
+    cocoas  = TRANSLATOR.instance_variable_get :@cocoaifications
+
+    cocoaed = cocoas[:chocolate_pancake]
+    assert_includes cocoas.keys, :chocolate_pancake
+    assert_equal    cocoaed,     cocoas[:chocolate_pancake]
+
+    cocoaed = cocoas[:chocolate_pancake?]
+    assert_includes cocoas.keys, :chocolate_pancake?
+    assert_equal    cocoaed,     cocoas[:chocolate_pancake?]
+    # make sure we didn't kill the other guy
+    assert_equal    cocoaed,     cocoas[:chocolate_pancake]
   end
 
   def test_classifications_are_cached
     classifications = TRANSLATOR.instance_variable_get :@classifications
 
-    classified      = TRANSLATOR.classify 'made_up_class_name'
+    classified = TRANSLATOR.classify 'made_up_class_name'
     assert_includes classifications.keys, 'made_up_class_name'
     assert_equal    classified, classifications['made_up_class_name']
   end
@@ -137,7 +113,7 @@ class TestAccessibilityTranslator < MiniTest::Unit::TestCase
   def test_singularizations_are_cached
     singulars = TRANSLATOR.instance_variable_get :@singularizations
 
-    singular  = TRANSLATOR.singularize 'buttons'
+    singular = TRANSLATOR.singularize 'buttons'
     assert_includes singulars.keys, 'buttons'
     assert_equal    singular, singulars['buttons']
   end

data/test/sanity/ax/test_application.rb

@@ -2,9 +2,6 @@
 require 'test/helper'
 require 'ax/application'
 
-class AX::Element
-  attr_reader :ref
-end
 
 class TestAXApplication < MiniTest::Unit::TestCase
 
@@ -17,15 +14,13 @@ class TestAXApplication < MiniTest::Unit::TestCase
       NSRunningApplication.runningApplicationWithProcessIdentifier app.pid
   end
 
-  def test_is_a_direct_subclass_of_element
+  def test_subclass_of_element
     assert_equal AX::Element, AX::Application.superclass
   end
 
-  def test_inspect_includes_pid
+  def test_inspect
+    assert_match app.inspect, /children/
     assert_match /\spid=\d+/, app.inspect
-  end
-
-  def test_inspect_includes_focused
     assert_match /\sfocused\[(?:✔|✘)\]/, app.inspect
   end
 
@@ -35,10 +30,9 @@ class TestAXApplication < MiniTest::Unit::TestCase
     mock.define_singleton_method(:terminate)   { got_called = true }
     mock.define_singleton_method(:terminated?) { false }
     app.instance_variable_set :@app, mock
+
     app.perform :terminate
     assert got_called
-  ensure
-    app.instance_variable_set :@app, running_app
   end
 
   def test_force_terminate
@@ -50,37 +44,44 @@ class TestAXApplication < MiniTest::Unit::TestCase
 
     app.perform :force_terminate
     assert got_called
-  ensure
-    app.instance_variable_set :@app, running_app
   end
 
-  def test_overrides_call_super
-    assert_match app.inspect, /children/
+  def test_writable_handles_focused_and_hidden
+    assert app.writable? :focused?
+    assert app.writable? :focused
+    assert app.writable? :hidden
+    assert app.writable? :hidden?
+  end
+
+  def test_attribute_calls_super
     assert_equal 'AXElementsTester', app.title
+  end
 
+  def test_set_calls_super
     called_super = false
-    app.define_singleton_method :perform do |name|
-      called_super = true if name == :some_action
+    app.define_singleton_method :set do |attr, value|
+      called_super = true if attr == :thingy && value == 'pie'
     end
-    app.perform :some_action
+    app.set :thingy, 'pie'
     assert called_super
+  end
 
+  def test_writable_calls_super
     called_super = false
-    app.define_singleton_method :set do |attr, value|
-      called_super = true if attr == :thingy && value == 'pie'
+    app.define_singleton_method :writable? do |attr|
+      called_super = true if attr == :brain
     end
-    app.set :thingy, 'pie'
+    app.writable? :brain
     assert called_super
   end
 
-  def test_type_string_forwards_events
-    skip "This strangely causes other tests to fail occassionally"
-    got_callback = false
-    app.ref.define_singleton_method :post do |events|
-      got_callback = true if events.kind_of?(Array)
+  def test_perform_calls_super
+    called_super = false
+    app.define_singleton_method :perform do |name|
+      called_super = true if name == :some_action
     end
-    app.type_string 'test'
-    assert got_callback
+    app.perform :some_action
+    assert called_super
   end
 
   def test_bundle_identifier

data/test/sanity/ax/test_systemwide.rb

@@ -11,21 +11,17 @@ class TestAXSystemWide < MiniTest::Unit::TestCase
     @system_wide ||= AX::SystemWide.new
   end
 
+  # this is more so I know if Apple ever changes how CFEqual() works on AX stuff
   def test_is_effectively_a_singleton
     assert_equal AX::SystemWide.new, AX::SystemWide.new
   end
 
-  def test_type_string_forwards_events
-    system  = system_wide.ref
-    meth    = system.method :post
-    got_callback = false
-    system.define_singleton_method :post do |events|
-      got_callback = true if events.kind_of?(Array)
-    end
-    system_wide.type_string 'test'
-    assert got_callback
-  ensure
-    system.define_singleton_method :post, meth if meth
+  def test_type_forwards_events
+    ref         = system_wide.ref
+    called_back = false
+    ref.define_singleton_method(:post) { |x| called_back = true if x.kind_of? Array }
+    assert system_wide.type 'test'
+    assert called_back
   end
 
   def test_search_not_allowed
@@ -36,13 +32,8 @@ class TestAXSystemWide < MiniTest::Unit::TestCase
     assert_raises(NoMethodError) { system_wide.on_notification }
   end
 
-  def test_element_at
-    system = system_wide.ref
-    [[10,10],[500,500]].each do |point|
-      expected = system.element_at(point)
-      actual   = system_wide.element_at(point).ref
-      assert_equal expected, actual
-    end
+  def test_element_at # returns a wrapped dude
+    assert_kind_of AX::Element, system_wide.element_at([10,10])
   end
 
   def test_parameterized_attributes_is_empty

metadata

@@ -2,14 +2,14 @@
 name: AXElements
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 0.7.6
+  version: 0.7.7
 platform: ruby
 authors:
 - Mark Rada
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-06 00:00:00 Z
+date: 2012-04-07 00:00:00 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -59,12 +59,11 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: "1.17"
-description: 'AXElements is a DSL abstraction on top of the Mac OS X Accessibility
-  Framework
+description: 'AXElements is a UI automation DSL built on top of the Mac OS X Accessibility
 
-  that allows code to be written in a very natural and declarative style that
+  Framework that allows code to be written in a very natural and declarative
 
-  describes user interactions.
+  style that describes user interactions.
 
 '
 email: mrada@marketcircle.com
@@ -76,7 +75,6 @@ extra_rdoc_files:
 - docs/Acting.markdown
 - docs/Debugging.markdown
 - docs/images/all_the_buttons.jpg
-- docs/images/AX.png
 - docs/images/next_version.png
 - docs/images/ui_hierarchy.dot
 - docs/images/ui_hierarchy.png
@@ -165,7 +163,6 @@ files:
 - docs/Acting.markdown
 - docs/Debugging.markdown
 - docs/images/all_the_buttons.jpg
-- docs/images/AX.png
 - docs/images/next_version.png
 - docs/images/ui_hierarchy.dot
 - docs/images/ui_hierarchy.png