fOOrth 0.6.6 → 0.6.11

data/lib/fOOrth/library/formatting/hash.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+#* library/formatting/hash.rb - Hash support for displaying data formatted neatly.
+class Hash
+
+  # Bullets ========================================================
+
+  #Print out the array as bullet points.
+  def puts_foorth_bullets(page_width)
+    puts foorth_format_bullets(page_width)
+  end
+
+  #Convert the array to strings with bullet points.
+  #<br>Returns
+  #* A string.
+  def foorth_format_bullets(page_width)
+    return "" if empty?
+
+    builder = XfOOrth::BulletPoints.new(page_width)
+
+    self.each do |pair|
+      builder.add(*pair)
+    end
+
+    builder.render.join("\n").freeze
+  end
+
+end
+

data/lib/fOOrth/library/formatting/nil.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+
+#* library/formatting/nil.rb - Support for displaying nothing formatted neatly.
+class NilClass
+
+  #Create a bullet point description from nothing.
+  def format_description(_max_width)
+    []
+  end
+
+end
+
+

data/lib/fOOrth/library/formatting/object.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+#* library/formatting/object.rb - Support for displaying data formatted neatly.
+class Object
+
+  #Create a bullet point description from this object.
+  def format_description(max_width)
+    self.to_s.format_description(max_width)
+  end
+
+  #Get data ready for being in a bullet point.
+  def prepare_bullet_data
+    ["*", self]
+  end
+
+end
+
+

data/lib/fOOrth/library/formatting/string.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+#* library/formatting/string.rb - Support for displaying data formatted neatly.
+class String
+
+  #Create a bullet point description from this string.
+  def format_description(max_width)
+    do_format_description(split(' ').each, max_width)
+  end
+
+  #Do the formatting legwork.
+  def do_format_description(input, max_width)
+    result, build = [], ""
+
+    loop do
+      build = build.split_if_over(input.next, max_width, result)
+                   .split_if_huge(max_width, result)
+    end
+
+    result << build
+  end
+
+  #Split if adding a word goes over a little.
+  def split_if_over(word, max_width, buffer)
+    word.prepend(" ") unless self.empty?
+    word_len = word.length
+
+    if (length + word_len) >= max_width && word_len < max_width
+      buffer << self
+      word.lstrip
+    else
+      self + word
+    end
+
+  end
+
+  #Split up a overlong blob of text.
+  def split_if_huge(max_width, buffer)
+    while length >= max_width
+      buffer << slice!(0, max_width)
+    end
+
+    self
+  end
+end
+

data/lib/fOOrth/library/hash_library.rb

