facets-glimmer 3.2.0

data/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/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/core/facets/symbol/op_div.rb

@@ -0,0 +1,21 @@
+require 'facets/string/op_div'
+
+class Symbol
+
+  # Join with _path_ as a file path.
+  #
+  # * path - The path component(s) to append. [#to_s]
+  #
+  # Examples
+  #
+  #   (:merb / "string")   #=> "merb/string"
+  #   (:merb / :symbol)    #=> "merb/symbol"
+  #
+  # Returns String of the receiver (as a path string), concatenated
+  # with _path_.
+  def /(path)
+    File.join(to_s, path.to_s)
+  end
+
+end
+

data/lib/core/facets/symbol/plain.rb

@@ -0,0 +1,51 @@
+class Symbol
+
+  # Symbol does not end in `!`, `=`, or `?`.
+  #
+  #   :a.plain?   #=> true
+  #   :a?.plain?  #=> false
+  #   :a!.plain?  #=> false
+  #   :a=.plain?  #=> false
+  #
+  def plain?
+    c = to_s[-1,1]
+    !(c == '=' || c == '?' || c == '!')
+  end
+
+  # Alias for `#plain?` method. Likely this should have been the original
+  # and only name, but such is life.
+  alias_method :reader?, :plain?
+
+  # Symbol ends in `=`.
+  #
+  #   :a=.setter? #=> true
+  #   :a.setter?  #=> false
+  #
+  def setter?
+    to_s[-1,1] == '='
+  end
+
+  # Alias for `#setter?` method. Likely this should have been the original
+  # and only name, but such is life.
+  alias_method :writer?, :setter?
+
+  # Symbol ends in `?`.
+  #
+  #   :a?.query? #=> true
+  #   :a.query?  #=> false
+  #
+  def query?
+    to_s[-1,1] == '?'
+  end
+
+  # Symbol ends in `!`.
+  #
+  #   :a!.bang? #=> true
+  #   :a.bang?  #=> false
+  #
+  def bang?
+    to_s[-1,1] == '!'
+  end
+
+end
+

data/lib/core/facets/symbol/query.rb

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

data/lib/core/facets/symbol/reader.rb

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

data/lib/core/facets/symbol/setter.rb

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

data/lib/core/facets/symbol/succ.rb

@@ -0,0 +1,23 @@
+class Symbol
+
+  unless method_defined?(:succ)  # 1.9+ TODO: is this right?
+
+    # 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(n=1)
+      s = self.to_s
+      n.times do
+        s = s.succ
+      end
+      s.to_sym
+    end
+
+  end
+
+end

data/lib/core/facets/symbol/thrown.rb

@@ -0,0 +1,22 @@
+class Symbol
+
+  # Returns truew if the given block throws the symbol, otherwise false.
+  # Note that +throw+ inside the block must be used in one-argument form.
+  #
+  # @return [true,false]
+  def thrown?
+    thrown = true
+    catch(self) do
+      begin
+        yield
+        thrown = false
+      rescue ArgumentError => err     # 1.9 exception
+        thrown = false if err.message.index('uncaught throw')
+      rescue NameError => err         # 1.8 exception
+        thrown = false if err.message.index('uncaught throw')
+      end
+    end
+    thrown
+  end
+
+end

data/lib/core/facets/symbol/variablize.rb

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

data/lib/core/facets/symbol/writer.rb

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

data/lib/core/facets/symbol.rb

@@ -0,0 +1,14 @@
+require_relative 'symbol/as_s.rb'
+require_relative 'symbol/bang.rb'
+require_relative 'symbol/call.rb'
+require_relative 'symbol/chomp.rb'
+require_relative 'symbol/generate.rb'
+require_relative 'symbol/not.rb'
+require_relative 'symbol/op_div.rb'
+require_relative 'symbol/plain.rb'
+require_relative 'symbol/query.rb'
+require_relative 'symbol/setter.rb'
+require_relative 'symbol/succ.rb'
+require_relative 'symbol/thrown.rb'
+require_relative 'symbol/variablize.rb'
+

data/lib/core/facets/time/ago.rb

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

data/lib/core/facets/time/change.rb

@@ -0,0 +1,46 @@
+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.
+  #
+  #   t1 = Time.at(10000)
+  #   t1.ctime   #=> "Wed Dec 31 21:46:40 1969"
+  #
+  #   t2 = t1.change(:hour => 11)
+  #   t2.ctime   #=> "Wed Dec 31 11:00:00 1969"
+  #
+  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
+
+  # Old Version ...
+  #
+  #   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/core/facets/time/dst_adjustment.rb

@@ -0,0 +1,24 @@
+class Time
+
+  unless method_defined?(:dst_adjustment)
+
+    # 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 handles
+    # 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

data/lib/core/facets/time/elapse.rb

@@ -0,0 +1,18 @@
+class Time
+
+  # Tracks the elapse time of a code block.
+  #
+  #   e = Time.elapse { sleep 1 }
+  #
+  #   e.assert > 1
+  #
+  # 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/core/facets/time/future.rb

