AXElements 0.9.0 → 1.0.0.alpha

data/lib/ax/scroll_area.rb

@@ -22,13 +22,12 @@ class AX::ScrollArea < AX::Element
   def scroll_to element
     return if NSContainsRect(self.bounds, element.bounds)
     Mouse.move_to self.to_point
-
-    # calculate direction and velocity for scrolling
+    # calculate direction to scroll
     direction = element.position.y > self.position.y ? -5 : 5
-
-    Mouse.scroll direction until NSContainsRect(self.bounds, element.bounds)
-
-    spin 0.1
+    until NSContainsRect(self.bounds, element.bounds)
+      Mouse.scroll direction
+    end
+    sleep 0.1
   end
 
 end

data/lib/ax/systemwide.rb

@@ -11,37 +11,10 @@ require 'accessibility/string'
 class AX::SystemWide < AX::Element
   include Accessibility::String
 
-  class << self
-    ##
-    # Find and return the group that represents the desktop
-    #
-    # @return [AX::Group]
-    def desktop
-      AX::Application.finder.scroll_areas.first.groups.first
-    end
-
-    ##
-    # @note This currently does not include spotlight or the
-    #       notification center as they interact oddly with
-    #       accessibility APIs and how AXElements handle errors
-    #
-    # Find and return menu bar items for the system
-    #
-    # That is, menu bar items that do not belong to the current
-    # app, but that belong to the system, such as the clock or
-    # wi-fi menu.
-    #
-    # @return [AX::MenuBarItem]
-    def status_items
-      AX::Application.new('SystemUIServer').menu_bar.children
-    end
-  end
-
-
   ##
   # Overridden since there is only one way to get the element ref.
   def initialize
-    super Accessibility::Element.system_wide
+    super AXUIElementCreateSystemWide()
   end
 
   ##
@@ -123,9 +96,4 @@ class AX::SystemWide < AX::Element
     @ref.set_timeout_to seconds
   end
 
-  # (see AX::Application.frontmost_application)
-  def focused_application
-    AX::Application.frontmost_app
-  end
-
 end

data/lib/ax_elements.rb

@@ -1,20 +1,12 @@
-require 'ax_elements/active_support_selections'
-require 'accessibility/bridge'
-require 'ax_elements/mri' unless on_macruby?
-
 # Mix the language methods into the TopLevel
 require 'accessibility/dsl'
 include Accessibility::DSL
 
-require 'accessibility/system_info'
-
 ##
-# @deprecated Please use {AX::Application.dock} instead
-#
 # The Mac OS X dock application.
 #
 # @return [AX::Application]
-AX::DOCK = AX::Application.dock
+AX::DOCK = AX::Application.new('com.apple.dock')
 
 # Load explicitly defined elements that are optional
 require 'ax/button'

data/lib/ax_elements/core_graphics_workaround.rb

@@ -0,0 +1,5 @@
+MOUNTAIN_LION_APPKIT_VERSION = 1187
+if NSAppKitVersionNumber >= MOUNTAIN_LION_APPKIT_VERSION
+    framework '/System/Library/Frameworks/CoreGraphics.framework'
+end
+

data/lib/ax_elements/nsarray_compat.rb

@@ -1,6 +1,5 @@
 require 'ax/element'
 require 'accessibility/translator'
-require 'active_support/core_ext/array/access'
 
 ##
 # An old hack on arrays that allows you to map a single method across
@@ -12,6 +11,18 @@ require 'active_support/core_ext/array/access'
 # on this and so I will just keep it around for backwards compatability.
 module Accessibility::NSArrayCompat
 
+  ##
+  # Equivalent to `#at(1)`
+  def second
+    at(1)
+  end
+
+  ##
+  # Equivalent to `#at(2)`
+  def third
+    at(2)
+  end
+
   ##
   # @note Debatably bad idea. Maintained for backwards compatibility.
   #
@@ -29,11 +40,11 @@ module Accessibility::NSArrayCompat
   #   outline.rows.text_fields.values # all at once
   #
   def method_missing method, *args
-    smethod = TRANSLATOR.singularize(method.to_s.chomp('?'))
+    smethod = TRANSLATOR.singularize(method.chomp('?'))
     map do |x|
