bewildr 0.1.8 → 0.1.9

data/Rakefile

@@ -10,7 +10,7 @@ require 'cucumber/rake/task'
 
 spec = Gem::Specification.new do |s|
   s.name = 'bewildr'
-  s.version = '0.1.8'
+  s.version = '0.1.9'
   s.has_rdoc = true
   s.extra_rdoc_files = ['README.rdoc', 'LICENSE']
   s.summary = 'Test WPF UI apps with IronRuby'
@@ -21,6 +21,7 @@ spec = Gem::Specification.new do |s|
   s.files = %w(LICENSE README.rdoc Rakefile) + Dir.glob("{bin,lib}/**/*")
   s.require_path = "lib"
   s.bindir = "bin"
+  s.add_dependency('activesupport', '>= 3.0.0')
 end
 
 Rake::GemPackageTask.new(spec) do |p|

data/lib/bewildr.rb

@@ -11,6 +11,7 @@ load_assembly 'UIAutomationClient, Version=3.0.0.0, Culture=neutral, PublicKeyTo
 load_assembly 'UIAutomationTypes, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35'
 load_assembly 'System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'
 load_assembly 'System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'
+load_assembly 'WindowsBase, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35'
 
 #require BewildrClickr - stopgap until the ffi gem works under ironruby
 require File.join(File.expand_path(File.dirname(__FILE__)), "bewildr", "ext", "BewildrClickr.dll")
@@ -18,6 +19,8 @@ CLICKR = Bewildr::Clickr::Clickr.new
 
 #load plain old ruby libraries
 require 'timeout'
+require 'singleton'
+require 'active_support/core_ext/string/inflections'
 
 #require ruby extensions
 require 'bewildr/ext/extensions'
@@ -30,6 +33,7 @@ require 'bewildr/finder'
 require 'bewildr/application'
 require 'bewildr/windows'
 require 'bewildr/element'
+require 'bewildr/mouse'
 
 require 'bewildr/control_patterns/window_pattern'
 require 'bewildr/control_patterns/value_pattern'

data/lib/bewildr/application.rb

@@ -1,35 +1,52 @@
 #Copyright (c) 2010, Nathaniel Ritmeyer. All rights reserved.
 
 module Bewildr
+  #Wraps System::Diagnostics::Process object and provides class methods to interrogate currently running
+  #processes, attach to processes or start new ones
   class Application
+    #Returns a new instance of Bewildr::Application that wraps the process passed as the argument
     def initialize(proc)
       @proc = proc
       @proc.wait_for_input_idle(10)
-      @proc_id = proc.id
     end
     private :initialize
 
+    #Returns the id of the underlying process
+    def proc_id
+      running? ? @proc.id.to_i : nil
+    end
+
+    #Return the name of the underlying process
+    def name
+      running? ? @proc.process_name.to_s : nil
+    end
+
+    #kills this process. Uses taskkill to perform the butchery
     def kill
-      `taskkill /f /t /pid #{@proc_id}`
+      `taskkill /f /t /pid #{proc_id}`
       Timeout::timeout(5) do
         sleep 0.1 while running?
       end
     end
 
+    #Returns true if this process is running, false if it isn't
     def running?
       @proc.nil? ? false : !@proc.has_exited
     end
 
+    #Waits for up to 30 seconds for the process to terminate
     def wait_for_termination
       Timeout::timeout(30) do
         sleep 0.2 while running?
       end
     end
 
+    #Returns a list of windows associated with this application
     def windows
-      Bewildr::Windows.windows_by_process_id(@proc_id)
+      Bewildr::Windows.windows_by_process_id(proc_id)
     end
 
+    #Returns a window whose title matches the string or regex passed in as the argument
     def window_by_name(input)
       case input
       when String then return windows.select{|window| window.name.strip == input.strip}.first
@@ -40,6 +57,9 @@ module Bewildr
     end
     alias :window :window_by_name
 
+    #Waits for up to 30 seconds for a window belonging to this application to appear. When it does, a
+    #Bewildr::Element representing the window is returned. This method allows you in one line to wait
+    #for a window to appear and also return it
     def wait_for_window(input, wait_time = 30)
       begin
         Timeout::timeout(wait_time) do
