volt 0.9.6 → 0.9.7.pre2

data/lib/volt/helpers/time/distance.rb

@@ -0,0 +1,63 @@
+module Volt
+  class Duration
+    UNIT_MAP = {
+      :years => 31536000,
+      :months => 2592000,
+      :weeks => 604800,
+      :days => 86400,
+      :hours => 3600,
+      :minutes => 60,
+      :seconds => 1
+    }
+
+    # Returns a string representation of the duration.
+    #
+    # @param How many places in time units to show.
+    # @param The minimum unit to show, anything below will be ignored.  Results
+    #        will be rounded up the the nearest min_unit.
+    def duration_in_words(places=2, min_unit=:minutes, recent_message='just now')
+      parts = []
+      secs = to_i
+      UNIT_MAP.each_pair do |unit, count|
+        val = (secs / count).floor
+        secs = secs % count
+
+        parts << [val, unit] if val > 0
+        break if unit == min_unit
+      end
+
+      # Trim number of units
+      parts = parts.take(places) if places
+
+      parts = parts.map do |val, unit|
+        pl_units = val == 1 ? unit.singularize : unit
+        "#{val} #{pl_units}"
+      end
+
+      # Round up to the nearest unit
+      if parts.size == 0
+        parts << recent_message
+      end
+
+      parts.to_sentence
+    end
+  end
+end
+
+class VoltTime
+  def time_distance_in_words(from_time=VoltTime.live_now(60), places=2, min_unit=:minutes, recent_message='just now')
+    dist = from_time - self
+
+    direction = dist >= 0 ? 'ago' : 'from now'
+
+    duration = dist.abs.seconds
+
+    dist_in_words = duration.duration_in_words(places, min_unit, recent_message)
+
+    unless dist_in_words == recent_message
+      dist_in_words += ' ' + direction
+    end
+
+    dist_in_words
+  end
+end

data/lib/volt/helpers/time/duration.rb

@@ -0,0 +1,71 @@
+# Much of this class was borrowed from ActiveSupport:
+# https://github.com/rails/rails/blob/master/activesupport/lib/active_support/duration.rb
+
+module Volt
+  class Duration
+    attr_accessor :value, :parts
+
+    def initialize(value, parts)
+      @value, @parts = value, parts
+    end
+
+    # Compares with the value on another Duration if Duration is passed
+    # or just compares value with the other object
+    def ==(other)
+      if other.is_a?(Volt::Duration)
+        other.value == value
+      else
+        other == value
+      end
+    end
+
+    # Adds durations or duration to a VoltTime or seconds to the duration
+    def +(other)
+      if other.is_a?(Volt::Duration)
+        Volt::Duration.new(value + other.value, parts + other.parts)
+      else
+        Volt::Duration.new(value + other, parts + [[:seconds, other]])
+      end
+    end
+
+    # Calculates a new Time which is the Duration in the future.
+    # The default is since the current time
+    def since(time = VoltTime.now)
+      sum(1, time)
+    end
+    alias :from_now :since
+
+    # Calculates a new Time which is the Duration in the past
+    # The default is since the current time
+    def ago(time = VoltTime.now)
+      sum(-1, time)
+    end
+    alias :until :ago
+
+    # Ensure that the Duration responds like the value to other methods
+    def respond_to_missing?(method, include_private=false)
+      @value.respond_to?(method, include_private)
+    end
+
+    def inspect
+      parts.
+        reduce(::Hash.new(0)) { |h,(l,r)| h[l] += r; h }.
+        sort_by {|unit,  _ | [:years, :months, :days, :minutes, :seconds, :secs].index(unit)}.
+        map     {|unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}"}.
+        to_sentence
+    end
+
+    def sum(sign, time = VoltTime.now)
+      parts.inject(time) do |t, (type, number)|
+        t.advance({type => number*sign})
+      end
+    end
+
+    private
+      # Ensures that the Duration responds like the value to other methods
+      def method_missing(method, *args, &block)
+        value.send(method, *args, &block)
+      end
+
+  end
+end

data/lib/volt/helpers/time/local_calculations.rb

