barometer 0.8.0 → 0.9.0

data/lib/barometer/data/local_datetime.rb

@@ -1,145 +0,0 @@
-require 'date'
-module Barometer
-  #
-  # A simple DateTime class
-  #
-  # A time class that represents the local date_time ...
-  # it has no concept of time zone
-  #
-  class Data::LocalDateTime < Data::LocalTime
-
-    attr_reader :year, :month, :day
-
-    def initialize(y,mon,d,h=0,m=0,s=0)
-      raise(ArgumentError, "invalid date") unless y && mon && d && Date.civil(y,mon,d)
-      @year = y
-      @month = mon
-      @day = d
-      super(h,m,s)
-      self
-    end
-
-    def year=(y)
-      unless y && y.is_a?(Fixnum) && Date.civil(y,@month,@day)
-        raise(ArgumentError, "invalid year")
-      end
-      @year = y
-    end
-
-    def month=(m)
-      unless m && m.is_a?(Fixnum) && Date.civil(@year,m,@day)
-        raise(ArgumentError, "invalid month")
-      end
-      @month = m
-    end
-
-    def day=(d)
-      unless d && d.is_a?(Fixnum) && Date.civil(@year,@month,d)
-        raise(ArgumentError, "invalid day")
-      end
-      @day = d
-    end
-
-    def parse(string, format=nil)
-      return unless string
-      new_date = Data::LocalDateTime.parse(string, format)
-      @year = new_date.year
-      @month = new_date.month
-      @day = new_date.day
-      @hour = new_date.hour
-      @min = new_date.min
-      @sec = new_date.sec
-      self
-    end
-
-    def self.parse(string, format=nil)
-      return nil unless string
-      return string if string.is_a?(Data::LocalDateTime)
-
-      year = nil; month = nil; day = nil;
-      hour = nil; min = nil; sec = nil;
-      if string.is_a?(Time) || string.is_a?(DateTime)
-        year = string.year
-        month = string.mon
-        day = string.day
-        hour = string.hour
-        min = string.min
-        sec = string.sec
-      elsif string.is_a?(Date)
-        year = string.year
-        month = string.mon
-        day = string.day
-      elsif string.is_a?(String)
-        begin
-          datetime = if format
-            Time.strptime(string, format)
-          else
-            DateTime.parse(string)
-          end
-          year = datetime.year
-          month = datetime.mon
-          day = datetime.day
-          hour = datetime.hour
-          min = datetime.min
-          sec = datetime.sec
-        rescue ArgumentError
-          return nil
-        end
-      end
-      Data::LocalDateTime.new(year, month, day, hour, min, sec)
-    end
-
-    # convert to a Date class
-    #
-    def to_d
-      Date.civil(@year, @month, @day)
-    end
-
-    # convert to a DateTime class
-    #
-    def to_dt
-      DateTime.new(@year, @month, @day, @hour, @min, @sec)
-    end
-
-    def <=>(other)
-      if other.is_a?(String) || other.is_a?(Time) || other.is_a?(DateTime) || other.is_a?(Date)
-        the_other = Data::LocalDateTime.parse(other)
-      else
-        the_other = other
-      end
-      raise ArgumentError unless the_other.is_a?(Data::LocalDateTime) || the_other.is_a?(Data::LocalTime)
-
-      if ((other.is_a?(String) || other.is_a?(Time) || other.is_a?(DateTime)) &&
-        the_other.is_a?(Data::LocalDateTime)) || other.is_a?(Data::LocalDateTime)
-        # we are counting days + seconds
-        if (_total_days <=> the_other._total_days) == 0
-          return total_seconds <=> the_other.total_seconds
-        else
-          return _total_days <=> the_other._total_days
-        end
-      elsif other.is_a?(Date) && the_other.is_a?(Data::LocalDateTime)
-        # we are counting days
-        return _total_days <=> the_other._total_days
-      elsif the_other.is_a?(Data::LocalTime)
-        # we are counting seconds
-        return total_seconds <=> the_other.total_seconds
-      end
-    end
-
-    def to_s(time=false)
-      datetime = self.to_dt
-      format = (time ? "%Y-%m-%d %I:%M:%S %p" : "%Y-%m-%d")
-      datetime.strftime(format).downcase
-    end
-
-    def nil?; @year == 0 && @month == 0 && @day == 0 && super; end
-
-    # this assumes all years have 366 days (which only is true for leap years)
-    # but since this is just for comparisons, this will be accurate
-    #
-    def _total_days
-      self.to_d.yday + (@year * 366)
-    end
-
-  end
-end

data/lib/barometer/data/local_time.rb