@@ -57,12 +77,15 @@ module Bewildr
       end
     end
 
-    #takes name or full path of exe to start
+    #Returns a new instance of Bewildr::Application wrapping the process created when the specified exe file is invoked.
+    #  Application.start("notepad.exe")
+    #  Application.start("c:\some\path\my_app.exe")
     def self.start(process_name)
       raise "Can't find: #{process_name}" unless File.exist?(process_name)
       Bewildr::Application.new(System::Diagnostics::Process.start(process_name))
     end
 
+    #Same as the start method but allows the passing of arguments
     def self.start_with_settings(path_to_exe, settings_hash)
       start_info = System::Diagnostics::ProcessStartInfo.new(path_to_exe)
       unless settings_hash[:args].nil? and settings_hash[:args].size > 0
@@ -71,14 +94,18 @@ module Bewildr
       Bewildr::Application.new(System::Diagnostics::Process.start(start_info))
     end
 
+    #Returns a Bewildr::Application wrapping a process already in memory where the argument is the process name
     def self.attach_to_process_name(process_name)
       Bewildr::Application.new(System::Diagnostics::Process.get_processes_by_name(process_name).first)
     end
 
+    #Returns a Bewildr::Application wrapping a process already in memory where the argument is the process object to be wrapped
     def self.attach_to_process(process)
       Bewildr::Application.new(process)
     end
 
+    #Given an exe name/path this method will return a new Bewildr::Application based either on a process already in memory
+    #or the process started by executing the app at the path specified in the argument
     def self.attach_or_launch(path_to_exe)
       #if app is already open attach to it
       potential_process_name = File.basename(path_to_exe, ".exe")
@@ -91,12 +118,15 @@ module Bewildr
       end
     end
 
+    #Starts the app specified in the first argument and then waits and returns the window that matches the
+    #string or regex passed as the second argument
     def self.start_app_and_wait_for_window(path, window_name)
       app = Bewildr::Application.start(path)
       window = app.wait_for_window(window_name)
       return app, window
     end
 
+    #Kills all processes that match the name passed as an argument
     def self.kill_all_processes_with_name(input)
       System::Diagnostics::Process.get_processes_by_name(input).each do |p|
         p.kill
@@ -104,10 +134,14 @@ module Bewildr
       end
     end
 
+    #Returns an array of Bewildr::Application instances wrapping processes whose name match the string
+    #passed as an argument
     def self.processes_with_name(input)
       System::Diagnostics::Process.get_processes_by_name(input).collect {|p| Bewildr::Application.attach_to_process(p) }
     end
 
+    #Waits for and eventually returns a Bewildr::Application wrapping the process whose name matches
+    #the string passed as an argument
     def self.wait_for_process_with_name(input)
       Timeout.timeout(30) {sleep 0.1 until System::Diagnostics::Process.get_processes_by_name(input).size > 0}
       self.attach_to_process_name(input)

data/lib/bewildr/control_patterns/toggle_pattern.rb

@@ -32,8 +32,12 @@ module Bewildr
               state
             end
           when :button
-            def toggle(value)
-              set_state_to(value)
+            def toggle_on
+               set_state_to(:on)
+            end
+
+            def toggle_off
+               set_state_to(:off)
             end
 
             def toggle_state

data/lib/bewildr/control_type_additions/combo_box_additions.rb

@@ -49,7 +49,7 @@ module Bewildr
             raise "Index must be 0 or greater" if input < 0
             begin
               expand_combo
-              my_item = list_items[input].select
+              list_items[input].select
             ensure
               collapse_combo
             end

data/lib/bewildr/control_type_additions/list_additions.rb

@@ -43,10 +43,11 @@ module Bewildr
 
           def select_by_index(input)
             raise "Index must be 0 or greater" if input < 0
-            my_item = list_items[input].select
+            list_items[input].select
           end
 
           def selected
+            return nil if get_selection.empty?
             get_selection.first.name
           end
         end

data/lib/bewildr/control_type_additions/scroll_additions.rb

