qualitysmith_extensions 0.0.60 → 0.0.63

data/lib/qualitysmith_extensions/find/select.rb

@@ -0,0 +1,68 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# Changes::
+#++
+
+
+require 'find'
+require 'enumerator'
+
+module Find
+  # Identical to +find+ except +select+ returns the matching files as an _array_. (+find+ returns nil, which is not very useful if you actually wanted an array.)
+  #
+  # Calls the associated block with the name of every file and directory listed as arguments, then recursively on their subdirectories, and so on.
+  #
+  # Return a true (non-false) value from the block for every path that you want to be returned in the resulting array.
+  #
+  # You can still use <tt>Find.prune</tt>.
+  #
+  def self.select(*paths, &block)
+    Enumerable::Enumerator.new(self, :find, *paths).select{|value| yield value}
+  end
+end
+
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  # to do: would probably be safer if we *created* our own files/directories during setup, rather than expecting there to be some for us to use in cwd
+  
+  def test_true
+    dir = '.'
+    files_expected = []
+    Find.find(dir) { |path| files_expected << path }
+
+    files = Find.select(dir) { |path| true }
+    assert_equal files_expected, files
+
+    # Doesn't have to be true necessarily -- can be a string
+    files = Find.select(dir) { |path| path }
+    assert_equal files_expected, files
+  end
+
+  def test_false
+    dir = '.'
+    files = Find.select(dir) { |path| false }
+
+    assert_equal [], files
+  end
+
+end
+=end
+
+

data/lib/qualitysmith_extensions/kernel/autoreload.rb

@@ -0,0 +1,128 @@
+# CREDIT Michael Neumann
+# CREDIT George Moschovitis
+
+module Kernel
+
+  # Autoreload feature files.
+  #
+  # Automatically reload, at regular intervals, any previously loaded features,
+  # and/or other files not already loaded, if they have been modified since the last
+  # interval check. A numeric parameter sets the reload interval in seconds
+  # and the file parameter can either be a glob string or an array
+  # of file paths. If a glob string, it is expanded only once on the initial
+  # method call. Supplying a boolean parameter of 'false' will force autreload to
+  # skip previously loaded features and only reload the specified files.
+  # Also keeps a "dirty" flag.
+
+  def autoreload( *args )
+
+    check_interval=10
+    include_features = true
+    files = nil
+
+    args.each do |arg|
+      case arg
+      when Numeric
+        check_interval = arg
+      when String
+        files = Dir.glob( arg )
+      when Array
+        files = arg
+      when TrueClass, FalseClass
+        include_features = arg
+      end
+    end
+
+    file_mtime = {}
+
+    Thread.new(Time.now) do |start_time|
+      loop do
+        sleep check_interval
+
+        if include_features
+          feature_files = $LOADED_FEATURES.collect { |feature|
+            $LOAD_PATH.each { |lp| file = File.join(lp, feature) }
+          }.flatten
+          p feature_files
+
+          feature_files.each { |file|
+            if File.exists?(file) and (mtime = File.stat(file).mtime) > (file_mtime[file] || start_time)
+              $autoreload_dirty = true
+              file_mtime[file] = mtime
+              STDERR.puts "File '#{ file }' reloaded"
+              begin
+                load(file)
+              rescue Exception => e
+                STDERR.puts e.inspect
+              end
+            end
+          }
+        end
+
+        if files
+          files.each do |file|
+            if File.exists?(file) and (mtime = File.stat(file).mtime) > (file_mtime[file] || start_time)
+              $autoreload_dirty = true
+              file_mtime[file] = mtime
+              STDERR.puts "File '#{ file }' changed"
+              begin
+                load(file)
+              rescue Exception => e
+                STDERR.puts e.inspect
+              end
+            end
+          end
+        end
+
+      end
+    end
+
+  end
+
+
+  # Same as #autoreload, but does not include previously loaded features.
+  # This is equivalent to as adding a 'false' parameter to #autoreload.
+
+  def autoreload_files( *args )
+    autoreload( false, *args )
+  end
+
+  # deprecate
+  alias_method :autoreload_glob, :autoreload_files
+
+end
+
+#--
+#   # OLD VERSION
+#   def autoreload(check_interval=10)
+#     Thread.new(Time.now) { |start_time|
+#       file_mtime = {}
+#       loop {
+#         sleep check_interval
+#         $LOADED_FEATURES.each { |feature|
+#           $LOAD_PATH.each { |lp|
+#             file = File.join(lp, feature)
+#             if (File.exists?(file) and
+#               File.stat(file).mtime > (file_mtime[file] || start_time))
+#               file_mtime[file] = File.stat(file).mtime
+#               STDERR.puts "reload #{ file }"
+#               begin
+#                 load(file)
+#               rescue Exception => e
+#                 STDERR.puts e.inspect
+#               end
+#             end
+#           }
+#         }
+#       }
+#     }
+#   end
+#++
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+# TODO