@@ -0,0 +1,16 @@
+class Time
+
+  def self.current
+    now
+  end
+
+  def past?(other=nil)
+    self < (other || self.class.current)
+  end
+
+  def future?(other=nil)
+    self > (other || self.class.current)
+  end
+
+end
+

data/lib/core/facets/time/hence.rb

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

data/lib/core/facets/time/in.rb

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

data/lib/core/facets/time/less.rb

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

data/lib/core/facets/time/past.rb

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

data/lib/core/facets/time/round_to.rb

@@ -0,0 +1,21 @@
+require 'facets/time/trunc'
+
+class Time
+
+  # Round time at the nearest range (in seconds).
+  #
+  #   t1 = Time.now
+  #   t2 = t1.round_to(60*60)
+  #   t2.min #=> 0
+  #   t2.sec #=> 0
+  #
+  # TODO: What about `round(:minute)`?
+  #
+  # TODO: Fractional seconds should round the usec.
+  #
+  def round_to(seconds)
+    (self + seconds / 2.0).trunc(seconds)
+  end
+
+end
+

data/lib/core/facets/time/set.rb

@@ -0,0 +1,27 @@
+class Time
+
+  # Like change but does not reset earlier times.
+  #
+  # NOTE: It would be better, probably if this were called "change".
+  # and that #change were called "reset".
+  #
+  def set(options)
+    opts={}
+    options.each_pair do |k,v| 
+      k = :min if k.to_s =~ /^min/
+      k = :sec if k.to_s =~ /^sec/
+      opts[k] = v.to_i 
+    end
+    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]   || self.min,
+      opts[:sec]   || self.sec,
+      opts[:usec]  || self.usec
+    )
+  end
+
+end

data/lib/core/facets/time/shift.rb

@@ -0,0 +1,97 @@
+require 'facets/time/set'
+require 'facets/time/dst_adjustment'
+
+class Time
+
+  # TODO: Deprecate use of #dst-adjustment in Time#shift ?
+
+  # Returns a new Time representing the time shifted by the time-units given.
+  # Positive number shift the time forward, negative number shift the time 
+  # backward.
+  #
+  #   t = Time.utc(2010,10,10,0,0,0)
+  #   t.shift( 4, :days)            #=>  Time.utc(2010,10,14,0,0,0)
+  #   t.shift(-4, :days)            #=>  Time.utc(2010,10,6,0,0,0)
+  #
+  # More than one unit of time can be given.
+  #
+  #   t.shift(4, :days, 3, :hours)  #=>  Time.utc(2010,10,14,3,0,0)
+  #
+  # The #shift method can also take a hash.
+  #
+  #   t.shift(:days=>4, :hours=>3)  #=>  Time.utc(2010,10,14,3,0,0)
+  #
+  def shift(*time_units)
+    time_hash = Hash===time_units.last ? time_units.pop : {}
+    time_units = time_units.flatten
+    time_units << :seconds if time_units.size % 2 == 1
+    time_hash.each{ |units, number| time_units << number; time_units << units }
+
+    time = self
+    time_units.each_slice(2) do |number, units|
+      #next time = time.ago(-number, units) if number < 0
+      time = (
+        case units.to_s.downcase.to_sym
+        when :years, :year
+          time.set( :year=>(year + number) )
+        when :months, :month
+          if number > 0
+            new_month = ((month + number - 1) % 12) + 1
+            y = (number / 12) + (new_month < month ? 1 : 0)
+            time.set(:year => (year + y), :month => new_month)
+          else
+            number = -number
+            new_month = ((month - number - 1) % 12) + 1
+            y = (number / 12) + (new_month > month ? 1 : 0)
+            time.set(:year => (year - y), :month => new_month)
+          end
+        when :weeks, :week
+          time + (number * 604800)
+        when :days, :day
+          time + (number * 86400)
+        when :hours, :hour
+          time + (number * 3600)
+        when :minutes, :minute, :mins, :min
+          time + (number * 60)
+        when :seconds, :second, :secs, :sec, nil
+          time + number
+        else
+          raise ArgumentError, "unrecognized time units -- #{units}"
+        end
+      )
+    end
+    dst_adjustment(time)
+  end
+
+  # Alias for #shift.
+  alias_method :in, :shift
+
+  # Alias for #shift.
+  alias_method :hence, :shift unless method_defined?(:hence)
+
+  # Returns a new Time representing the time a number of time-units ago.
+  # This is just like #shift, but reverses the direction.
+  #
+  #   t = Time.utc(2010,10,10,0,0,0)
+  #
+  #   t.less(4, :days)             #=>  Time.utc(2010,10,6,0,0,0)
+  #
+  def less(*time_units)
+    time_hash  = Hash===time_units.last ? time_units.pop : {}
+    time_units = time_units.flatten
+
+    time_units << :seconds if time_units.size % 2 == 1
+
+    time_hash.each{ |units, number| time_units << number; time_units << units }
+
+    neg_times = []
+    time_units.each_slice(2){ |number, units| neg_times << -number; neg_times << units }
+
+    shift(*neg_times)
+  end
+
+  # Alias for #less
+  alias_method :ago, :less unless method_defined?(:ago)
+
+end
+