@@ -23,7 +23,7 @@ module Bewildr
           end
 
           def page_down_to_bottom_of_scroll_bar
-            scroll_down_one_page while vertical_scroll_percent < 100.0
+            scroll_down_one_page while vertical_scroll_percent < 99.99
           end
         end
       end

data/lib/bewildr/element.rb

@@ -1,10 +1,14 @@
 #Copyright (c) 2010, Nathaniel Ritmeyer. All rights reserved.
 
 module Bewildr
+  #All MS UI Automation elements accessed using bewildr are represented as instances of Bewildr::Element.
   class Element
     attr_reader :automation_element
     attr_reader :control_type
     
+    #Returns a new instance of Bewildr::Element wrapping the MS UI Automation Element passed in as an
+    #argument. You probably won't be calling this method directly - if you are then you probably know
+    #what your'e doing
     def initialize(input)
       @automation_element = input
       case input
@@ -17,16 +21,19 @@ module Bewildr
       end
     end
 
+    #Returns the underlying automation element's name property
     def name
       existence_check
       @automation_element.current.name.to_s
     end
 
+    #Returns the underlying automation element's automation id property
     def automation_id
       existence_check
       @automation_element.current.automation_id.to_s
     end
 
+    #Returns true if the element exists, false if it doesn't
     def exists?
       return false if @control_type == :non_existent
       begin
@@ -38,21 +45,26 @@ module Bewildr
     end
     alias :exist? :exists?
 
+    #Returns true if the element is visible, false if it isn't
     def visible?
       existence_check
       !@automation_element.current.is_offscreen
     end
 
+    #Returns true if this element has a descendant that meets the search criteria, false if it doesn't
+    #Takes a condition hash
     def contains?(condition_hash)
       get(condition_hash).exists?
     end
     alias :contain? :contains?
 
+    #Returns true if the underlying automation element is enabled, false if it's not
     def enabled?
       existence_check
       @automation_element.current.is_enabled
     end
 
+    #Waits up to 30 seconds for a descendant of this element to exist that meets the search criteria
     def wait_for_existence_of(condition_hash)
       Timeout.timeout(30) do
         sleep 0.1 until contains?(condition_hash)
@@ -60,26 +72,31 @@ module Bewildr
       get(condition_hash)
     end
 
+    #Waits for up to 30 seconds for this element to no longer have a descendant element that meest the criteria
     def wait_for_non_existence_of(condition_hash)
       Timeout.timeout(30) do
         sleep 0.1 unless contains?(condition_hash)
       end
     end
 
+    #Gives this element focus
     def focus
       @automation_element.set_focus
     end
 
+    #Returns true if this element is scrollable, false if it isn't.
     def scrollable?
       return false unless @automation_element.get_supported_patterns.collect {|pattern| pattern.programmatic_name.to_s }.include?("ScrollPatternIdentifiers.Pattern")
       vertically_scrollable
     end
 
-    #:id => "id"
-    #:name => "bob"
-    #:type => :button
-    #:scope => :children / :descendants
-    #:how_many => :first / :all
+    #Returns the result of searching this element's children or descendants for the first or all matches of
+    #a particular id, name or type (or combination!). See Bewildr::Finder for more details
+    #  :id => "id"
+    #  :name => "bob"
+    #  :type => :button
+    #  :scope => :children / :descendants
+    #  :how_many => :first / :all
     def get(condition_hash)
       existence_check
       condition = Finder.condition_for(condition_hash)
@@ -99,12 +116,12 @@ module Bewildr
       end
     end
 
-    #add "children/child" and "descendants/descendant" methods
-
+    #Returns true if this element is the root element of the UI element tree
     def root?
       @automation_element == System::Windows::Automation::AutomationElement.root_element
     end
 
+    #Returns a new element representing this element's parent in the UI element tree
     def parent
       return nil if root?
       walker = System::Windows::Automation::TreeWalker.RawViewWalker
@@ -112,11 +129,13 @@ module Bewildr
       Bewildr::Element.new(potential_parent)
     end
 
+    #Returns true if this element has descendants, false if it doesn't
     def has_children?
       walker = System::Windows::Automation::TreeWalker.RawViewWalker
       !walker.get_first_child(@automation_element).nil?
     end
 