-      if    !x.kind_of?(AX::Element) then super
-      elsif  x.respond_to? method    then x.send method,  *args
-      else                                x.send smethod, *args
+      if    !x.kind_of? AX::Element then super
+      elsif  x.respond_to? method   then x.send method,  *args
+      else                               x.send smethod, *args
       end
     end
   end
@@ -47,99 +58,8 @@ module Accessibility::NSArrayCompat
 
 end
 
-unless defined? NSArray
-  NSArray = Array
-end
 
-##
-# AXElements extensions for `NSArray`
+# AXElements extensions for `NSArray`.
 class NSArray
   include Accessibility::NSArrayCompat
-
-  if on_macruby?
-
-    ##
-    # Returns the tail of the array from `position`
-    #
-    # @example
-    #
-    #   [1, 2, 3, 4].from(0)   # => [1, 2, 3, 4]
-    #   [1, 2, 3, 4].from(2)   # => [3, 4]
-    #   [1, 2, 3, 4].from(10)  # => []
-    #   [].from(0)             # => []
-    #
-    # @param position [Fixnum]
-    # @return [Array]
-    def from position
-      self[position, length] || []
-    end
-
-    ##
-    # Returns the beginning of the array up to `position`
-    #
-    #   [1, 2, 3, 4].to(0)   # => [1]
-    #   [1, 2, 3, 4].to(2)   # => [1, 2, 3]
-    #   [1, 2, 3, 4].to(10)  # => [1, 2, 3, 4]
-    #   [].to(0)             # => []
-    #
-    # @param count [Fixnum]
-    # @return [Array]
-    def to count
-      take count + 1
-    end
-
-    ##
-    # Equal to `self[1]`
-    def second
-      self[1]
-    end
-
-    ##
-    # Equal to `self[2]`
-    def third
-      self[2]
-    end
-
-    ##
-    # Equal to `self[3]`
-    def fourth
-      self[3]
-    end
-
-    ##
-    # Equal to `self[4]`
-    def fifth
-      self[4]
-    end
-
-    ##
-    # Equal to `self[41]`
-    #
-    # Also known as accessing "the reddit".
-    def forty_two
-      self[41]
-    end
-
-  else
-
-    ##
-    # Create a new array with the same contents as the given array
-    #
-    # @param ary [Array]
-    def self.arrayWithArray ary
-      ary.dup
-    end
-
-    ##
-    # Create and return a new empty array
-    #
-    # @return [Array]
-    def self.array
-      []
-    end
-
-  end
-
-  alias_method :the_reddit, :forty_two
-
 end

data/lib/ax_elements/vendor/inflection_data.rb

@@ -0,0 +1,66 @@
+module Accessibility
+  Inflector.inflections do |inflect|
+    inflect.plural(/$/, 's')
+    inflect.plural(/s$/i, 's')
+    inflect.plural(/(ax|test)is$/i, '\1es')
+    inflect.plural(/(octop|vir)us$/i, '\1i')
+    inflect.plural(/(octop|vir)i$/i, '\1i')
+    inflect.plural(/(alias|status)$/i, '\1es')
+    inflect.plural(/(bu)s$/i, '\1ses')
+    inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+    inflect.plural(/([ti])um$/i, '\1a')
+    inflect.plural(/([ti])a$/i, '\1a')
+    inflect.plural(/sis$/i, 'ses')
+    inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+    inflect.plural(/(hive)$/i, '\1s')
+    inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+    inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+    inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+    inflect.plural(/(m|l)ouse$/i, '\1ice')
+    inflect.plural(/(m|l)ice$/i, '\1ice')
+    inflect.plural(/^(ox)$/i, '\1en')
+    inflect.plural(/^(oxen)$/i, '\1')
+    inflect.plural(/(quiz)$/i, '\1zes')
+
+    inflect.singular(/s$/i, '')
+    inflect.singular(/(n)ews$/i, '\1ews')
+    inflect.singular(/([ti])a$/i, '\1um')
+    inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
+    inflect.singular(/(^analy)ses$/i, '\1sis')
+    inflect.singular(/([^f])ves$/i, '\1fe')
+    inflect.singular(/(hive)s$/i, '\1')
+    inflect.singular(/(tive)s$/i, '\1')
+    inflect.singular(/([lr])ves$/i, '\1f')
+    inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+    inflect.singular(/(s)eries$/i, '\1eries')
+    inflect.singular(/(m)ovies$/i, '\1ovie')
+    inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+    inflect.singular(/(m|l)ice$/i, '\1ouse')
+    inflect.singular(/(bus)es$/i, '\1')
+    inflect.singular(/(o)es$/i, '\1')
+    inflect.singular(/(shoe)s$/i, '\1')
+    inflect.singular(/(cris|ax|test)es$/i, '\1is')
+    inflect.singular(/(octop|vir)i$/i, '\1us')
+    inflect.singular(/(alias|status)es$/i, '\1')
+    inflect.singular(/^(ox)en/i, '\1')
+    inflect.singular(/(vert|ind)ices$/i, '\1ex')
+    inflect.singular(/(matr)ices$/i, '\1ix')
+    inflect.singular(/(quiz)zes$/i, '\1')
+    inflect.singular(/(database)s$/i, '\1')
+
+    inflect.irregular('person', 'people')
+    inflect.irregular('man', 'men')
+    inflect.irregular('child', 'children')
+    inflect.irregular('sex', 'sexes')
+    inflect.irregular('move', 'moves')
+    inflect.irregular('cow', 'kine')
+    inflect.irregular('zombie', 'zombies')
+
+    inflect.uncountable(%w(equipment information rice money species series fish sheep jeans))
+
+    # Related to accessibility
+    inflect.acronym('UI')
+    inflect.acronym('RTF')
+    inflect.acronym('URL')
+  end
+end