data/lib/qualitysmith_extensions/kernel/example_printer.rb

@@ -19,10 +19,15 @@ require 'rubygems'
 # alternative is dirt simple, and it still works.
 module ExamplePrinter
   # Prints the given statement (+code+ -- a string) before evaluating it.
+  # Same as xmp only it doesn't print the return value.
+  #
+  #   o = nil
+  #   xmp 'o = C.new', binding
+  #   # => o = C.new
   def put_statement(code, binding = nil, file = __FILE__, line = __LINE__)
-    # This didn't work. Still got this error: undefined local variable or method `x' for #<TheTest:0xb7dbc358> (NameError)
+#    # This didn't work. Still got this error: undefined local variable or method `x' for #<TheTest:0xb7dbc358> (NameError)
 #    Binding.of_caller do |caller_binding|
-#      puts caller_binding
+#      #puts caller_binding
 #      puts code
 #      eval code, caller_binding
 #    end
@@ -31,6 +36,7 @@ module ExamplePrinter
   end
   alias_method :stp, :put_statement
 
+  # Prints the given statement (+code+ -- a string) before evaluating it. Then prints its return value.
   # Pretty much compatible with irb/xmp. But you have currently have to pass
   # in the binding manually if you have any local variables/methods that xmp
   # should have access to.

data/lib/qualitysmith_extensions/object/if_else.rb

@@ -0,0 +1,157 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?::
+# Developer notes::
+# Changes::
+#++
+
+
+
+class Object
+  # Returns +self+ if +condition+; otherwise, returns +else_value+.
+  #
+  # Example:
+  #   "Average: #{array.average}". if_else array.size >= 3, ''
+  # That is another way to say this:
+  #   array.size >= 3 ? "Average: #{array.average}" : '' )
+  #
+  # Sometimes you want to do 'something unless condition' and you want that whole expression to return '' (or some other value)
+  # if the condition is false, rather than nil, which is what it currently returns.
+  #
+  # *Important*: "+self+" will always be "evaluated". So if the receiver of this message is some _dangerous_ call (has side 
+  # effects), then you would be advised to use the normal if/then/else or ?/: constructs instead.
+  #
+  # For example, +method_with_adverse_side_effects+ will be called unconditionally in this case (whether or not +ready?+ returns +false+):
+  #   obj.method_with_adverse_side_effects.   if_else ready?, NotReady
+  # But it will not be called in this case if +ready?+ returns +false+:
+  #   ready? ? obj.method_with_adverse_side_effects : NotReady)
+  #
+  # "Isn't this method useless?" ... Yes, basically. Its main advantage is that it lets you put the condition _after_ the normal
+  # value, which may make it easier to follow the normal execution flow when reading the source.
+  #
+  # This is similar to something I saw in another language (Python?) where a similar syntax is built right into the language. Something like this:
+  #   normal_value if condition else else_value
+  #
+  # I thought that was a neat idea so I implemented it as best I could in Ruby.
+  #
+  # This might also be interesting for folks coming from Smalltalk, where +if+ really _is_ just a message that you pass to an
+  # object along with a block (?) to be executed if +condition+ is +true+ and a block to be executed if +condition+ is +false+.
+  #
+  def if(condition, else_value = nil)
+    condition ?
+      self :
+      else_value
+  end
+  alias_method :if_else, :if
+
+  def unless(condition, else_value)
+    !condition ?
+      self :
+      else_value
+  end
+  alias_method :unless_else, :unless
+end
+
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+require 'rubygems'
+require 'qualitysmith_extensions/array/average'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+    array = [1, 2]
+    assert_equal 'not enough values', average(array)
+    assert_equal 'not enough values', average_the_normal_way(array)
+
+    array = [1, 2, 3]
+    assert_equal 'average = 2.0', average(array)
+    assert_equal 'average = 2.0', average_the_normal_way(array)
+  end
+
+  # This way is actually easier to read, so you'd be pretty silly to use if_else in this case!
+  def average_the_normal_way(array)
+    array.size >= 3 ?
+      "average = #{array.average}" :
+      'not enough values'
+  end
+
+  def average(array)
+    "average = #{array.average}".if_else( array.size >= 3, 'not enough values' )
+  end
+
+
+
+
+
+  def test_2
+    # Sometimes you want to do 'something unless condition' and you want that whole expression to return '' (or some other value)
+    # if the condition is false, rather than nil, which is what it currently returns.
+    assert_equal nil, render_list_the_naive_way([])
+    assert_equal '',  render_list_the_long_way([])
+    assert_equal '',  render_list([])
+
+    list = ['Alice', 'Malory']
+
+    [
+      render_list_the_naive_way(list),
+      render_list_the_long_way(list),
+      render_list(list),
+    ].each {|a|
+      assert_equal '<ul><li>Alice</li><li>Malory</li></ul>', a
+    }
+
+  end
+
+  def render_list_the_naive_way(list)
+    content_tag(:ul,
+      list.map { |item|
+        content_tag(:li,
+          item
+        )
+      }
+    ) unless list.empty?
+  end
+  def render_list_the_long_way(list)
+    unless list.empty?
+      content_tag(:ul,
+        list.map { |item|
+          content_tag(:li,
+            item
+          )
+        }
+      )
+    else
+      ''
+    end
+  end
+  def render_list(list)
+    content_tag(:ul,
+      list.map { |item|
+        content_tag(:li,
+          item
+        )
+      }
+    ).   unless_else list.empty?, ''
+  end
+
+  def content_tag(tag, contents)
+    "<#{tag}>#{contents}</#{tag}>"
+  end
+end
+=end
+
+