+    #Returns an array containing this element's (direct) children
     def children
       return [] unless has_children?
       walker = System::Windows::Automation::TreeWalker.ControlViewWalker #RawViewWalker
@@ -129,24 +148,22 @@ module Bewildr
       bewildred_children
     end
 
+    #Clicks this element - this is done by actual mouse moves and clicks. The automation element's underlying InvokePattern is not used.
     def click
-      CLICKR.click(clickable_point)
+      Bewildr::Mouse.click(clickable_point)
     end
 
+    #Double clicks this element - this is done by actual mouse moves and clicks. The automation element's underlying InvokePattern is not used.
     def double_click
-      CLICKR.double_click(clickable_point)
+      Bewildr::Mouse.double_click(clickable_point)
     end
 
+    #Right clicks this element - this is done by actual mouse moves and clicks. The automation element's underlying InvokePattern is not used.
     def right_click
-      CLICKR.right_click(clickable_point)
-    end
-
-    private
-
-    def existence_check
-      raise Bewildr::ElementDoesntExist unless exists?
+      Bewildr::Mouse.right_click(clickable_point)
     end
 
+    #Returns the underlying automation element's clickable point property - this is used by the various click methods
     def clickable_point
       existence_check
       Timeout.timeout(30) do
@@ -160,14 +177,24 @@ module Bewildr
       end
     end
 
+    private
+
+    #Raises an exception if this element no longer exists
+    def existence_check
+      raise Bewildr::ElementDoesntExist unless exists?
+    end
+
+    #Used to add scrollability to an element if it becomes scrollable subsequent to its initial discovery
     def prepare_element
       load_all_items_hack if scrollable?
     end
 
+    #Figures out this element's control type
     def set_control_type
       @control_type = Bewildr::ControlType.symbol_for_enum(@automation_element.current.control_type)
     end
 
+    #Mixes in bewildr control patterns dynamically based on what patterns the underlying automation element has
     def build_element
       @automation_element.get_supported_patterns.each do |pattern|
         pattern_name = pattern.programmatic_name.to_s.gsub(/Identifiers\.Pattern/, "")
@@ -176,22 +203,15 @@ module Bewildr
       end
     end
 
+    #Adds control type addition modules to this element based on the underlying automation element's control type.
     #list of control types comes from http://msdn.microsoft.com/en-us/library/ms750574.aspx
     def include_additions
-      case @control_type
-      when :combo_box then extend Bewildr::ControlTypeAdditions::ComboBoxAdditions
-      when :data_grid then extend Bewildr::ControlTypeAdditions::DataGridAdditions
-      when :document  then extend Bewildr::ControlTypeAdditions::DocumentAdditions
-      when :hyperlink then extend Bewildr::ControlTypeAdditions::TextAdditions
-      when :list      then extend Bewildr::ControlTypeAdditions::ListAdditions
-      when :menu      then extend Bewildr::ControlTypeAdditions::MenuAdditions
-      when :menu_item then extend Bewildr::ControlTypeAdditions::MenuItemAdditions
-      when :tab       then extend Bewildr::ControlTypeAdditions::TabAdditions
-      when :text      then extend Bewildr::ControlTypeAdditions::TextAdditions
-      when :tree      then extend Bewildr::ControlTypeAdditions::TreeAdditions
-      when :tree_item then extend Bewildr::ControlTypeAdditions::TreeItemAdditions
-      when :window    then extend Bewildr::ControlTypeAdditions::WindowAdditions
-      end 
+      #the following looks like could have performance issues, but the tests don't take any longer to execute...
+      potential_addition = Bewildr::ControlTypeAdditions.submodules.select {|mod| mod.name.demodulize == "#{@control_type.to_s.classify}Additions"}.first
+      extend potential_addition unless potential_addition.nil?
+
+      #non-standards - move this to another method in the near future
+      extend Bewildr::ControlTypeAdditions::TextAdditions if @control_type == :hyperlink
 
       #add scrolling capability if relevant - TODO: this ugliness will be fixed later
       if @automation_element.get_supported_patterns.collect {|pattern| pattern.programmatic_name.to_s }.include?("ScrollPatternIdentifiers.Pattern")