@@ -0,0 +1,49 @@
+# Local calculations for use on the client only
+
+class VoltTime
+  
+  def change_local(options)
+    t = @time.getlocal
+    new_year = options.fetch(:year, t.year)
+    new_month = options.fetch(:month, t.month)
+    new_day   = options.fetch(:day, t.day)
+    new_hour  = options.fetch(:hour, t.hour)
+    new_min   = options.fetch(:min, options[:hour] ? 0 : t.min)
+    new_sec   = options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : t.sec)
+    
+    t = Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec)
+    VoltTime.from_time(t)
+  end
+  
+  # Returns a new VoltTime representing the beginning of the local day, 00:00:00
+  def local_beginning_of_day
+    change_local(hour: 0, min: 0, min: 0)
+  end
+
+  # Returns a new VoltTime representing the end of the local day, 23:59:59.999
+  def local_end_of_day
+    t = @time.getlocal
+    t = Time.new(t.year, t.month, t.day, 23, 59, 59.999)
+    VoltTime.from_time(t)
+  end
+
+  # Returns a new VoltTime representing the middle of the local day, 12:00:00
+  def local_middle_of_day
+    change_local(hour: 12)
+  end
+
+  # Returns the number of seconds since 00:00:00 of the current local day
+  def local_seconds_since_midnight
+    to_f - change_local(hour: 0).to_f
+  end
+
+  # Returns the number of seconds until 23:59:59.999 of current local day  
+  def local_seconds_until_end_of_day
+    local_end_of_day.to_f - to_f
+  end
+
+  # Returns a Range for the start to end of day
+  def local_all_day
+    local_beginning_of_day..local_end_of_day
+  end
+end

data/lib/volt/helpers/time/local_volt_time.rb

@@ -0,0 +1,23 @@
+class VoltTime
+
+  # Returns a string representation of the local time
+  def local_to_s
+    @time.getlocal.to_s
+  end
+  
+  # Returns a canonical representation of the local time
+  def local_asctime
+    @time.getlocal.asctime
+  end
+  
+  # Returns a canonical representation of the local time
+  def local_ctime
+    @time.getlocal.ctime
+  end
+  
+  # Formats the local time according to the provided string
+  def local_strftime(string)
+    @time.getlocal.strftime(string)
+  end
+  
+end

data/lib/volt/helpers/time/numeric.rb

@@ -0,0 +1,59 @@
+# Much of this class was borrowed from ActiveSupport:
+# https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/numeric/time.rb
+# and
+# https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/integer/time.rb
+
+require 'volt/helpers/time/duration'
+
+class Numeric
+  
+  # Returns a duration for the number of seconds provided.
+  def seconds
+    Volt::Duration.new(self, [[:secs, self]])
+  end
+  alias :second :seconds
+  
+  # Returns a duration for the number of minutes provided.
+  def minutes
+    Volt::Duration.new(self * 60, [[:secs, self * 60]])
+  end
+  alias :minute :minutes
+  
+  # Returns a duration for the number of hours provided.
+  def hours
+    Volt::Duration.new(self * 60 * 60, [[:secs, self * 60 * 60]])
+  end
+  alias :hour :hours
+  
+  # Returns a duration for the number of days provided.
+  def days
+    Volt::Duration.new(self * 24.hours, [[:days, self]])
+  end
+  alias :day :days
+  
+  # Returns a duration for the number of weeks provided.
+  def weeks
+    Volt::Duration.new(self * 7.days, [[:days, self * 7]])
+  end
+  alias :week :weeks
+  
+  # Returns a duration for the number of fortnights provided.
+  def fortnights
+    Volt::Duration.new(self * 14.days, [[:days, self * 14]])
+  end
+  alias :fortnight :fortnights
+  
+  # Returns a duration for the number of months provided.
+  # Ignores any fractional part of months
+  def months
+    Volt::Duration.new(self.to_i * 30.days, [[:months, self.to_i]])
+  end
+  alias :month :months
+  
+  # Returns a duration for the number of years provided
+  # Ignores any fractional part of years
+  def years
+    Volt::Duration.new(self.to_i * 365.25.days, [[:years, self.to_i]])
+  end
+  alias :year :years
+end

data/lib/volt/helpers/time/volt_time.rb

