mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/core/facets/string/word_wrap.rb

@@ -0,0 +1,34 @@
+class String
+
+  # Word wrap a string not exceeding max width.
+  #
+  #   puts "this is a test".word_wrap(4)
+  #
+  # _produces_
+  #
+  #   this
+  #   is a
+  #   test
+  #
+  # This is basic implementation of word wrap, but smart
+  # enough to suffice for most use cases.
+  #
+  #  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
+
+end

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

@@ -0,0 +1,12 @@
+class String
+
+  # Returns an array of characters.
+  #
+  #   "abc 123".words  #=> ["abc","123"]
+  #
+  def words
+    self.split(/\s+/)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/string/xor.rb

@@ -0,0 +1,22 @@
+class String
+
+  # XOR two string.
+  #
+  # TODO: This is used by crypt.rb, it needs to be documented.
+
+  def ^(aString)
+    a = self.unpack('C'*(self.length))
+    b = aString.unpack('C'*(aString.length))
+    if (b.length < a.length)
+      (a.length - b.length).times { b << 0 }
+    end
+    xor = ""
+    0.upto(a.length-1) { |pos|
+      x = a[pos] ^ b[pos]
+      xor << x.chr()
+    }
+    return(xor)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/symbol.rb

@@ -0,0 +1,6 @@
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/symbol/chomp.rb

@@ -0,0 +1,24 @@
+class Symbol
+
+  # Just like String#chomp.
+  #
+  #   :ab.chomp(:b)  #=> :a
+  #
+  #   CREDIT: Trans
+
+  def chomp(seperator)
+    to_s.chomp(seperator.to_s).to_sym
+  end
+
+  # Just like String#lchomp.
+  #
+  #   :ab.lchomp(:a)  #=> :b
+  #
+  #   CREDIT: Trans
+
+  def lchomp(seperator)
+    to_s.reverse.chomp(seperator.to_s).reverse.to_sym
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/symbol/generate.rb

@@ -0,0 +1,24 @@
+class Symbol
+
+  # Generate a unique symbol.
+  #
+  #   Symbol.generate => :-1
+  #
+  # If +key+ is given the new symbol will be prefixed with it.
+  #
+  #   Symbol.generate(:foo) => :foo-1
+  #
+  #   TODO: Is the generated symbol format acceptable?
+  #
+  #  CREDIT: Trans
+
+  def self.generate(key=nil)
+    key = key.to_sym if key
+    @symbol_generate_counter ||= {}
+    @symbol_generate_counter[key] ||= 0
+    num = @symbol_generate_counter[key] += 1
+    ("#{key}-%X" % num).to_sym
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/symbol/not.rb

@@ -0,0 +1,29 @@
+class Symbol
+
+  # Does a symbol have a "not" sign?
+  #
+  #   "friend".to_sym.not?   #=> false
+  #   "~friend".to_sym.not?  #=> true
+  #
+  #  CREDIT: Trans
+
+  def not?
+    self.to_s.slice(0,1) == '~'
+  end
+
+  # Add a "not" sign to the front of a symbol.
+  #
+  #   ~:friend    #=> :"~friend"
+  #
+  #  CREDIT: Trans
+
+  def ~@
+    if self.to_s.slice(0,1) == '~'
+      "#{self.to_s[1..-1]}".to_sym
+    else
+      "~#{self}".to_sym
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/symbol/plain.rb

@@ -0,0 +1,17 @@
+class Symbol
+
+  def plain?
+    c = to_s[-1,1]
+    !(c == '=' || c == '?')
+  end
+
+  def setter?
+    to_s[-1,1] == '='
+  end
+
+  def query?
+    to_s[-1,1] == '?'
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/symbol/query.rb

@@ -0,0 +1 @@
+require 'facets/symbol/plain'

data/lib/gems/facets-2.4.5/lib/core/facets/symbol/re_s.rb

@@ -0,0 +1,18 @@
+require 'facets/functor'
+
+class Symbol
+
+  # Convert symbol to string, apply string method
+  # and convert back to symbol via a fluent
+  # interface.
+  #
+  #   :HELLO.re_s.downcase
+  #
+  def re_s
+    @re_s ||= Functor.new do |op, *a|
+      to_s.send(op, *a).to_sym
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/symbol/setter.rb