data/lib/bewildr/finder.rb

@@ -1,10 +1,20 @@
 #Copyright (c) 2010, Nathaniel Ritmeyer. All rights reserved.
 
 module Bewildr
+  #Wraps the Search Condition paradigm used by MS UI Automation to find objects in the UI Element tree. It contains various
+  #methods that build up the parts needed for to search for elements. These methods are called by Bewildr::Element#get in
+  #order to get and test for existence of descendent elements in the UI element tree. All of the methods take a condition
+  #hash, this is made up of at least one, but can be several key/value pairs.
   class Finder
     extend Bewildr::BewildrHelpers
     
     class << self
+      #Returns a System::Windows::Automation::PropertyCondition or AndCondition based on a translation of the condition hash.
+      #The condition hash must contain at least one of the following keys:
+      #  :id => "some id"
+      #  :name => "some name"
+      #  :type => :some_control_type
+      #These keys can be combined to create more complex search criteria
       def condition_for(condition_hash)
         conditions = condition_hash.select {|key, value| [:id, :name, :type].include?(key) }
         conditions = Hash[*conditions.flatten]
@@ -15,6 +25,11 @@ module Bewildr
         end
       end
 
+      #Returns whether the seach should interrogate only children, or all descendants. If neither is specified, the default
+      #is to search the descendants. The condition hash should contain one of the following options:
+      #  :scope => :children
+      #  :scope => :descendants
+      #  nothing
       def scope_for(condition_hash)
         case condition_hash[:scope]
         when :children          then System::Windows::Automation::TreeScope.Children
@@ -22,7 +37,12 @@ module Bewildr
         end
       end
 
-      #returns the method to call
+      #Returns whether the seach should stop at the first element that matches the criteria or whether it should find all
+      #elements that match. If neither is specified, the default is to find only the first element that matches. The condition
+      #hash should contain one of the following options:
+      #  :how_many => :first
+      #  :how_many => :all
+      #  nothing
       def how_many_for(condition_hash)
         case condition_hash[:how_many]
         when :first, nil then :find_first
@@ -33,12 +53,16 @@ module Bewildr
 
       private
 
+      #Used to create an AndCondition that takes into account all of the search conditions. This is done by
+      #creating a single condition for each of the conditions and then creating an AndCondition combining
+      #the individual search conditions
       def multiple_conditions(condition_hash)
         condition_array = []
         condition_hash.keys.each {|key| condition_array << single_condition({key => condition_hash[key]}) }
         System::Windows::Automation::AndCondition.new(r_array_to_cs_array_of_conditions(condition_array))
       end
 
+      #Calls the condition hash's corresponding condition creation method
       def single_condition(condition_hash)
         case condition_hash.keys.first
         when :id    then id_condition(condition_hash)
@@ -47,16 +71,19 @@ module Bewildr
         end
       end
 
+      #Returns a PropertyCondition when :id has been specified as the condition type
       def id_condition(condition_hash)
         value = r_string_to_c_string(condition_hash[:id].to_s)
         System::Windows::Automation::PropertyCondition.new(System::Windows::Automation::AutomationElement.automation_id_property, value)
       end
 
+      #Returns a PropertyCondition when :name has been specified as the condition type
       def name_condition(condition_hash)
         value = r_string_to_c_string(condition_hash[:name])
         System::Windows::Automation::PropertyCondition.new(System::Windows::Automation::AutomationElement.name_property, value)
       end
 
+      #Returns a PropertyCondition when :type has been specified as the condition type
       def type_condition(condition_hash)
         value = Bewildr::ControlType.enum_for_symbol(condition_hash[:type])
         System::Windows::Automation::PropertyCondition.new(System::Windows::Automation::AutomationElement.control_type_property, value)

data/lib/bewildr/mouse.rb