data/lib/qualitysmith_extensions/object/send_if.rb

@@ -18,7 +18,13 @@ gem 'facets'
 require 'facets/core/kernel/with'       # returning
 
 class Object
-  # But only sends +message+ to +self+ if +condition+ is met.
+  # Sends +message+ to +self+ (including +block_to_always_execute+ if supplied) if +condition+ is met. If +condition+ is _not_ met,
+  # +block_to_always_execute+ will still be called (if supplied), but we will _not_ pass the message. (If +condition+ is not met
+  # and +block_to_always_execute+ is not supplied, it will simply return +self+.)
+  #
+  # In summary:
+  # * +block+: _always_ executed
+  # * +message+: only sent if +condition+
   #
   # If a block (+block_to_always_execute+) is supplied, it is passed on to the message if the condition is met; (otherwise it is
   # simply called without sending the message).

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: qualitysmith_extensions
 version: !ruby/object:Gem::Version 
-  version: 0.0.60
-date: 2007-06-05 00:00:00 -07:00
+  version: 0.0.63
+date: 2007-07-17 00:00:00 -07:00
 summary: A collection of reusable Ruby methods developed by QualitySmith.
 require_paths: 
 - lib
@@ -44,6 +44,7 @@ files:
 - lib/qualitysmith_extensions/exception/inspect_with_backtrace.rb
 - lib/qualitysmith_extensions/colored/toggleability.rb
 - lib/qualitysmith_extensions/file_test/binary_file.rb
+- lib/qualitysmith_extensions/kernel/autoreload.rb
 - lib/qualitysmith_extensions/kernel/require_all.rb
 - lib/qualitysmith_extensions/kernel/simulate_input.rb
 - lib/qualitysmith_extensions/kernel/die.rb
@@ -66,6 +67,7 @@ files:
 - lib/qualitysmith_extensions/object/methods.rb
 - lib/qualitysmith_extensions/object/default.rb
 - lib/qualitysmith_extensions/object/send_if.rb
+- lib/qualitysmith_extensions/object/if_else.rb
 - lib/qualitysmith_extensions/file/exact_match_regexp.rb
 - lib/qualitysmith_extensions/date/iso8601.rb
 - lib/qualitysmith_extensions/date/deprecated.rb
@@ -74,6 +76,7 @@ files:
 - lib/qualitysmith_extensions/time/deprecated.rb
 - lib/qualitysmith_extensions/time/all.rb
 - lib/qualitysmith_extensions/regexp/join.rb
+- lib/qualitysmith_extensions/find/select.rb
 - lib/qualitysmith_extensions/mutex/if_available.rb
 - lib/qualitysmith_extensions/console/command.rb
 - lib/qualitysmith_extensions/console/command.facets.1.8.54.rb