@@ -1,134 +0,0 @@
-module Barometer
-  #
-  # A simple Time class
-  #
-  # A time class that represents the local time ...
-  # it has no concept of time zone or date
-  #
-  class Data::LocalTime
-    include Comparable
-
-    attr_reader :hour, :min, :sec
-
-    def initialize(h=0,m=0,s=0)
-      self.hour = h
-      self.min = m
-      self.sec = s
-      self
-    end
-
-    def hour=(h)
-      raise ArgumentError unless (h.is_a?(Fixnum) || h.nil?)
-      hour_cap = 24
-      if h.to_i >= hour_cap.to_i
-        @hour = h.divmod(hour_cap)[1]
-      else
-        @hour = h
-      end
-    end
-
-    def min=(m)
-      raise ArgumentError unless (m.is_a?(Fixnum) || m.nil?)
-      minute_cap = 60
-      if m.to_i >= minute_cap.to_i
-        result = m.divmod(minute_cap)
-        @min = result[1]
-        self.hour = @hour + result[0]
-      else
-        @min = m
-      end
-    end
-
-    def sec=(s)
-      raise ArgumentError unless (s.is_a?(Fixnum) || s.nil?)
-      second_cap = 60
-      if s.to_i >= second_cap.to_i
-        result = s.divmod(second_cap)
-        @sec = result[1]
-        self.min = @min + result[0]
-      else
-        @sec = s
-      end
-    end
-
-    def parse(string)
-      if string.is_a?(Time) || string.is_a?(DateTime)
-        @hour = string.hour
-        @min = string.min
-        @sec = string.sec
-      elsif string.is_a?(String)
-        time = Time.parse(string)
-        @hour = time.hour
-        @min = time.min
-        @sec = time.sec
-      end
-      self
-    end
-
-    def self.parse(string)
-      return string if string.is_a?(Data::LocalTime)
-      local = Data::LocalTime.new
-      local.parse(string)
-      local
-    end
-
-    # convert to a Time class
-    #
-    def to_t
-      date = Date.today
-      Time.local(date.year,date.month,date.day,@hour,@min,@sec)
-    end
-
-    def total_seconds
-      (@hour * 60 * 60) + (@min * 60) + @sec
-    end
-
-    def <=>(other)
-      if other.is_a?(String) || other.is_a?(Time) || other.is_a?(DateTime)
-        the_other = Data::LocalTime.parse(other)
-      else
-        the_other = other
-      end
-      raise ArgumentError unless the_other.is_a?(Data::LocalTime)
-      total_seconds <=> the_other.total_seconds
-    end
-
-    def +(seconds)
-      local_time = Data::LocalTime.new
-      if seconds.is_a?(Fixnum) || seconds.is_a?(Float)
-        local_time.sec = self.total_seconds + seconds.to_i
-      elsif seconds.is_a?(Data::LocalTime)
-        this_total = self.total_seconds + seconds.total_seconds
-        local_time.sec = this_total
-      end
-      local_time
-    end
-
-    def -(seconds)
-      local_time = Data::LocalTime.new
-      if seconds.is_a?(Fixnum) || seconds.is_a?(Float)
-        local_time.sec = self.total_seconds - seconds.to_i
-      elsif seconds.is_a?(Data::LocalTime)
-        #self.sec += seconds.total_seconds
-        this_total = self.total_seconds - seconds.total_seconds
-        local_time.sec = this_total
-      end
-      local_time
-    end
-
-    def diff(other)
-      the_other = Data::LocalTime.parse(other)
-      raise ArgumentError unless the_other.is_a?(Data::LocalTime)
-      (self.total_seconds - the_other.total_seconds).to_i.abs
-    end
-
-    def to_s(seconds=false)
-      time = self.to_t
-      format = (seconds ? "%I:%M:%S %p" : "%I:%M %p")
-      time.strftime(format).downcase
-    end
-
-    def nil?; @hour == 0 && @min == 0 && @sec == 0; end
-
-  end
-end

data/lib/barometer/data/speed.rb