@@ -0,0 +1,99 @@
+#Represents and gives access to mouse actions. Implemented as a singleton, but accessed through class methods to make the API more contained.
+class Bewildr::Mouse
+  include Singleton
+
+  def initialize
+    @clickr = Bewildr::Clickr::Clickr.new
+  end
+
+  #Returns the BewildrClickr instance - don't use!
+  def clickr
+    @clickr
+  end
+
+  #Clicks the mouse at the supplied point
+  def self.click(point)
+    instance.clickr.click(point)
+  end
+
+  #Double clicks the mouse at the supplied point
+  def self.double_click(point)
+    instance.clickr.double_click(point)
+  end
+
+  #Right clicks the mouse at the supplied point
+  def self.right_click(point)
+    instance.clickr.right_click(point)
+  end
+
+  #Press the left mouse button down at the current point
+  def self.left_down
+    instance.clickr.left_mouse_button_down
+  end
+
+  #Release the left mouse button
+  def self.left_up
+    instance.clickr.left_mouse_button_up
+  end
+
+  #Moves the mouse to the supplied point
+  def self.move_to(point)
+    instance.clickr.set_location(point)
+  end
+
+  #Drags the mouse from one location to another, and optionally, via another! Pass a has containing the following keys:
+  #  :from
+  #  :to
+  #  :via (optional)
+  #  :wait_at_via_for
+  #The value for each of those keys should be either a point or an element apart from :wait_at_via_for which
+  #takes seconds (eg: 0.2, 3, etc). If an element is supplied, the drag point will be the element's clickable point
+  def self.drag(args)
+    raise "Can't drag without a :from key in the hash" unless args.keys.include?(:from)
+    raise "Can't drag without a :to key in the hash" unless args.keys.include?(:to)
+
+    point_from = args[:from]
+    point_to   = args[:to]
+    point_via  = args[:via]
+    args[:wait_at_via_for].nil? ? wait_time = 2 : wait_time = args[:wait_at_via_for]
+
+    point_from = point_from.clickable_point if point_from.instance_of?(Bewildr::Element)
+    point_to   = point_to.clickable_point if point_to.instance_of?(Bewildr::Element)
+    point_via  = point_via.clickable_point if !point_via.nil? && point_via.instance_of?(Bewildr::Element)
+    
+    raise "Supplied :from was not an Element or a Point" unless point_from.class == System::Windows::Point
+    raise "Supplied :to was not an Element or a Point"   unless point_to.class   == System::Windows::Point
+    raise "Supplied :via was not an Element or a Point"  unless point_via.nil? || point_via.class  == System::Windows::Point
+
+    self.move_to(point_from)
+    self.left_down
+    sleep 0.2
+
+    if point_via.instance_of?(System::Windows::Point)
+      almost_midway = System::Windows::Point.new
+      almost_midway.x = point_via.x + 1
+      almost_midway.y = point_via.y + 1
+      self.move_to(almost_midway)
+      sleep 0.3
+      self.move_to(point_via)
+      sleep wait_time
+    end
+
+    almost_there = System::Windows::Point.new
+    almost_there.x = point_to.x + 1
+    almost_there.y = point_to.y + 1
+
+    self.move_to(almost_there)
+    sleep 0.2
+    self.move_to(point_to)
+    self.left_up
+  end
+end
+
+=begin
+        Methods in BewildrClickr dll that need wrapping here...
+
+        public void Drag(Point startingLocation, Point targetLocation)
+        public void RightMouseButtonDown()
+        public void RightMouseButtonUp()
+=end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: bewildr
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: false
   segments: 
   - 0
   - 1
-  - 8
-  version: 0.1.8
+  - 9
+  version: 0.1.9
 platform: ruby
 authors: 
 - Nat Ritmeyer
@@ -15,10 +15,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-08 00:00:00 +00:00
+date: 2011-01-20 00:00:00 +00:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
 description: Test WPF UI apps with IronRuby
 email: nat@natontesting.com
 executables: []
@@ -64,6 +79,7 @@ files:
 - lib/bewildr/ext/BewildrClickr.dll
 - lib/bewildr/ext/extensions.rb
 - lib/bewildr/finder.rb
+- lib/bewildr/mouse.rb
 - lib/bewildr/windows.rb
 - lib/bewildr.rb
 has_rdoc: true