facets 2.6.0 → 2.7.0

data/lib/more/facets/string/words.rb

@@ -1,167 +0,0 @@
-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, 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, 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 DEFINITION)
-    #
-    # 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, 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/more/facets/syncarray.rb

@@ -1,114 +0,0 @@
-# = 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/more/facets/synchash.rb

@@ -1,157 +0,0 @@
-# = 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
-#++
-

data/lib/more/facets/typecast.rb

@@ -1,261 +0,0 @@
-# = TypeCast
-#
-# Provides a generic simple type conversion utility. All the ruby core
-# conversions are available by default.
-#
-#   "1234".cast_to Float     => 1234.0  (Float)
-#   Time.cast_from("6:30")   => 1234.0   (Time)
-#
-# To implement a new type conversion, you have two choices, take:
-#
-#  class CustomType
-#    def initialize(my_var)
-#      @my_var = my_var
-#    end
-#  end
-#
-# Define a to_class_name instance method
-#
-#  class CustomType
-#    def to_string
-#      my_var.to_s
-#    end
-#  end
-#
-#  c = CustomType.new 1234
-#  s.cast_to String   =>  "1234" (String)
-#
-# Define a from_class_name class method
-#
-#  class CustomType
-#    def self.from_string(str)
-#      self.new(str)
-#    end
-#  end
-#
-#  "1234".cast_to CustomType  =>  #<CustomType:0xb7d1958c @my_var="1234">
-#
-# Those two methods are equivalent in the result. It was coded like that to
-# avoid the pollution of core classes with tons of to_* methods.
-#
-# The standard methods to_s, to_f, to_i, to_a and to_sym are also used by
-# this system if available.
-#
-# == Faq
-#
-# Q. Why didn't you name the `cast_to` method to `to` ?
-#
-# A. Even if it would make the syntax more friendly, I suspect it could cause
-# a lot of collisions with already existing code. The goal is that each
-# time you call cast_to, you either get your result, either a
-# TypeCastException
-#
-# == Authors
-#
-# * Jonas Pfenniger
-# 
-# == History
-#
-# * 2006-06-06 3v1l_d4y:
-#   * Removed transformation options.
-#   * Removed StringIO typecast. It is not required by default.
-#   * Added TypeCastException for better error reporting while coding.
-#
-# == Todo
-#
-# * Consider how this might fit in with method signitures, overloading,
-#   and expiremental euphoria-like type system.
-#
-# * Look to implement to_int, to_mailtext, to_r, to_rfc822text and to_str.
-#
-# == Copying
-#
-#   Copyright (c) 2004 Jonas Pfenniger
-#
-#   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 'time'
-require 'facets/string/methodize'
-require 'facets/string/camelcase' #modulize'
-
-# = Typecast
-#
-# Provides a generic simple type conversion utility. All the ruby core
-# conversions are available by default.
-#
-#   "1234".cast_to Float     => 1234.0  (Float)
-#   Time.cast_from("6:30")   => 1234.0   (Time)
-#
-# To implement a new type conversion, you have two choices, take:
-#
-#  class CustomType
-#    def initialize(my_var)
-#      @my_var = my_var
-#    end
-#  end
-#
-# Define a to_class_name instance method
-#
-#  class CustomType
-#    def to_string
-#      my_var.to_s
-#    end
-#  end
-#
-#  c = CustomType.new 1234
-#  s.cast_to String   =>  "1234" (String)
-#
-# Define a from_class_name class method
-#
-#  class CustomType
-#    def self.from_string(str)
-#      self.new(str)
-#    end
-#  end
-#
-#  "1234".cast_to CustomType  =>  #<CustomType:0xb7d1958c @my_var="1234">
-#
-# Those two methods are equivalent in the result. It was coded like that to
-# avoid the pollution of core classes with tons of to_* methods.
-#
-# The standard methods to_s, to_f, to_i, to_a and to_sym are also used by
-# this system if available.
-#
-# == Faq
-#
-# Q. Why didn't you name the `cast_to` method to `to` ?
-#
-# A. Even if it would make the syntax more friendly, I suspect it could cause
-# a lot of collisions with already existing code. The goal is that each
-# time you call cast_to, you either get your result, either a
-# TypeCastException
-#
-module TypeCast
-
-  # Typecast method extensions for Object class.
-
-  module Object
-    # Cast an object to another
-    #
-    #    1234.cast_to(String)  => "1234"
-    #
-    def cast_to(klass)
-      klass.cast_from(self)
-    end
-  end
-
-  # Typecast method extensions for Class class.
-
-  module Class
-    # Cast on object from another.
-    #
-    #   String.cast_from(1234) => "1234"
-    #
-    def cast_from(object)
-      method_to = "to_#{self.name.methodize}".to_sym
-      if object.respond_to? method_to
-        retval = object.send(method_to)
-        return retval
-      end
-      method_from = "from_#{object.class.name.methodize}".to_sym
-      if respond_to? method_from
-        retval = send(method_from, object)
-        return retval
-      end
-      raise TypeCastException, "TypeCasting from #{object.class.name} to #{self.name} not supported"
-    end
-  end
-
-end
-
-# TypeCast Exception error.
-#
-class TypeCastException < Exception; end
-
-class Object #:nodoc:
-  include TypeCast::Object
-end
-
-class Class #:nodoc:
-  include TypeCast::Class
-end
-
-class Array #:nodoc:
-  def self.cast_from(object)
-    return super
-  rescue TypeCastException
-    return object.to_a if object.respond_to? :to_a
-    raise
-  end
-end
-
-class Float #:nodoc:
-  def self.cast_from(object)
-    return super
-  rescue TypeCastException
-    return object.to_f if object.respond_to? :to_f
-    raise
-  end
-end
-
-class Integer #:nodoc:
-  def self.cast_from(object)
-    return super
-  rescue TypeCastException
-    return object.to_i if object.respond_to? :to_i
-    raise
-  end
-end
-
-class String #:nodoc:
-  def self.cast_from(object)
-    return super
-  rescue TypeCastException
-    return object.to_s if object.respond_to? :to_s
-    raise
-  end
-end
-
-class Symbol #:nodoc:
-  def self.cast_from(object)
-    return super
-  rescue TypeCastException
-    return object.to_sym if object.respond_to? :to_sym
-    raise
-  end
-end
-
-# Special Extensions
-
-class Class #:nodoc:
-  # "string".cast_to Class         #=> String
-  def self.from_string(string)
-    string = string.to_s.camelcase #modulize
-    base   = string.sub!(/^::/, '') ? Object : (self.kind_of?(Module) ? self : self.class )
-    klass  = string.split(/::/).inject(base){ |mod, name| mod.const_get(name) }
-    return klass if klass.kind_of? Class
-    nil
-  rescue
-    nil
-  end
-
-  class << self
-    alias_method :from_symbol, :from_string
-  end
-end
-
-class Time #:nodoc:
-  def self.from_string(string, options={})
-    parse(string)
-  rescue
-    nil
-  end
-end
-