@@ -0,0 +1 @@
+require 'facets/symbol/plain'

data/lib/gems/facets-2.4.5/lib/core/facets/symbol/succ.rb

@@ -0,0 +1,19 @@
+unless (RUBY_VERSION[0,3] == '1.9')
+
+  class Symbol
+
+    # Successor method for symobol. This simply converts
+    # the symbol to a string uses String#succ and then
+    # converts it back to a symbol.
+    #
+    #   :a.succ => :b
+    #
+    #  TODO: Make this  work more like a simple character dial?
+
+    def succ
+      self.to_s.succ.intern
+    end
+
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/symbol/to_proc.rb

@@ -0,0 +1,38 @@
+unless (RUBY_VERSION[0,3] == '1.9')
+
+  class Symbol
+
+    # Turn a symbol into a proc calling the method to
+    # which it refers.
+    #
+    #   up = :upcase.to_proc
+    #   up.call("hello")  #=> HELLO
+    #
+    # More useful is the fact that this allows <tt>&</tt>
+    # to be used to coerce Symbol into Proc.
+    #
+    #   %w{foo bar qux}.map(&:upcase)   #=> ["FOO","BAR","QUX"]
+    #   [1, 2, 3].inject(&:+)           #=> 6
+    #
+    # And other conveniences such as:
+    #
+    #   %{john terry fiona}.map(&:capitalize)   # -> %{John Terry Fiona}
+    #   sum = numbers.inject(&:+)
+    #
+    #   TODO: This will be deprecated as of Ruby 1.9, since it will become standard Ruby.
+    #
+    # CREDIT: Florian Gross (orignal)
+    # CREDIT: Nobuhiro Imai (current)
+
+    def to_proc
+      Proc.new{|*args| args.shift.__send__(self, *args)}
+    end
+
+    # OLD DEFINITION
+    #def to_proc
+    #  proc { |obj, *args| obj.send(self, *args) }
+    #end
+
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/symbol/variablize.rb

@@ -0,0 +1,12 @@
+class Symbol
+
+  # Prepend an "@" to the beginning of a symbol
+  # to make a instance variable name. This also replaces
+  # non-valid characters with underscores.
+
+  def variablize
+    "@#{self}".gsub(/\W/, '_').to_sym
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/time.rb

@@ -0,0 +1,6 @@
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/time/advance.rb

@@ -0,0 +1,17 @@
+class Time
+
+  # Uses Date to provide precise Time calculations for years, months, and days.
+  # The +options+ parameter takes a hash with any of these keys: <tt>:years</tt>,
+  # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
+  # <tt>:minutes</tt>, <tt>:seconds</tt>.
+  #
+  #   CREDIT: ActiveSupport
+  def advance(options)
+    d = to_date.advance(options)
+    time_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
+    seconds_to_advance = (options[:seconds] || 0) + (options[:minutes] || 0) * 60 + (options[:hours] || 0) * 3600
+    seconds_to_advance == 0 ? time_advanced_by_date : time_advanced_by_date.since(seconds_to_advance)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/time/ago.rb

@@ -0,0 +1 @@
+require 'facets/time/hence'

data/lib/gems/facets-2.4.5/lib/core/facets/time/change.rb