@@ -70,27 +70,35 @@ module XfOOrth
 
   # [i h] .[]@ [h[i]]
   Hash.create_shared_method('.[]@', TosSpec, [],
-    &lambda {|vm| vm.poke(self[vm.peek]); })
+    &lambda {|vm| vm.poke(self[vm.peek]) })
 
   # [v i h] .[]! []; h[i]=v
   Hash.create_shared_method('.[]!', TosSpec, [],
-    &lambda {|vm| value, index = vm.popm(2); self[index] = value; })
+    &lambda {|vm| value, index = vm.popm(2); self[index] = value })
 
   # [{"a"=>1, "b"=>2}] .length [2]]
   Hash.create_shared_method('.length', TosSpec, [],
-    &lambda {|vm| vm.push(self.length); })
+    &lambda {|vm| vm.push(self.length) })
 
   # [a_hash] .empty? [a_boolean]]
   Hash.create_shared_method('.empty?', TosSpec, [],
-    &lambda {|vm| vm.push(self.empty?); })
+    &lambda {|vm| vm.push(self.empty?) })
+
+  # [a_hash] .present? [a_boolean]]
+  Hash.create_shared_method('.present?', TosSpec, [],
+    &lambda {|vm| vm.push(!self.empty?) })
+
+  # [a_hash] .clear! []]
+  Hash.create_shared_method('.clear!', TosSpec, [],
+    &lambda {|vm| self.clear })
 
   # [h] .keys [[keys]]
   Hash.create_shared_method('.keys', TosSpec, [],
-    &lambda {|vm| vm.push(self.keys); })
+    &lambda {|vm| vm.push(self.keys) })
 
   # [h] .values [[values]]
   Hash.create_shared_method('.values', TosSpec, [],
-    &lambda {|vm| vm.push(self.values); })
+    &lambda {|vm| vm.push(self.values) })
 
   # [h] .strmax2 [widest_key widest_value]
   Hash.create_shared_method('.strmax2', TosSpec, [], &lambda {|vm|

data/lib/fOOrth/library/introspection/class.rb

@@ -30,17 +30,11 @@ class Class
     found = false
 
     if symbol
-      spec, info = map_foorth_shared_info(symbol)
-
-      if spec && !spec.has_tag?(:stub)
-        (results << ["", ""]).concat(info).concat(spec.get_info)
+      if scrape_method_info(results, *map_foorth_shared_info(symbol))
         found = true
       end
 
-      spec, info = map_foorth_exclusive_info(symbol)
-
-      if spec && !spec.has_tag?(:stub)
-        (results << ["", ""]).concat(info).concat(spec.get_info)
+      if scrape_method_info(results, *map_foorth_exclusive_info(symbol, "Class"))
         found = true
       end
 
@@ -54,18 +48,28 @@ class Class
   def get_info
     results = [["Lineage", lineage]]
 
-    if foorth_has_exclusive?
-      results.concat([["", ""], ["Methods", "Class"]])
+    get_exclusive_method_info(results, "Class")
+    get_shared_method_info(results)
 
-      foorth_exclusive.extract_method_names(:all).sort.each do |name|
-        symbol, info = XfOOrth::SymbolMap.map_info(name)
-        (results << ["", ""]).concat(info)
+    results
+  end
 
-        spec, info = map_foorth_exclusive_info(symbol, :shallow)
-        results.concat(info).concat(spec.get_info)
-      end
+  private
+
+  #Get method information
+  #<br>Endemic Code Smells
+  #* :reek:UtilityFunction
+  def scrape_method_info(results, spec, info)
+    if spec && !spec.has_tag?(:stub)
+      (results << ["", ""]).concat(info).concat(spec.get_info)
+      true
+    else
+      false
     end
+  end
 
+  #Get shared method info
+  def get_shared_method_info(results)
     unless foorth_shared.empty?
       results.concat([["", ""], ["Methods", "Shared"]])
 
@@ -77,8 +81,6 @@ class Class
         results.concat(info).concat(spec.get_info)
       end
     end
-
-    results
   end
 
 end

data/lib/fOOrth/library/introspection/context.rb

@@ -7,6 +7,8 @@ module XfOOrth
   class Context
 
     #Get introspection info.
+    #<br>Endemic Code Smells
+    #* :reek:FeatureEnvy :reek:TooManyStatements
     def get_info
       results = [["Level", depth]]
 
@@ -25,8 +27,7 @@ module XfOOrth
       end
 
       if (prev = self.previous)
-        results << ["", ""]
-        results.concat(prev.get_info)
+        results.concat([["", ""]]).concat(prev.get_info)
       end
 
       results

data/lib/fOOrth/library/introspection/object.rb

@@ -17,31 +17,15 @@ class Object
   #Get introspection info.
   def get_info
     results = [["Type", foorth_name]]
-
-    unless (vars = instance_variables).empty?
-      results.concat([["", ""], ["Data", "Instance"], ["", ""]])
-
-      vars.sort.each do |name|
-        var_name = XfOOrth::SymbolMap.unmap(name[1..-1].to_sym) || name
-        results << [var_name, instance_variable_get(name)]
-      end
-    end
-
-    if foorth_has_exclusive?
-      results.concat([["", ""], ["Methods", "Exclusive"]])
-
-      foorth_exclusive.extract_method_names(:all).sort.each do |name|
-        symbol, info = XfOOrth::SymbolMap.map_info(name)
-        results.concat([["", ""], ["Name", name], info])
-        spec, info = map_foorth_exclusive_info(symbol, :shallow)
-        results.concat(info).concat(spec.get_info)
-      end
-    end
+    get_instance_variable_info(results)
+    get_exclusive_method_info(results, "Exclusive")
 
     results
   end
 
   #Investigate a method of this object.
+  #<br>Endemic Code Smells
+  #* :reek:FeatureEnvy
   def foorth_method_info(name)
     symbol, results = XfOOrth::SymbolMap.map_info(name)
     found = false
@@ -65,5 +49,43 @@ class Object
     foorth_name + " < " + self.class.lineage
   end
 
+  private
+
+  #Get information about instance variables
+  def get_instance_variable_info(results)
+    names = instance_variables.map do |sym|
+      if (name = XfOOrth::SymbolMap.unmap(sym.to_s[1..-1].to_sym))
+        [name, sym]
+      end
+    end
+    .compact
+    .sort {|first, second| first[0] <=> second[0] }
+
+    unless names.empty?
+      results.concat([["", ""], ["Data", "Instance"], ["", ""]])
+
+      names.each do |name, sym|
+        results << [name, instance_variable_get(sym)]
+      end
+    end
+  end
+
+
+  #Get exclusive method info
+  def get_exclusive_method_info(results, designation)
+    if foorth_has_exclusive?
+      results.concat([["", ""], ["Methods", designation]])
+
+      foorth_exclusive.extract_method_names(:all).sort.each do |name|
+        symbol, info = XfOOrth::SymbolMap.map_info(name)
+        (results << ["", ""]).concat(info)
+
+        spec, info = map_foorth_exclusive_info(symbol, :shallow)
+        results.concat(info).concat(spec.get_info)
+      end
+    end
+  end
+
+
 
 end

data/lib/fOOrth/library/introspection/string.rb

@@ -4,6 +4,8 @@
 class String
 
   #Scan all classes for information about a method.
+  #<br>Endemic Code Smells
+  #* :reek:DuplicateMethodCall :reek:FeatureEnvy :reek:TooManyStatements
   def foorth_method_scan
     symbol, results = XfOOrth::SymbolMap.map_info(self)
     found = false
@@ -11,13 +13,27 @@ class String
     symbol && $FOORTH_GLOBALS.values
       .select {|entry| entry.has_tag?(:class)}
       .collect {|spec| spec.new_class}
-      .sort {|a,b| a.foorth_name <=> b.foorth_name}
+      .sort {|first, second| first.foorth_name <=> second.foorth_name}
       .each do |klass|
-        spec, info = klass.map_foorth_shared_info(symbol, :shallow)
-        found |= spec && (results << ["", ""]).concat(info).concat(spec.get_info)
+        shared_spec, shared_info = klass.map_foorth_shared_info(symbol, :shallow)
 
-        spec, info = klass.map_foorth_exclusive_info(symbol, :shallow)
-        found |= spec && (results << ["", ""]).concat(info).concat(spec.get_info)
+        if shared_spec
+          results
+            .concat([["", ""]])
+            .concat(shared_info)
+            .concat(shared_spec.get_info)
+        end
+
+        excl_spec, excl_info = klass.map_foorth_exclusive_info(symbol, :shallow)
+
+        if excl_spec
+          results
+            .concat([["", ""]])
+            .concat(excl_info)
+            .concat(excl_spec.get_info)
+        end
+
+        found ||= (shared_spec || excl_spec)
       end
 
     results << ["Scope", "not found in any class."] if symbol && !found

data/lib/fOOrth/library/introspection/vm.rb

@@ -8,6 +8,18 @@ module XfOOrth
 
     #Get introspection info.
     def get_info
+      results = get_basic_vm_info
+      get_instance_variable_info(results)
+      get_vm_thread_data_info(results)
+      get_exclusive_method_info(results, "Exclusive")
+
+      results
+    end
+
+    private
+
+    #Get the vm basic stuff first.
+    def get_basic_vm_info
       results = [["Name",    foorth_name],
                  ["Ruby",    self.to_s],
                  ["Stack",   @data_stack.inspect],
@@ -22,47 +34,23 @@ module XfOOrth
         results << ["Buffer", source.read_buffer.inspect]
       end
 
-      names = instance_variables.map do |sym|
-        if (name = XfOOrth::SymbolMap.unmap(sym.to_s[1..-1].to_sym))
-          [name, sym]
-        end
-      end
-
-      names.compact!
-
-      unless names.empty?
-        results.concat([["", ""], ["Data", "Instance"], ["", ""]])
-
-        names.each do |name, sym|
-          results << [name, instance_variable_get(sym)]
-        end
-      end
+      results
+    end
 
+    #Get the thread data info.
+    def get_vm_thread_data_info(results)
       unless @data.empty?
         results.concat([["", ""], ["Data", "Thread"], ["", ""]])
 
         @data
           .keys
           .map{|symbol| [SymbolMap.unmap(symbol), symbol]}
-          .sort{|a,b| a[0] <=> b[0]}
+          .sort{|first, second| first[0] <=> second[0]}
           .map{|name, symbol| [name, @data[symbol]]}
           .each do |name, value|
             results << [name, value.inspect]
           end
       end
-
-      if foorth_has_exclusive?
-        results.concat([["", ""], ["Methods", "Exclusive"]])
-
-        foorth_exclusive.extract_method_names(:all).sort.each do |name|
-          symbol, info = SymbolMap.map_info(name)
-          results.concat([["", ""], ["Name", name], info])
-          spec, info = map_foorth_exclusive_info(symbol, :shallow)
-          results.concat(info).concat(spec.get_info)
-        end
-      end
-
-      results
     end
 
   end

data/lib/fOOrth/library/mutex_library.rb

@@ -9,7 +9,7 @@ module XfOOrth
   # [Mutex] .do{{ ... }} [] (Releases a lock on the mutex)
   Mutex.create_exclusive_method('.do{{', NosSpec, [], &lambda {|vm|
     block = vm.pop
-    Thread.exclusive { block.call(vm, nil, nil) }
+    foorth_shared_mutex.synchronize { block.call(vm, nil, nil) }
   })
 
   # [a_mutex] .lock [] (Acquires a lock on the mutex)
@@ -29,3 +29,10 @@ module XfOOrth
   })
 
 end
+
+# Create a shared mutex instance.
+class Mutex
+  def self.foorth_shared_mutex
+    @foorth_shared_mutex ||= Mutex.new
+  end
+end