data/lib/ax_elements/vendor/inflections.rb

@@ -0,0 +1,176 @@
+module Accessibility
+  module Inflector
+    # A singleton instance of this class is yielded by Inflector.inflections, which can then be used to specify additional
+    # inflection rules. Examples:
+    #
+    #   ActiveSupport::Inflector.inflections do |inflect|
+    #     inflect.plural /^(ox)$/i, '\1\2en'
+    #     inflect.singular /^(ox)en/i, '\1'
+    #
+    #     inflect.irregular 'octopus', 'octopi'
+    #
+    #     inflect.uncountable "equipment"
+    #   end
+    #
+    # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
+    # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
+    # already have been loaded.
+    class Inflections
+      ##
+      # Singleton instance of the inflections database.
+      #
+      # @return [Accessibility::Inflector::Inflections]
+      def self.instance
+        @__instance__ ||= new
+      end
+
+      attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms, :acronym_regex
+
+      def initialize
+        @plurals, @singulars, @uncountables, @humans, @acronyms, @acronym_regex = [], [], [], [], {}, /(?=a)b/
+      end
+
+      # Specifies a new acronym. An acronym must be specified as it will appear in a camelized string.  An underscore
+      # string that contains the acronym will retain the acronym when passed to `camelize`, `humanize`, or `titleize`.
+      # A camelized string that contains the acronym will maintain the acronym when titleized or humanized, and will
+      # convert the acronym into a non-delimited single lowercase word when passed to +underscore+.
+      #
+      # Examples:
+      #   acronym 'HTML'
+      #   titleize 'html' #=> 'HTML'
+      #   camelize 'html' #=> 'HTML'
+      #   underscore 'MyHTML' #=> 'my_html'
+      #
+      # The acronym, however, must occur as a delimited unit and not be part of another word for conversions to recognize it:
+      #
+      #   acronym 'HTTP'
+      #   camelize 'my_http_delimited' #=> 'MyHTTPDelimited'
+      #   camelize 'https' #=> 'Https', not 'HTTPs'
+      #   underscore 'HTTPS' #=> 'http_s', not 'https'
+      #
+      #   acronym 'HTTPS'
+      #   camelize 'https' #=> 'HTTPS'
+      #   underscore 'HTTPS' #=> 'https'
+      #
+      # Note: Acronyms that are passed to `pluralize` will no longer be recognized, since the acronym will not occur as
+      # a delimited unit in the pluralized result. To work around this, you must specify the pluralized form as an
+      # acronym as well:
+      #
+      #    acronym 'API'
+      #    camelize(pluralize('api')) #=> 'Apis'
+      #
+      #    acronym 'APIs'
+      #    camelize(pluralize('api')) #=> 'APIs'
+      #
+      # `acronym` may be used to specify any word that contains an acronym or otherwise needs to maintain a non-standard
+      # capitalization. The only restriction is that the word must begin with a capital letter.
+      #
+      # Examples:
+      #   acronym 'RESTful'
+      #   underscore 'RESTful' #=> 'restful'
+      #   underscore 'RESTfulController' #=> 'restful_controller'
+      #   titleize 'RESTfulController' #=> 'RESTful Controller'
+      #   camelize 'restful' #=> 'RESTful'
+      #   camelize 'restful_controller' #=> 'RESTfulController'
+      #
+      #   acronym 'McDonald'
+      #   underscore 'McDonald' #=> 'mcdonald'
+      #   camelize 'mcdonald' #=> 'McDonald'
+      def acronym(word)
+        @acronyms[word.downcase] = word
+        @acronym_regex = /#{@acronyms.values.join("|")}/
+      end
+
+      # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
+      # The replacement should always be a string that may include references to the matched data from the rule.
+      def plural(rule, replacement)
+        @uncountables.delete(rule) if rule.is_a?(String)
+        @uncountables.delete(replacement)
+        @plurals.insert(0, [rule, replacement])
+      end
+
+      # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
+      # The replacement should always be a string that may include references to the matched data from the rule.
+      def singular(rule, replacement)
+        @uncountables.delete(rule) if rule.is_a?(String)
+        @uncountables.delete(replacement)
+        @singulars.insert(0, [rule, replacement])
+      end
+
+      # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
+      # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+      #
+      # Examples:
+      #   irregular 'octopus', 'octopi'
+      #   irregular 'person', 'people'
+      def irregular(singular, plural)
+        @uncountables.delete(singular)
+        @uncountables.delete(plural)
+        if singular[0,1].upcase == plural[0,1].upcase
+          plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+          plural(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + plural[1..-1])
+          singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+        else
+          plural(Regexp.new("#{singular[0,1].upcase}(?i)#{singular[1..-1]}$"), plural[0,1].upcase + plural[1..-1])
+          plural(Regexp.new("#{singular[0,1].downcase}(?i)#{singular[1..-1]}$"), plural[0,1].downcase + plural[1..-1])
+          plural(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), plural[0,1].upcase + plural[1..-1])
+          plural(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), plural[0,1].downcase + plural[1..-1])
+          singular(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), singular[0,1].upcase + singular[1..-1])
+          singular(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), singular[0,1].downcase + singular[1..-1])
+        end
+      end
+
+      # Add uncountable words that shouldn't be attempted inflected.
+      #
+      # Examples:
+      #   uncountable "money"
+      #   uncountable "money", "information"
+      #   uncountable %w( money information rice )
+      def uncountable(*words)
+        (@uncountables << words).flatten!
+      end
+
+      # Specifies a humanized form of a string by a regular expression rule or by a string mapping.
+      # When using a regular expression based replacement, the normal humanize formatting is called after the replacement.
+      # When a string is used, the human form should be specified as desired (example: 'The name', not 'the_name')
+      #
+      # Examples:
+      #   human /_cnt$/i, '\1_count'
+      #   human "legacy_col_person_name", "Name"
+      def human(rule, replacement)
+        @humans.insert(0, [rule, replacement])
+      end
+
+      # Clears the loaded inflections within a given scope (default is <tt>:all</tt>).
+      # Give the scope as a symbol of the inflection type, the options are: <tt>:plurals</tt>,
+      # <tt>:singulars</tt>, <tt>:uncountables</tt>, <tt>:humans</tt>.
+      #
+      # Examples:
+      #   clear :all
+      #   clear :plurals
+      def clear(scope = :all)
+        case scope
+          when :all
+            @plurals, @singulars, @uncountables, @humans = [], [], [], []
+          else
+            instance_variable_set "@#{scope}", []
+        end
+      end
+    end
+
+    # Yields a singleton instance of Inflector::Inflections so you can specify additional
+    # inflector rules.
+    #
+    # Example:
+    #   ActiveSupport::Inflector.inflections do |inflect|
+    #     inflect.uncountable "rails"
+    #   end
+    def inflections
+      if block_given?
+        yield Inflections.instance
+      else
+        Inflections.instance
+      end
+    end
+  end
+end