@@ -0,0 +1,41 @@
+class Time
+
+  # Returns a new Time where one or more of the elements
+  # have been changed according to the +options+ parameter.
+  # The time options (hour, minute, sec, usec) reset
+  # cascadingly, so if only the hour is passed, then
+  # minute, sec, and usec is set to 0. If the hour and
+  # minute is passed, then sec and usec is set to 0.
+  #
+  #  t = Time.now            #=> Sat Dec 01 14:10:15 -0500 2007
+  #  t.change(:hour => 11)   #=> Sat Dec 01 11:00:00 -0500 2007
+  #
+  def change(options)
+    opts=options; #{}; options.each_pair{ |k,v| opts[k] = v.to_i }
+    self.class.send(
+      self.utc? ? :utc : :local,
+      opts[:year]  || self.year,
+      opts[:month] || self.month,
+      opts[:day]   || self.day,
+      opts[:hour]  || self.hour,
+      opts[:min]   || (opts[:hour] ? 0 : self.min),
+      opts[:sec]   || ((opts[:hour] || opts[:min]) ? 0 : self.sec),
+      opts[:usec]  || ((opts[:hour] || opts[:min] || opts[:sec]) ? 0 : self.usec)
+    )
+  end
+
+  #def change(options)
+  #  ::Time.send(
+  #    self.utc? ? :utc_time : :local_time,
+  #    options[:year]  || self.year,
+  #    options[:month] || self.month,
+  #    options[:day]   || self.day,
+  #    options[:hour]  || self.hour,
+  #    options[:min]   || (options[:hour] ? 0 : self.min),
+  #    options[:sec]   || ((options[:hour] || options[:min]) ? 0 : self.sec),
+  #    options[:usec]  || ((options[:hour] || options[:min] || options[:sec]) ? 0 : self.usec)
+  #  )
+  #end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/time/elapse.rb

@@ -0,0 +1,16 @@
+class Time
+
+  # Tracks the elapse time of a code block.
+  #
+  #   Time.elapse { sleep 1 }  #=> 0.999188899993896
+  #
+  #   CREDIT: Hal Fulton
+
+  def self.elapse
+    raise "Need block" unless block_given?
+    t0 = now.to_f
+    yield
+    now.to_f - t0
+  end
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/time/hence.rb

@@ -0,0 +1,94 @@
+require 'facets/time/set'
+
+class Time
+
+  if defined?(::ActiveSupport)
+
+    alias_method :in, :since
+    alias_method :hence, :since
+
+  else
+
+    # Returns a new Time representing the time
+    # a number of time-units ago.
+    #
+    def ago(number, units=:seconds)
+      time =(
+        case units.to_s.downcase.to_sym
+        when :years
+          set(:year => (year - number))
+        when :months
+          #years = ((month - number) / 12).to_i
+          y = ((month - number) / 12).to_i
+          m = ((month - number - 1) % 12) + 1
+          set(:year => (year - y), :month => m)
+        when :weeks
+          self - (number * 604800)
+        when :days
+          self - (number * 86400)
+        when :hours
+          self - (number * 3600)
+        when :minutes
+          self - (number * 60)
+        when :seconds, nil
+          self - number
+        else
+          raise ArgumentError, "unrecognized time units -- #{units}"
+        end
+      )
+      dst_adjustment(time)
+    end
+    #
+    # Returns a new Time representing the time
+    # a number of time-units hence.
+
+    def hence(number, units=:seconds)
+      time =(
+        case units.to_s.downcase.to_sym
+        when :years
+          set( :year=>(year + number) )
+        when :months
+          y = ((month + number) / 12).to_i
+          m = ((month + number - 1) % 12) + 1
+          set(:year => (year + y), :month => m)
+        when :weeks
+          self + (number * 604800)
+        when :days
+          self + (number * 86400)
+        when :hours
+          self + (number * 3600)
+        when :minutes
+          self + (number * 60)
+        when :seconds
+          self + number
+        else
+          raise ArgumentError, "unrecognized time units -- #{units}"
+        end
+      )
+      dst_adjustment(time)
+    end
+
+    alias_method :in, :hence
+    alias_method :since, :hence
+
+    # Adjust DST
+    #
+    # TODO: Can't seem to get this to pass ActiveSupport tests.
+    #       Even though it is essentially identical to the
+    #       ActiveSupport code (see Time#since in time/calculations.rb).
+    #       It handels all but 4 tests.
+    def dst_adjustment(time)
+      self_dst = self.dst? ? 1 : 0
+      time_dst = time.dst? ? 1 : 0
+      seconds  = (self - time).abs
+      if (seconds >= 86400 && self_dst != time_dst)
+        time + ((self_dst - time_dst) * 60 * 60)
+      else
+        time
+      end
+    end
+
+  end
+
+end
+