rubybreaker 0.0.2 → 0.0.3

data/lib/rubybreaker/{error.rb → debug/error.rb}

@@ -48,7 +48,7 @@ module RubyBreaker
 
     end
 
-    class TypeError < ::UserError
+    class TypeError < UserError
     end
 
     class SubtypeFailure < TypeError

data/lib/rubybreaker/runtime.rb

@@ -41,7 +41,7 @@ module RubyBreaker
     end
 
   end
- 
+
   # This module is included for "broken" classes.
   module Broken
 
@@ -85,7 +85,8 @@ module RubyBreaker
               meth_type.types << t
             else
               # then upgrade it
-              placeholder.meth_type_map[t.meth_name] = MethodListType.new([meth_type, t])
+              placeholder.meth_type_map[t.meth_name] = 
+                  MethodListType.new([meth_type, t])
             end
           else
             placeholder.meth_type_map[t.meth_name] = t

data/lib/rubybreaker/runtime/inspector.rb

@@ -1,6 +1,6 @@
 #--
-# This file defines Inspector which finds the type placeholder for a
-# module.
+# This file defines the type inspector which fetches the type information
+# gathered or documented in a Breakable, Broken, or hybrid module.
 
 require_relative "util"
 require_relative "monitor"
@@ -9,24 +9,26 @@ module RubyBreaker
 
   module Runtime
   
-    # This module inspects a Breakable module and retrieves type information
-    # if there is any.
+    # This module inspects a Breakable module, a Broken module, or a hybrid
+    # module to fetch the type information for each method.
     module Inspector
       
-      # This method inspects the module for specified method name. It
-      # returns the method type or method list type for the given method. If
-      # no method exists or if there is no type information for the method,
-      # it returns nil
+      # This method inspects the module for the type of the specified
+      # method. It returns the method type or method list type for the given
+      # method, by looking at, first, the placeholder for the Breakable
+      # side of the module, and then, the placeholder for the Broken side of
+      # the module. If no method exists or if there is no type information
+      # for the method, it returns nil.
       def self.inspect_meth(mod, mname)
         mname = mname.to_sym 
         if Breakable::TYPE_PLACEHOLDER_MAP.has_key?(mod)
           placeholder = Breakable::TYPE_PLACEHOLDER_MAP[mod]
-        elsif Broken::TYPE_PLACEHOLDER_MAP.has_key?(mod)
-          placeholder = Broken::TYPE_PLACEHOLDER_MAP[mod]
-        else
-          # TODO
         end
         t = placeholder.meth_type_map[mname] if placeholder
+        if !t && Broken::TYPE_PLACEHOLDER_MAP.has_key?(mod)
+          placeholder = Broken::TYPE_PLACEHOLDER_MAP[mod]
+          t = placeholder.meth_type_map[mname] if placeholder
+        end
         return t
       end
 
@@ -56,10 +58,15 @@ module RubyBreaker
             mtypes[im] = mtype if mtype 
           }
         end
+        mm = Broken::TYPE_PLACEHOLDER_MAP[mod]
+        if mm
+          mm.meth_type_map.each_pair {|im,mtype|
+            mtypes[im] = mtype if mtype 
+          }
+        end
         return mtypes
       end 
       
-      
     end
   
   end

data/lib/rubybreaker/runtime/monitor.rb

@@ -6,9 +6,8 @@
 
 dir = File.dirname(__FILE__) 
 require_relative "util"
-require_relative "type_placeholder"
-require_relative "../context"
 require_relative "../debug"
+require_relative "type_placeholder"
 require_relative "pluggable"
 require_relative "type_system"
 
@@ -56,12 +55,12 @@ module RubyBreaker
       def initialize(); @switch = true end
 
       def turn_on();
-        Debug.msg("Switch turned on")
+        RubyBreaker.log("Switch turned on")
         @switch = true; 
       end
 
       def turn_off(); 
-        Debug.msg("Switch turned off")
+        RubyBreaker.log("Switch turned off")
         @switch = false; 
       end
 
@@ -120,7 +119,7 @@ module RubyBreaker
         # this is what the renamed method
         stub_meth_name = get_alt_meth_name(meth_name) 
 
-        Debug.msg("Route to #{stub_meth_name}",CONTEXT)
+        RubyBreaker.log("Route to #{stub_meth_name}", :debug, CONTEXT)
 
         # short-circuit if switch was off--i.e., no monitoring
         if !switch