data/lib/core/facets/time/stamp.rb

@@ -0,0 +1,47 @@
+class Time
+
+  # TODO: Time::Formats need improvement!
+  unless const_defined?('FORMAT')
+    FORMAT = {
+      :utc      => "%Y-%m-%d %H:%M:%S",
+      :utcT     => "%Y-%m-%dT%H:%M:%S",
+      :db       => "%Y-%m-%d %H:%M:%S",
+      :database => "%Y-%m-%d %H:%M:%S",
+      :number   => "%Y%m%d%H%M%S",
+      :short    => "%d %b %H:%M",
+      :time     => "%H:%M",
+      :long     => "%B %d, %Y %H:%M",
+      :day1st   => "%d-%m-%Y %H:%M",
+      :dmYHM    => "%d-%m-%Y %H:%M",
+      :rfc822   => "%a, %d %b %Y %H:%M:%S %z",
+      :ruby18   => "%a %b %d %H:%M:%S %z %Y",
+      nil       => "%Y-%m-%d %H:%M:%S %z"
+    }
+  end
+
+  # Produce time stamp for Time.now. See #stamp.
+  #
+  # CREDIT: Trans
+
+  def self.stamp(*args)
+    now.stamp(*args)
+  end
+
+  # Create a time stamp.
+  #
+  #   t = Time.at(10000)
+  #   t.stamp(:short)    #=> "31 Dec 21:46"
+  #
+  # Supported formats come from the Time::FORMAT constant.
+  #
+  # CREDIT: Trans
+
+  def stamp(fmt = nil)
+    unless String === fmt
+      fmt = FORMAT[fmt]
+    end
+    strftime(fmt).strip
+  end
+
+end
+

data/lib/core/facets/time/to_time.rb

@@ -0,0 +1,21 @@
+class Time
+
+  unless method_defined?(:to_time) # 1.9
+
+    # To be able to keep Dates and Times interchangeable
+    # on conversions.
+
+    def to_time
+      getlocal 
+    end
+
+    # A method to keep Time, Date and DateTime instances interchangeable
+    # on conversions. In this case, it simply returns +self+.
+    #def to_time
+    #  self
+    #end
+
+  end
+
+end
+

data/lib/core/facets/time/trunc.rb

@@ -0,0 +1,15 @@
+class Time
+
+  # Truncate time at give range (in seconds).
+  #
+  #   t = Time.now
+  #   t = t.trunc(60*60)
+  #   t.min #=> 0
+  #   t.sec #=> 0
+  #
+  def trunc(amount)
+    self - (self.to_i % amount)
+  end
+
+end
+

data/lib/core/facets/time.rb

@@ -0,0 +1,16 @@
+require_relative 'time/ago.rb'
+require_relative 'time/change.rb'
+require_relative 'time/dst_adjustment.rb'
+require_relative 'time/elapse.rb'
+require_relative 'time/future.rb'
+require_relative 'time/hence.rb'
+require_relative 'time/in.rb'
+require_relative 'time/less.rb'
+require_relative 'time/past.rb'
+require_relative 'time/round_to.rb'
+require_relative 'time/set.rb'
+require_relative 'time/shift.rb'
+require_relative 'time/stamp.rb'
+require_relative 'time/to_time.rb'
+require_relative 'time/trunc.rb'
+

data/lib/core/facets/unboundmethod/arguments.rb

@@ -0,0 +1,44 @@
+class UnboundMethod
+
+  # Resolves the arguments of the method to have an
+  # identical signiture --useful for preserving arity.
+  #
+  #   class X
+  #     def foo(a, b); end
+  #     def bar(a, b=1); end
+  #   end
+  #
+  #   foo_method = X.instance_method(:foo)
+  #   foo_method.arguments   #=> "a0, a1"
+  #
+  #   bar_method = X.instance_method(:bar)
+  #   bar_method.arguments   #=> "a0, *args"
+  #
+  # When defaults are used the arguments must end in "*args".
+  #
+  # CREDIT: Trans
+
+  def arguments
+    ar = arity
+    case ar <=> 0
+    when 1
+      args = []
+      ar.times do |i|
+        args << "a#{i}"
+      end
+      args = args.join(", ")
+    when 0
+      args = ""
+    else
+      ar = -ar - 1
+      args = []
+      ar.times do |i|
+        args << "a#{i}"
+      end
+      args << "*args"
+      args = args.join(", ")
+    end
+    return args
+  end
+
+end

data/lib/core/facets/unboundmethod.rb

@@ -0,0 +1,2 @@
+require_relative 'unboundmethod/arguments.rb'
+

data/lib/core/facets/version.rb

@@ -0,0 +1,18 @@
+module Facets
+  #
+  def self.index
+    @index ||= (
+      require 'yaml'
+      YAML.load(File.new(File.dirname(__FILE__) + '/facets.yml'))
+    )
+  end
+
+  #
+  def self.const_missing(name)
+    key = name.to_s.downcase
+    index[key] || super(name)
+  end
+
+  # deprecate
+  VERSION = '3.2.0'
+end