@@ -0,0 +1,170 @@
+# Volt needs its own date/time class because of the differences between
+# how Opal (i.e. JavaScript) and Ruby handle timezones. In JavaScript
+# there are only two possible timezones, the local zone and UTC, while
+# in Ruby any timezone can be set.
+# VoltTime is always stored in UTC but can be converted to the local timezone.
+# Because of Opal issue , VoltTime could not be Volt::Time.
+# Because of Opal issue , VoltTime could not be a subclass of ::Time
+
+class VoltTime
+  # Since VoltTime is required by the user, we don't add it to the FIELD_CASTS
+  # list until after it is included, since we don't have access to the class
+  # here.
+  if defined?(Volt::FieldHelpers)
+    Volt::FieldHelpers::FIELD_CASTS[VoltTime] = nil
+  end
+
+  # A VoltTime can be initialized from either local or UTC timezone.
+  # If no parameters are provided then the current time is initialized.
+  # Zone must be specified (as :local or :utc) if any parts of the date are given
+  # to be clear whether VoltTime should assume that the parameters
+  # are for a local or utc time.
+  def initialize(zone = nil, year = nil, month = nil, day = nil, hour = nil, min = nil, sec = nil)
+
+    # Case when all params are nil - create time now
+    if !zone || !year
+      @time = ::Time.new.getutc
+    elsif zone == :utc
+      t = ::Time.new(year, month, day, hour, min, sec)
+      @time = (t + t.utc_offset).getutc
+    elsif zone == :local
+      @time = ::Time.new(year, month, day, hour, min, sec).getutc
+    else
+      raise ArgumentError, "Specify zone as :utc or :local"
+    end
+  end
+
+  class << self
+
+    # Returns a VoltTime from a ::Time
+    def from_time(time)
+      VoltTime.new.set_time(time)
+    end
+
+    # Returns the time now in the UTC timezone
+    def now
+      VoltTime.new
+    end
+
+    # Live now acts just like now, except it invalidates any computations the
+    # VoltTime object is used in at every interval.  This makes it easy to
+    # display live timer's.
+    def live_now(interval=1000)
+      dep = Volt::Dependency.new
+      dep.depend
+      Volt::Timers.client_set_timeout(interval) do
+        dep.changed!
+      end
+      VoltTime.new
+    end
+
+    # Returns the time as seconds from the epoch Jan 1 1970
+    def at(secs, usecs = 0)
+      VoltTime.new.set_time(::Time.at(secs, usecs))
+    end
+
+    # Returns the name of the current local timezone
+    def current_zone
+      ::Time.new.zone
+    end
+
+    # Return the local timezone offset from UTC in hours
+    # in seconds
+    def current_offset
+      ::Time.new.utc_offset
+    end
+
+  end
+
+  # Sets Volt::Time from a ::Time object, converting to UTC if necessary
+  def set_time(time)
+    @time = time.getutc
+    return self
+  end
+
+  def <=> (other)
+    if other.is_a?(::Time)
+      @time <=> other
+    else
+      @time <=> other.getutc
+    end
+  end
+
+  def == (other)
+    if other.is_a?(::Time)
+      @time == other
+    else
+      @time == other.getutc
+    end
+  end
+
+  def to_s
+    @time.to_s
+  end
+
+  def inspect
+    @time.inspect
+  end
+
+  def + (other)
+    if other.is_a?(Volt::Duration)
+      other.sum(1, self)
+    else
+      VoltTime.from_time(@time + other)
+    end
+  end
+
+  def - (other)
+    if other.is_a?(VoltTime)
+      @time - other.getutc
+    elsif other.is_a?(::Time)
+      @time - other
+    elsif other.is_a?(Volt::Duration)
+      other.sum(-1, self)
+    else
+      VoltTime.from_time(@time - other)
+    end
+  end
+
+  # Redefining getlocal without a timezone parameter
+  def getlocal
+    @time.getlocal
+  end
+
+  # Redefining localtime without a timezone parameter
+  def localtime
+    # Opal 0.9.0 has no localtime method so use getlocal instead
+    @time.getlocal
+  end
+
+  # Get the local offset from UTC
+  def local_offset
+    @time.getlocal.utc_offset
+  end
+
+  def respond_to?(method_name, include_private = false)
+    @time.respond_to?(method_name, include_private)
+  end
+
+  unless RUBY_PLATFORM == 'opal'
+    # Marshal support for drb and ForkingServer
+    def _dump(level)
+      @time.to_i.to_s
+    end
+
+    def self._load(args)
+      at(args.to_i)
+    end
+  end
+
+  private
+
+  def method_missing(method, *args, &block)
+    @time.send(method, *args, &block)
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    @time.respond_to?(method_name, include_private)
+  end
+
+end

data/lib/volt/models.rb

@@ -22,3 +22,8 @@ else
   require(gem_dir + '/stdlib/promise')
 end
 require 'volt/utils/promise_extensions'
+
+
+unless RUBY_PLATFORM == 'opal'
+  require 'volt/models/migrations/migration_runner'
+end