@@ -143,7 +142,7 @@ module RubyBreaker
 
         mm.monitor_before_method(obj, meth_info)
 
-        Debug.msg("monitor_before_method ended")
+        RubyBreaker.log("monitor_before_method ended")
 
         # we are going to turn the switch back on
         GLOBAL_MONITOR_SWITCH.turn_on()
@@ -197,7 +196,7 @@ module RubyBreaker
       def self.rename_meth(recv, meth_name)
         alt_meth_name = MonitorUtils.get_alt_meth_name(meth_name)
         recv.module_eval("alias :\"#{alt_meth_name}\" :\"#{meth_name}\"")
-        Debug.msg("Adding alternate method for #{meth_name}")
+        RubyBreaker.log("Adding alternate method for #{meth_name}")
         recv.module_eval <<-EOF
           def #{meth_name}(*args, &blk)
             RubyBreaker::Runtime::MonitorUtils.route(self, 
@@ -210,18 +209,27 @@ module RubyBreaker
 
       # Installs an module (class) monitor to the object. 
       def self.install_module_monitor(mod)
-        Debug.short_msg("Installing module monitor for #{mod}")
+
+        RubyBreaker.log("Installing module monitor for #{mod}")
+
         Breakable::MONITOR_MAP[mod] = Monitor.new(mod, DEFAULT_TYPE_SYSTEM)
         Breakable::TYPE_PLACEHOLDER_MAP[mod] = TypePlaceholder.new
+
         meth_type_map = []
         meths = mod.instance_methods(false)  
+
+        # RubyBreaker now supports the hybrid of Breakable and Broken. Here,
+        # see if any methods are already broken.
+        broken_meth_type_map = Inspector.inspect_all(mod)
+        broken_meths = broken_meth_type_map.keys
+
         meths.each do |m| 
-          self.rename_meth(mod,m) 
+          # As long as the method is not "Broken" yet, it is considered
+          # Breakable (if the module is declared to be Breakable).
+          unless broken_meths.include?(m)
+            self.rename_meth(mod,m) 
+          end 
         end
-        Debug.feed_line()
-      end
-
-      def self.report(mod)
       end
 
     end

data/lib/rubybreaker/runtime/object_wrapper.rb

@@ -1,6 +1,8 @@
 #--
 # This program keeps track of every method call to a wrapped object. 
 
+require_relative "../debug"
+
 module RubyBreaker
 
   module Runtime
@@ -66,7 +68,7 @@ module RubyBreaker
       
       # This method missing method redirects all other method calls.
       def method_missing(mname,*args,&blk)
-        Debug.msg("Method_missing for #{mname}")
+        ::RubyBreaker.log("Method_missing for #{mname}")
         if GLOBAL_MONITOR_SWITCH.switch
           @__rubybreaker_type.add_meth(mname)
           retval =  @__rubybreaker_obj.send(mname,*args,&blk)

data/lib/rubybreaker/runtime/type_system.rb

@@ -10,6 +10,7 @@ require_relative "object_wrapper"
 require_relative "type_placeholder"
 require_relative "../type"
 require_relative "../typing"
+require_relative "../debug"
 
 module RubyBreaker
 
@@ -192,7 +193,7 @@ module RubyBreaker
           end
         end
 
-        Debug.msg("In module monitor_before #{meth_name}")
+        RubyBreaker.log("In module monitor_before #{meth_name}")
         
         meth_type = meth_type_map[meth_name]
         
@@ -241,7 +242,7 @@ module RubyBreaker
         args = meth_info.args
         blk = meth_info.blk
 
-        Debug.msg("In module monitor_after #{meth_name}")
+        RubyBreaker.log("In module monitor_after #{meth_name}")
 
         meth_type_map = Breakable::TYPE_PLACEHOLDER_MAP[mod].meth_type_map
 

data/lib/rubybreaker/test/testcase.rb

@@ -25,7 +25,6 @@ module RubyBreaker
       alias :__run :run
 
       def run(*args,&blk)
-        # RubyBreaker::Utilities.rb_print("Running " + args[0].to_s)
         RubyBreaker::TestCase.setup()
         __run(*args,&blk)
         RubyBreaker::TestCase.teardown()

data/lib/rubybreaker/type/type.rb

@@ -17,7 +17,7 @@
 #
 
 require_relative "../util"
-require_relative "../context.rb"
+require_relative "../debug"
 
 module RubyBreaker
 

data/lib/rubybreaker/type/type_grammar.treetop

@@ -232,7 +232,7 @@ grammar TypeGrammar
         pos = RubyBreaker::Position.get()
         pos.col = interval.first
         begin 
-          mod_name = RubyBreaker::Utilities.camelize(text_value)
+          mod_name = RubyBreaker::Util.camelize(text_value)
           mod = eval mod_name
           t = RubyBreaker::NominalType.new(mod,pos)
         rescue

data/lib/rubybreaker/type/type_unparser.rb

@@ -37,7 +37,7 @@ module RubyBreaker
     # print method.
     def self.unparse_pp(pp,t)
       if t.instance_of?(NominalType)
-        tname = Utilities.underscore(t.mod)
+        tname = Util.underscore(t.mod)
         tokens = tname.split("/")        
         tname = tokens.last if tokens.size > 1
         pp.text(tname)

data/lib/rubybreaker/util.rb

@@ -4,7 +4,9 @@
 
 module RubyBreaker
 
-  module Utilities
+  # This module has utility functions that are useful across all components
+  # in the project.
+  module Util
 
     # File activesupport/lib/active_support/inflector/methods.rb, line 48
     def self.underscore(camel_cased_word)
@@ -28,14 +30,4 @@ module RubyBreaker
 
   end
 
-  # http://mentalized.net/journal/2010/04/02/suppress_warnings_from_ruby/
-  module Kernel
-    def suppress_warning
-      original_verbosity = $VERBOSE
-      $VERBOSE = nil
-      result = yield
-      $VERBOSE = original_verbosity
-      return result
-    end
-  end
 end

data/test/integrated/tc_both_broken_breakable.rb

@@ -0,0 +1,27 @@
+require "test/unit"
+require_relative "../../lib/rubybreaker"
+
+class IntegratedBothBrokenBreakableTest < Test::Unit::TestCase
+  include RubyBreaker
+  include RubyBreaker::TestCase
+
+  class A
+    include RubyBreaker::Breakable
+    include RubyBreaker::Broken
+    typesig("foo(fixnum[to_s]) -> string") 
+    def foo(x); x.to_s end
+    def bar(x); x.to_sym end
+  end
+
+  def test_both_broken_and_breakable
+    # A.new.foo(1)
+    A.new.bar("abc")
+    a_foo_meth_type = Runtime::Inspector.inspect_meth(A, :foo)
+    a_bar_meth_type = Runtime::Inspector.inspect_meth(A, :bar)
+    str = RubyBreaker::TypeUnparser.unparse(a_foo_meth_type)
+    assert_equal("foo(fixnum[to_s]) -> string", str)
+    str = RubyBreaker::TypeUnparser.unparse(a_bar_meth_type)
+    assert_equal("bar(string[to_sym]) -> symbol", str)
+  end
+
+end

data/test/ts_integrated.rb

@@ -4,3 +4,4 @@ require_relative "integrated/tc_method_missing"
 require_relative "integrated/tc_simple1"
 require_relative "integrated/tc_inherit_broken"
 require_relative "integrated/tc_class_methods"
+require_relative "integrated/tc_both_broken_breakable"

data/webpage/index.html

@@ -197,10 +197,20 @@ signature <code>bar(fixnum[to_s]) -&gt; string</code>, which means it takes an o
 has <code>Fixnum</code>'s <code>to_s</code> method and returns a string. More detail on the type
 annotation language will be explained in later section.</p>
 
-<p>It is possible to include either <code>Breakable</code> or <code>Broken</code> in an eigen-class
-to document class methods. To make this easier, RubyBreaker will
-automatically support auto-documentation and manual documentation of class
-methods if the original module is declared as <code>Breakable</code> or <code>Broken</code>,
+<h3>Hybrid of Breakable and Broken</h3>
+
+<p>Starting from version 0.0.3, RubyBreaker allows a module to be declared as
+<code>Breakable</code> and <code>Broken</code> at the same time. If a method has a corresponding
+type signature (manually documented) somewhere, then RubyBreaker will not
+monitor it during runtime. All other methods will be instrumented and
+monitored by RubyBreaker.</p>
+
+<h3>Class Methods</h3>
+
+<p>It is possible to include <code>Breakable</code> and/or <code>Broken</code> in an eigen-class to
+document class methods. To make this easier, RubyBreaker will automatically
+support auto-documentation and manual documentation of class methods if the
+original module is declared as <code>Breakable</code> and/or <code>Broken</code>,
 respectively--that is, up to immediate eigen class level of a "nominal"
 module.  The following example shows how class methods can be
 auto-documented and manually documented, respectively.</p>
@@ -221,11 +231,6 @@ class B
 end
 </code></pre>
 
-<p>Keep in mind that <code>Broken</code> module always wins against <code>Breakable</code>.  In other
-words, if a module is declared as both <code>Broken</code> and <code>Breakable</code>, it is
-treated as <code>Broken</code>. Future versions of RubyBreaker will support a hybrid of
-the two modules, but it remains as a limitation in the current version.</p>
-
 <h3>Program Entry Point</h3>
 
 <p>In Ruby, as soon as a file is <code>require</code>d, the execution of that file begins.
@@ -301,8 +306,8 @@ and returns a <code>String</code> object. Note that these types are in lowercase
 indicating they are objects and not modules or classes themselves.</p>
 
 <p>There are several types that represent an object: nominal, duck, fusion,
-nil, 'any', and block. Each type signature itself represents a method type
-or a method list type (explained below).</p>
+nil, 'any', 'or', optional, variable-length, and block. Each type signature
+itself represents a method type or a method list type (explained below).</p>
 
 <h3>Nominal Type</h3>
 
@@ -355,6 +360,20 @@ other type is not a subtype of <code>?</code>. This becomes a bit complicated fo
 method or block argument types because of their contra-variance
 characteristic. Please refer to the section <em>Subtyping</em>.</p>
 
+<h3>Or Type</h3>
+
+<p>Any above types can be "or"ed together, using <code>||</code>, to represent an object
+that can be either one or the other. It <em>does</em> not represent an object that
+has to be both (which is not supported by RubyBreaker).</p>
+
+<h3>Optional Argument Type and Variable-Length Argument Type</h3>
+
+<p>Another useful features of Ruby are the optional argument type and the
+variable-length argument type. The former represents an argument that has a
+default value (and therefore does not have to be provided). The latter
+represents zero or more arguments of the same type. These are denoted by
+suffices, <code>?</code> and <code>*</code>, respectively.</p>
+
 <h3>Block Type</h3>
 
 <p>One of the Ruby's prominent features is the block argument. It allows
@@ -370,14 +389,6 @@ However, <em>keep in mind</em> that RubyBreaker <em>cannot</em> automatically do
 block types due to <code>yield</code> being a language construct rather than a method,
 which means it cannot be captured by meta-programming!</p>
 
-<h3>Optional Argument Type and Variable-Length Argument Type</h3>
-
-<p>Another useful features of Ruby are the optional argument type and the
-variable-length argument type. The former represents an argument that has a
-default value (and therefore does not have to be provided). The latter
-represents zero or more arguments of the same type. These are denoted by
-suffices, <code>?</code> and <code>*</code>, respectively.</p>
-
 <h3>Method Type and Method List Types</h3>
 
 <p>Method type is similar to the block type, but it represents an actual method

data/webpage/rdoc/RubyBreaker.html

@@ -47,9 +47,9 @@
     <nav id="file-list-section" class="section">
   <h3 class="section-header">Defined In</h3>
   <ul>
-    <li>lib/rubybreaker/context.rb
-    <li>lib/rubybreaker/debug.rb
-    <li>lib/rubybreaker/error.rb
+    <li>lib/rubybreaker/debug/context.rb
+    <li>lib/rubybreaker/debug/debug.rb
+    <li>lib/rubybreaker/debug/error.rb
     <li>lib/rubybreaker/runtime/inspector.rb
     <li>lib/rubybreaker/runtime/monitor.rb
     <li>lib/rubybreaker/runtime/object_wrapper.rb
@@ -96,8 +96,14 @@
 
   <ul class="link-list">
     
+    <li><a href="#method-c-error">::error</a>
+    
+    <li><a href="#method-c-log">::log</a>
+    
     <li><a href="#method-c-monitor">::monitor</a>
     
+    <li><a href="#method-c-verbose">::verbose</a>
+    
   </ul>
 </nav>
 
@@ -120,8 +126,6 @@
   
     <li><a href="./RubyBreaker/Context.html">RubyBreaker::Context</a>
   
-    <li><a href="./RubyBreaker/Debug.html">RubyBreaker::Debug</a>
-  
     <li><a href="./RubyBreaker/Errors.html">RubyBreaker::Errors</a>
   
     <li><a href="./RubyBreaker/Errors/InternalError.html">RubyBreaker::Errors::InternalError</a>
@@ -136,8 +140,6 @@
   
     <li><a href="./RubyBreaker/Errors/UserError.html">RubyBreaker::Errors::UserError</a>
   
-    <li><a href="./RubyBreaker/Kernel.html">RubyBreaker::Kernel</a>
-  
     <li><a href="./RubyBreaker/Main.html">RubyBreaker::Main</a>
   
     <li><a href="./RubyBreaker/ObjectPosition.html">RubyBreaker::ObjectPosition</a>
@@ -206,7 +208,7 @@
   
     <li><a href="./RubyBreaker/Typing.html">RubyBreaker::Typing</a>
   
-    <li><a href="./RubyBreaker/Utilities.html">RubyBreaker::Utilities</a>
+    <li><a href="./RubyBreaker/Util.html">RubyBreaker::Util</a>
   
   </ul>
 </nav>
@@ -292,6 +294,81 @@ monitor.</p>
       <h3 class="section-header">Public Class Methods</h3>
 
     
+      <div id="method-c-error" class="method-detail ">
+        
+        <div class="method-heading">
+          <span class="method-name">error</span><span
+            class="method-args">(err, level=:error, &blk)</span>
+          <span class="method-click-advice">click to toggle source</span>
+        </div>
+        
+
+        <div class="method-description">
+          
+          <p>This method is for reporting an error to the user. It will immediately show
+the error message but also log it.</p>
+          
+
+          
+          <div class="method-source-code" id="error-source">
+            <pre><span class="ruby-comment"># File lib/rubybreaker/debug/debug.rb, line 38</span>
+<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">error</span>(<span class="ruby-identifier">err</span>, <span class="ruby-identifier">level</span>=<span class="ruby-value">:error</span>, &amp;<span class="ruby-identifier">blk</span>)
+  <span class="ruby-identifier">msg</span> = <span class="ruby-identifier">err</span>.<span class="ruby-identifier">to_s</span>
+  <span class="ruby-identifier">msg</span> = <span class="ruby-node">&quot;#{msg} : #{yield}&quot;</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">blk</span>
+  <span class="ruby-constant">STDOUT</span>.<span class="ruby-identifier">puts</span> <span class="ruby-node">&quot;[#{level.to_s.upcase}] #{msg}&quot;</span>
+  <span class="ruby-constant">LOGGER</span>.<span class="ruby-identifier">send</span>(<span class="ruby-identifier">level</span>, <span class="ruby-identifier">msg</span>) <span class="ruby-keyword">if</span> <span class="ruby-keyword">defined?</span>(<span class="ruby-constant">OPTIONS</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-constant">OPTIONS</span>[<span class="ruby-value">:debug</span>]
+<span class="ruby-keyword">end</span></pre>
+          </div><!-- error-source -->
+          
+        </div>
+
+        
+
+        
+      </div><!-- error-method -->
+
+    
+      <div id="method-c-log" class="method-detail ">
+        
+        <div class="method-heading">
+          <span class="method-name">log</span><span
+            class="method-args">(str, level=:debug, context=nil, &blk)</span>
+          <span class="method-click-advice">click to toggle source</span>
+        </div>
+        
+
+        <div class="method-description">
+          
+          <p>This method logs a non-error (or error) message but with the provided
+context.</p>
+          
+
+          
+          <div class="method-source-code" id="log-source">
+            <pre><span class="ruby-comment"># File lib/rubybreaker/debug/debug.rb, line 47</span>
+<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">log</span>(<span class="ruby-identifier">str</span>, <span class="ruby-identifier">level</span>=<span class="ruby-value">:debug</span>, <span class="ruby-identifier">context</span>=<span class="ruby-keyword">nil</span>, &amp;<span class="ruby-identifier">blk</span>)
+  <span class="ruby-keyword">return</span> <span class="ruby-keyword">unless</span> <span class="ruby-keyword">defined?</span>(<span class="ruby-constant">OPTIONS</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-constant">OPTIONS</span>[<span class="ruby-value">:debug</span>]
+  <span class="ruby-identifier">msg</span> = <span class="ruby-identifier">str</span>.<span class="ruby-identifier">to_s</span>
+  <span class="ruby-identifier">msg</span> = <span class="ruby-node">&quot;#{msg} : #{yield}&quot;</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">blk</span>
+  <span class="ruby-keyword">if</span> <span class="ruby-identifier">context</span>
+    <span class="ruby-identifier">output</span> = <span class="ruby-string">&quot;&quot;</span>
+    <span class="ruby-identifier">pp</span> = <span class="ruby-constant">PrettyPrint</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">output</span>)
+    <span class="ruby-identifier">context</span>.<span class="ruby-identifier">format_with_msg</span>(<span class="ruby-identifier">pp</span>,<span class="ruby-identifier">msg</span>)
+    <span class="ruby-identifier">pp</span>.<span class="ruby-identifier">flush</span>
+    <span class="ruby-identifier">msg</span> = <span class="ruby-identifier">output</span>
+  <span class="ruby-keyword">end</span>
+  <span class="ruby-constant">LOGGER</span>.<span class="ruby-identifier">send</span>(<span class="ruby-identifier">level</span>, <span class="ruby-identifier">msg</span>) 
+<span class="ruby-keyword">end</span></pre>
+          </div><!-- log-source -->
+          
+        </div>
+
+        
+
+        
+      </div><!-- log-method -->
+
+    
       <div id="method-c-monitor" class="method-detail ">
         
         <div class="method-heading">
@@ -303,12 +380,13 @@ monitor.</p>
 
         <div class="method-description">
           
-          <p>Just redirecting</p>
+          <p>This is the manual indicator for the program entry point. It simply
+redirects to the monitor setup code.</p>
           
 
           
           <div class="method-source-code" id="monitor-source">
-            <pre><span class="ruby-comment"># File lib/rubybreaker.rb, line 209</span>
+            <pre><span class="ruby-comment"># File lib/rubybreaker.rb, line 229</span>
 <span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">monitor</span>()
   <span class="ruby-constant">Main</span>.<span class="ruby-identifier">setup</span>()
 <span class="ruby-keyword">end</span></pre>
@@ -322,6 +400,45 @@ monitor.</p>
       </div><!-- monitor-method -->
 
     
+      <div id="method-c-verbose" class="method-detail ">
+        
+        <div class="method-heading">
+          <span class="method-name">verbose</span><span
+            class="method-args">(str) { || ... }</span>
+          <span class="method-click-advice">click to toggle source</span>
+        </div>
+        
+
+        <div class="method-description">
+          
+          <p>This method will display verbose message. It is not for debugging but to
+inform users of each stage in the analysis.</p>
+          
+
+          
+          <div class="method-source-code" id="verbose-source">
+            <pre><span class="ruby-comment"># File lib/rubybreaker/debug/debug.rb, line 24</span>
+<span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier">verbose</span>(<span class="ruby-identifier">str</span>, &amp;<span class="ruby-identifier">blk</span>)
+  <span class="ruby-keyword">return</span> <span class="ruby-keyword">unless</span> <span class="ruby-keyword">defined?</span>(<span class="ruby-constant">OPTIONS</span>) <span class="ruby-operator">&amp;&amp;</span> (<span class="ruby-constant">OPTIONS</span>[<span class="ruby-value">:verbose</span>] <span class="ruby-operator">||</span> <span class="ruby-constant">OPTIONS</span>[<span class="ruby-value">:debug</span>])
+  <span class="ruby-keyword">if</span> <span class="ruby-identifier">blk</span>
+    <span class="ruby-identifier">msg</span> = <span class="ruby-keyword">yield</span>
+    <span class="ruby-identifier">msg</span> = <span class="ruby-node">&quot;#{str} : #{msg}&quot;</span> <span class="ruby-keyword">if</span> <span class="ruby-identifier">str</span>
+  <span class="ruby-keyword">else</span>
+    <span class="ruby-identifier">msg</span> = <span class="ruby-identifier">str</span>
+  <span class="ruby-keyword">end</span>
+  <span class="ruby-constant">STDOUT</span>.<span class="ruby-identifier">puts</span> <span class="ruby-identifier">msg</span> <span class="ruby-keyword">if</span> <span class="ruby-constant">OPTIONS</span>[<span class="ruby-value">:verbose</span>]
+  <span class="ruby-constant">LOGGER</span>.<span class="ruby-identifier">info</span> <span class="ruby-identifier">msg</span> <span class="ruby-keyword">if</span> <span class="ruby-constant">OPTIONS</span>[<span class="ruby-value">:debug</span>]
+<span class="ruby-keyword">end</span></pre>
+          </div><!-- verbose-source -->
+          
+        </div>
+
+        
+
+        
+      </div><!-- verbose-method -->
+
+    
     </section><!-- public-class-method-details -->
   
   </section><!-- 5Buntitled-5D -->