mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/string/words.rb

@@ -0,0 +1,173 @@
+require 'facets/string/fold'
+
+class String
+
+  module Words
+
+    # Returns an array of characters.
+    #
+    #   "abc 123".words  #=> ["abc","123"]
+
+    def words
+      self.split(/\s+/)
+    end
+
+    # Iterate through each word of a string.
+    #
+    #   "a string".each_word { |word, range| ... }
+
+    def each_word( &yld )
+      rest_of_string = self
+      wordfind = /([-'\w]+)/
+      arity = yld.arity
+      offset = 0
+      while wmatch = wordfind.match(rest_of_string)
+        word = wmatch[0]
+        range = offset+wmatch.begin(0) ... offset+wmatch.end(0)
+        rest_of_string = wmatch.post_match
+        if arity == 1
+          yld.call(word)
+        else
+          yld.call(word, range)
+        end
+        offset = self.length - rest_of_string.length
+      end
+    end
+
+    # Filters out words from a string based on block test.
+    #
+    #   "a string".word_filter { |word| word =~ /^a/ }  #=> "string"
+    #
+    #   CREDIT: George Moschovitis
+
+    def word_filter( &blk )
+      s = self.dup
+      s.word_filter!( &blk )
+    end
+
+    # In place version of #word_filter.
+    #
+    #   "a string".word_filter { |word| ... }
+    #
+    #   CREDIT: George Moschovitis
+
+    def word_filter! #:yield:
+      rest_of_string = self
+      wordfind = /(\w+)/
+      offset = 0
+      while wmatch = wordfind.match(rest_of_string)
+        word = wmatch[0]
+        range = offset+wmatch.begin(0) ... offset+wmatch.end(0)
+        rest_of_string = wmatch.post_match
+        self[range] = yield( word ).to_s
+        offset = self.length - rest_of_string.length
+      end
+      self
+    end
+
+    # TODO: This is alternateive from glue: worth providing?
+    #
+    # Enforces a maximum width of a string inside an
+    # html container. If the string exceeds this maximum width
+    # the string gets wraped.
+    #
+    # Not really useful, better use the CSS overflow: hidden
+    # functionality.
+    #
+    # === Input:
+    # the string to be wrapped
+    # the enforced width
+    # the separator used for wrapping
+    #
+    # === Output:
+    # the wrapped string
+    #
+    # === Example:
+    #  text = "1111111111111111111111111111111111111111111"
+    #  text = wrap(text, 10, " ")
+    #  p text # => "1111111111 1111111111 1111111111"
+    #
+    # See the test cases to better understand the behaviour!
+
+    #   def wrap(width = 20, separator = " ")
+    #     re = /([^#{separator}]{1,#{width}})/
+    #     scan(re).join(separator)
+    #   end
+
+    # Word wrap a string not exceeding max width.
+    #
+    #   puts "this is a test".word_wrap(4)
+    #
+    # _produces_
+    #
+    #   this
+    #   is a
+    #   test
+    #
+    #   CREDIT: Gavin Kistner
+    #   CREDIT: Dayne Broderson
+
+    def word_wrap( col_width=80 )
+      self.dup.word_wrap!( col_width )
+    end
+
+    # As with #word_wrap, but modifies the string in place.
+    #
+    #   CREDIT: Gavin Kistner
+    #   CREDIT: Dayne Broderson
+
+    def word_wrap!( col_width=80 )
+      self.gsub!( /(\S{#{col_width}})(?=\S)/, '\1 ' )
+      self.gsub!( /(.{1,#{col_width}})(?:\s+|$)/, "\\1\n" )
+      self
+    end
+
+    # old def
+
+    #def word_wrap(max=80)
+    #  c = dup
+    #  c.word_wrap!(max)
+    #  c
+    #end
+
+    #def word_wrap!(max=80)
+    #  raise ArgumentError, "Wrap margin too low: #{n}" if max <= 2
+    #  #gsub!( Regexp.new( "(.{1,#{max-1}}\\w)\\b\\s*" ), "\\1\n")
+    #  gsub!( /(.{1,#{max-1}}\S)([ ]|\n)/, "\\1\n")
+    #end
+
+    # Returns short abstract of long strings; not exceeding +range+
+    # characters. If range is an integer then the minimum is 20%
+    # of the maximum. The string is chopped at the nearest word
+    # if possible, and appended by +ellipsis+, which defaults
+    # to '...'.
+    #
+    #   CREDIT: George Moschovitis
+    #   CREDIT: Trans
+
+    def brief(range=76, ellipsis="...")
+      if Range===range
+        min = range.first
+        max = range.last
+      else
+        max = range
+        min = max - (max/5).to_i
+        range = min..max
+      end
+
+      if size > max
+        cut_at = rindex(/\b/, max) || max
+        cut_at = max if cut_at < min
+        xstring = slice(0, cut_at)
+        xstring.chomp(" ") + ellipsis
+      else
+        self
+      end
+    end
+
+  end
+
+  include Words
+
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/succ.rb

@@ -0,0 +1,44 @@
+class Integer
+
+  # Allows #succ to take _n_ increments.
+  #
+  #   3.succ(2)  #=> 5
+  #
+  #   CREDIT Trans
+
+  def succ(n=1)
+    self + n
+  end
+
+  # Provides #pred as the opposite of #succ.
+  #
+  #   3.pred(2)  #=> 1
+  #
+  #   CREDIT Trans
+
+  def pred(n=1)
+    self - n
+  end
+
+end
+
+class String
+
+  alias_method :succ1, :succ
+
+  # Allows #succ to take _n_ step increments.
+  #
+  #   "abc".succ      #=> "abd"
+  #   "abc".succ(4)   #=> "abg"
+  #   "abc".succ(24)  #=> "aca"
+  #
+  #  CREDIT Trans
+
+  def succ(n=1)
+    s = self
+    n.times { s = s.succ1 }
+    s
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/syncarray.rb

@@ -0,0 +1,114 @@
+# = SyncArray
+#
+# A thread-safe array. We use a sync object instead of a
+# mutex, because it is re-entrant. An exclusive lock is
+# needed when writing, a shared lock IS NEEDED when reading.
+#
+# == Authors
+#
+# * George Moschovitis
+#
+# == Copyright
+#
+# Copyright (c) 2004 George Moschovitis
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+require 'sync'
+
+# = SyncArray
+#
+# A thread-safe array. We use a sync object instead of a
+# mutex, because it is re-entrant. An exclusive lock is
+# needed when writing, a shared lock IS NEEDED when reading.
+#
+class Array
+
+  def self.mutable_methods
+    @mutable ||= %w{ << []= abbrev clear collect! compact! concat
+      delete delete_at delete_if fill flatten insert map! pop push
+      reject! replace reverse! shift slice! sort! transpose uniq!
+      unshift
+    }
+  end
+
+end
+
+class SyncArray < Array
+
+  attr :sync
+
+  #
+  # gmosx: delegator is not yet used.
+  #
+  def initialize(delegator = nil)
+    @sync = ::Sync.new()
+    super()
+  end
+
+  instance_methods.each do |m|
+    next if Object.instance_methods.include?(m)
+    if mutable_methods.include?(m)
+      sync_type = "Sync::EX"
+    else
+      sync_type = "Sync::SH"
+    end
+    class_eval %{
+      def #{m}(*args)
+        return @sync.synchronize(#{sync_type}) { super }
+      end
+    }
+  end
+
+#  def << (value)
+#    return @sync.synchronize(Sync::SH) { super }
+#  end
+#
+#  def delete_if(&block)
+#    return @sync.synchronize(Sync::SH) { super }
+#  end
+#
+#  def [](key)
+#    return @sync.synchronize(Sync::SH) { super }
+#  end
+#
+#  def []=(key, value)
+#    return @sync.synchronize(Sync::EX) { super }
+#  end
+#
+#  def delete(key)
+#    return @sync.synchronize(Sync::EX) { super }
+#  end
+#
+#  def clear
+#    @sync.synchronize(Sync::EX) { super }
+#  end
+#
+#  def size
+#    return @sync.synchronize(Sync::SH) { super }
+#  end
+#
+#  def shift
+#    return @sync.synchronize(::Sync::EX) { super }
+#  end
+#
+#  def unshift(el)
+#    return @sync.synchronize(::Sync::EX) { super }
+#  end
+
+end
+
+#--
+# Funniest thing, remove the :: in front of Sync.new in the initialize
+# routine and uncomment the alias line below and watch the stack blow chunks.
+# I'm leaving this comment here as a reminder.
+### Array::Sync = SyncArray
+#++
+

data/lib/gems/facets-2.4.5/lib/more/facets/synchash.rb

@@ -0,0 +1,157 @@
+# = SyncHash
+#
+# A thread-safe hash. We use a sync object instead of a mutex,
+# because it is re-entrant. An exclusive lock is needed when
+# writing, a shared lock IS NEEDED when reading.
+#
+# Uses the delegator pattern to allow for multiple
+# implementations!
+#
+#   hash = SyncHash.new
+#   hash = SyncHash.new(Hash.new)   # Delegates
+#
+# == Design
+#
+# This class uses the delegator pattern. However we don't use Ruby's
+# delegation facilities, they are more general and powerful than we
+# need here (and slower). Instead a custom (but simple) solution is
+# used.
+#
+# == Authors
+#
+# * George Moschovitis
+#
+# == Copyright
+#
+# Copyright (c) 2004 George Moschovitis
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+
+require 'sync'
+
+# = SyncHash
+#
+# A thread-safe hash. We use a sync object instead of a mutex,
+# because it is re-entrant. An exclusive lock is needed when
+# writing, a shared lock IS NEEDED when reading.
+#
+# Uses the delegator pattern to allow for multiple
+# implementations!
+#
+#   hash = SyncHash.new
+#   hash = SyncHash.new(Hash.new)   # Delegates
+#
+# == Design
+#
+# This class uses the delegator pattern. However we don't use Ruby's
+# delegation facilities, they are more general and powerful than we
+# need here (and slower). Instead a custom (but simple) solution is
+# used.
+#
+# == Usage
+#
+#   hash = SyncHash.new
+#   hash = SyncHash.new(Hash.new)   # Delegates
+#
+class SyncHash < Hash
+
+  attr :delegate, :sync
+
+  def initialize(delegate=nil)
+    @delegate = delegate
+    @sync = ::Sync.new
+    if delegate
+      self.extend Delegator
+    else
+      self.extend Inheritor
+    end
+  end
+
+  # Is this even advisable ?
+  #def replace(new_delegate)
+  #  self.extend Delegator unless @delegate
+  #  # or? raise 'not a delegating synchash' unless @delegate
+  #  @delegate = new_delegate
+  #end
+
+  # This module is used when a delegate is NOT being used.
+  module Inheritor
+
+    def [](key)
+      @sync.synchronize(::Sync::SH) { super }
+    end
+
+    def []=(key, value)
+      @sync.synchronize(::Sync::EX) { super }
+    end
+
+    def delete(key)
+      @sync.synchronize(::Sync::EX) { super }
+    end
+
+    def clear
+      @sync.synchronize(::Sync::EX) { super }
+    end
+
+    def size
+      @sync.synchronize(::Sync::SH) { super }
+    end
+
+    def values
+      @sync.synchronize(::Sync::SH) { super }
+    end
+
+    def keys
+      @sync.synchronize(::Sync::SH) { super }
+    end
+  end
+
+  # This module is used when a delegate is being used.
+  module Delegator
+
+    def [](key)
+      @sync.synchronize(::Sync::SH) { @delegate[key] }
+    end
+
+    def []=(key, value)
+      @sync.synchronize(::Sync::EX) { @delegate[key] = value }
+    end
+
+    def delete(key)
+      @sync.synchronize(::Sync::EX) { @delegate.delete(key) }
+    end
+
+    def clear
+      @sync.synchronize(::Sync::EX) { @delegate.clear }
+    end
+
+    def size
+      @sync.synchronize(::Sync::SH) { @delegate.size() }
+    end
+
+    def values
+      @sync.synchronize(::Sync::SH) { @delegate.values() }
+    end
+
+    def keys
+      @sync.synchronize(::Sync::SH) { @delegate.keys() }
+    end
+
+  end #module Delegator
+
+end #class SyncHash
+
+#--
+# Funniest thing, remove the :: in front of Sync.new in the initialize
+# routine and uncomment the alias line below and watch the stack blow chunks.
+# I'm leaving this comment here as a reminder.
+### Hash::Sync = SyncHash
+#++
+