@@ -1,158 +0,0 @@
-module Barometer
-  #
-  # A simple Speed class
-  #
-  # Think of this like the Integer class. Enhancement
-  # is that you can create a number (in a certain unit), then
-  # get that number back already converted to another unit.
-  #
-  # Speed is a vector, thus it has a perticular direction, although
-  # the direction is independent of the units
-  #
-  # All comparison operations will be done in metric
-  #
-  # NOTE: this currently only supports the scale of
-  #       kilometers (km) and miles (m) per hour.  There is currently
-  #       no way to scale to smaller units (eg km -> m -> mm)
-  #
-  class Data::Speed < Data::Units
-
-    METRIC_UNITS = "kph"
-    IMPERIAL_UNITS = "mph"
-
-    attr_accessor :kilometers, :miles
-    attr_accessor :degrees, :direction
-
-    def initialize(metric=true)
-      @kilometers = nil
-      @miles = nil
-      @degrees = nil
-      @direction = nil
-      super(metric)
-    end
-
-    def metric_default=(value); self.kph = value; end
-    def imperial_default=(value); self.mph = value; end
-
-    #
-    # CONVERTERS
-    #
-
-    def self.km_to_m(km)
-      return nil unless km && (km.is_a?(Integer) || km.is_a?(Float))
-      km.to_f * 0.622
-    end
-
-    def self.m_to_km(m)
-      return nil unless m && (m.is_a?(Integer) || m.is_a?(Float))
-      m.to_f * 1.609
-    end
-
-    #
-    # ACCESSORS
-    #
-
-    # store kilometers per hour
-    #
-    def kph=(kph)
-      return if !kph || !(kph.is_a?(Integer) || kph.is_a?(Float))
-      @kilometers = kph.to_f
-      self.update_miles(kph.to_f)
-    end
-
-    # store miles per hour
-    #
-    def mph=(mph)
-      return if !mph || !(mph.is_a?(Integer) || mph.is_a?(Float))
-      @miles = mph.to_f
-      self.update_kilometers(mph.to_f)
-    end
-
-    def direction=(direction)
-      return if !direction || !direction.is_a?(String)
-      @direction = direction
-    end
-
-    def degrees=(degrees)
-      return if !degrees || !(degrees.is_a?(Integer) || degrees.is_a?(Float))
-      @degrees = degrees
-    end
-
-    # return the stored kilometers or convert from miles
-    #
-    def kph(as_integer=true)
-      km = (@kilometers || Data::Speed.m_to_km(@miles))
-      km ? (as_integer ? km.to_i : (100*km).round/100.0) : nil
-    end
-
-    # return the stored miles or convert from kilometers
-    #
-    def mph(as_integer=true)
-      m = (@miles || Data::Speed.km_to_m(@kilometers))
-      m ? (as_integer ? m.to_i : (100*m).round/100.0) : nil
-    end
-
-    #
-    # OPERATORS
-    #
-
-    def <=>(other)
-      self.kph <=> other.kph
-    end
-
-    #
-    # HELPERS
-    #
-
-    # will just return the value (no units)
-    #
-    def to_i(metric=nil)
-      (metric || (metric.nil? && self.metric?)) ? self.kph : self.mph
-    end
-
-    # will just return the value (no units) with more precision
-    #
-    def to_f(metric=nil)
-      (metric || (metric.nil? && self.metric?)) ? self.kph(false) : self.mph(false)
-    end
-
-    # will return the value with units
-    #
-    def to_s(metric=nil)
-      (metric || (metric.nil? && self.metric?)) ? "#{self.kph} #{METRIC_UNITS}" : "#{self.mph} #{IMPERIAL_UNITS}"
-    end
-
-    # will just return the units (no value)
-    #
-    def units(metric=nil)
-      (metric || (metric.nil? && self.metric?)) ? METRIC_UNITS : IMPERIAL_UNITS
-    end
-
-    # when we set miles, it is possible the a non-equivalent value of
-    # kilometers remains.  if so, clear it.
-    #
-    def update_kilometers(m)
-      return unless @kilometers
-      difference = Data::Speed.m_to_km(m.to_f) - @kilometers
-      # only clear kilometers if the stored kilometers is off be more then 1 unit
-      # then the conversion of miles
-      @kilometers = nil unless difference.abs <= 1.0
-    end
-
-    # when we set kilometers, it is possible the a non-equivalent value of
-    # miles remains.  if so, clear it.
-    #
-    def update_miles(km)
-      return unless @miles
-      difference = Data::Speed.km_to_m(km.to_f) - @miles
-      # only clear miles if the stored miles is off be more then 1 unit
-      # then the conversion of kilometers
-      @miles = nil unless difference.abs <= 1.0
-    end
-
-    def nil?
-      (@kilometers || @miles) ? false : true
-    end
-
-  end
-end

data/lib/barometer/data/units.rb

@@ -1,49 +0,0 @@
-module Barometer
-  class Data::Units
-    include Comparable
-
-    attr_accessor :metric
-
-    def initialize(metric=true); @metric = metric; end
-
-    #
-    # HELPERS
-    #
-
-    def metric?; @metric; end
-    def metric!; @metric=true; end
-    def imperial!; @metric=false; end
-
-    # assigns a value to the right attribute based on metric setting
-    #
-    def <<(value)
-      return unless value
-
-      # these values can be treated like 'nil'
-      nil_values = ["NA", "N/A", ""]
-
-      begin
-        if value.is_a?(Array)
-          value_m = value[0].to_f if (value[0] && !nil_values.include?(value[0]))
-          value_i = value[1].to_f if (value[1] && !nil_values.include?(value[1]))
-          value_b = nil
-        else
-          value_m = nil
-          value_i = nil
-          value_b = value.to_f if (value && !nil_values.include?(value))
-        end
-      rescue
-        # do nothing
-      end
-
-      self.metric? ? self.metric_default = value_m || value_b :
-        self.imperial_default = value_i || value_b
-    end
-
-    # stubs
-    #
-    def metric_default=(value); raise NotImplementedError; end
-    def imperial_default=(value); raise NotImplementedError; end
-
-  end
-end