barometer 0.8.0 → 0.9.0

data/lib/barometer/data/pressure.rb

@@ -1,143 +1,22 @@
 module Barometer
-  #
-  # A simple Pressure 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.
-  #
-  # All comparison operations will be done in metric
-  #
-  # NOTE: the metric units for pressure aren't commonly used, except
-  #       that this class was designed for storing weather data,
-  #       and it seems that it is more common in this case
-  #
-  class Data::Pressure < Data::Units
+  module Data
+    class Pressure < ConvertableUnits
+      def mb; metric; end
+      def in; imperial; end
 
-    METRIC_UNITS = "mb"
-    IMPERIAL_UNITS = "in"
+      def units
+        metric? ? 'mb' : 'in'
+      end
 
-    attr_accessor :millibars, :inches
+      private
 
-    def initialize(metric=true)
-      @millibars = nil
-      @inches = nil
-      super(metric)
-    end
-
-    def metric_default=(value); self.mb = value; end
-    def imperial_default=(value); self.in = value; end
-
-    #
-    # CONVERTERS
-    #
-
-    def self.mb_to_in(mb)
-      return nil unless mb && (mb.is_a?(Integer) || mb.is_a?(Float))
-      mb.to_f * 0.02953
-    end
-
-    def self.in_to_mb(inches)
-      return nil unless inches &&
-        (inches.is_a?(Integer) || inches.is_a?(Float))
-      inches.to_f * 33.8639
-    end
-
-    #
-    # ACCESSORS
-    #
-
-    # store millibars
-    #
-    def mb=(mb)
-      return if !mb || !(mb.is_a?(Integer) || mb.is_a?(Float))
-      @millibars = mb.to_f
-      self.update_inches(mb.to_f)
-    end
-
-    # store inches
-    #
-    def in=(inches)
-      return if !inches || !(inches.is_a?(Integer) || inches.is_a?(Float))
-      @inches = inches.to_f
-      self.update_millibars(inches.to_f)
-    end
-
-    # return the stored millibars or convert from inches
-    #
-    def mb(as_integer=true)
-      mb = (@millibars || Data::Pressure.in_to_mb(@inches))
-      mb ? (as_integer ? mb.to_i : (100*mb).round/100.0) : nil
-    end
-
-    # return the stored inches or convert from millibars
-    #
-    def in(as_integer=true)
-      inches = (@inches || Data::Pressure.mb_to_in(@millibars))
-      inches ? (as_integer ? inches.to_i : (100*inches).round/100.0) : nil
-    end
-
-    #
-    # OPERATORS
-    #
+      def convert_imperial_to_metric(imperial_value)
+        imperial_value.to_f * 33.8639
+      end
 
-    def <=>(other)
-      self.mb <=> other.mb
+      def convert_metric_to_imperial(metric_value)
+        metric_value.to_f * 0.02953
+      end
     end
-
-    #
-    # HELPERS
-    #
-
-    # will just return the value (no units)
-    #
-    def to_i(metric=nil)
-      (metric || (metric.nil? && self.metric?)) ? self.mb : self.in
-    end
-
-    # will just return the value (no units) with more precision
-    #
-    def to_f(metric=nil)
-      (metric || (metric.nil? && self.metric?)) ? self.mb(false) : self.in(false)
-    end
-
-    # will return the value with units
-    #
-    def to_s(metric=nil)
-      (metric || (metric.nil? && self.metric?)) ? "#{self.mb} #{METRIC_UNITS}" : "#{self.in} #{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 inches, it is possible the a non-equivalent value of
-    # millibars remains.  if so, clear it.
-    #
-    def update_millibars(inches)
-      return unless @millibars
-      difference = Data::Pressure.in_to_mb(inches.to_f) - @millibars
-      # only clear millibars if the stored millibars is off be more then 1 unit
-      # then the conversion of inches
-      @millibars = nil unless difference.abs <= 1.0
-    end
-
-    # when we set millibars, it is possible the a non-equivalent value of
-    # inches remains.  if so, clear it.
-    #
-    def update_inches(mb)
-      return unless @inches
-      difference = Data::Pressure.mb_to_in(mb.to_f) - @inches
-      # only clear inches if the stored inches is off be more then 1 unit
-      # then the conversion of millibars
-      @inches = nil unless difference.abs <= 1.0
-    end
-
-    def nil?
-      (@millibars || @inches) ? false : true
-    end
-
   end
 end

data/lib/barometer/data/sun.rb

@@ -1,33 +1,33 @@
 module Barometer
-  #
-  # A simple Sun class
-  #
-  # Used to store sunrise and sunset information
-  #
-  class Data::Sun
+  module Data
+    class Sun
+      include Virtus.value_object
 
-    attr_reader :rise, :set
+      attribute :rise, ::Time
+      attribute :set, ::Time
 
-    def initialize(rise=nil, set=nil)
-      raise ArgumentError unless (rise.is_a?(Data::LocalTime) || rise.nil?)
-      raise ArgumentError unless (set.is_a?(Data::LocalTime) || set.nil?)
-      @rise = rise
-      @set = set
-    end
+      def nil?
+        !(rise || set)
+      end
 
-    def nil?
-      (@rise || @set) ? false : true
-    end
+      def after_rise?(time)
+        time >= rise
+      end
 
-    def after_rise?(time)
-      raise ArgumentError unless time.is_a?(Data::LocalTime)
-      time >= @rise
-    end
+      def before_set?(time)
+        time <= set
+      end
 
-    def before_set?(time)
-      raise ArgumentError unless time.is_a?(Data::LocalTime)
-      time <= @set
-    end
+      def to_s
+        [_to_s('rise', rise), _to_s('set', set)].compact.join(', ')
+      end
+
+      private
 
+      def _to_s(prefix, value)
+        return unless value
+        "#{prefix}: #{value.strftime('%H:%M')}"
+      end
+    end
   end
 end

data/lib/barometer/data/temperature.rb

@@ -1,177 +1,22 @@
 module Barometer
-  #
-  # A simple Temperature 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.
-  #
-  # All comparison operations will be done in the absolute
-  # scale of Kelvin (K)
-  #
-  class Data::Temperature < Data::Units
+  module Data
+    class Temperature < ConvertableUnits
+      def c; metric; end
+      def f; imperial; end
 
-    METRIC_UNITS = "C"
-    IMPERIAL_UNITS = "F"
+      def units
+        metric? ? 'C' : 'F'
+      end
 
-    attr_accessor :celsius, :fahrenheit, :kelvin
+      private
 
-    def initialize(metric=true)
-      @celsius = nil
-      @fahrenheit = nil
-      @kelvin = nil
-      super(metric)
-    end
-
-    def metric_default=(value); self.c = value; end
-    def imperial_default=(value); self.f = value; end
-
-    #
-    # CONVERTERS
-    #
-
-    def self.c_to_k(c)
-      return nil unless c && (c.is_a?(Integer) || c.is_a?(Float))
-      273.15 + c.to_f
-    end
-
-    # Tf = (9/5)*Tc+32
-    #
-    def self.c_to_f(c)
-      return nil unless c && (c.is_a?(Integer) || c.is_a?(Float))
-       ((9.0/5.0)*c.to_f)+32.0
-    end
-
-    # Tc = (5/9)*(Tf-32)
-    #
-    def self.f_to_c(f)
-      return nil unless f && (f.is_a?(Integer) || f.is_a?(Float))
-      (5.0/9.0)*(f.to_f-32.0)
-    end
-
-    def self.f_to_k(f)
-      return nil unless f && (f.is_a?(Integer) || f.is_a?(Float))
-      c = self.f_to_c(f.to_f)
-      self.c_to_k(c)
-    end
-
-    def self.k_to_c(k)
-      return nil unless k && (k.is_a?(Integer) || k.is_a?(Float))
-      k.to_f - 273.15
-    end
-
-    def self.k_to_f(k)
-      return nil unless k && (k.is_a?(Integer) || k.is_a?(Float))
-      c = self.k_to_c(k.to_f)
-      self.c_to_f(c)
-    end
-
-    #
-    # ACCESSORS
-    #
-
-    # store celsius and kelvin
-    #
-    def c=(c)
-      return if !c || !(c.is_a?(Integer) || c.is_a?(Float))
-      @celsius = c.to_f
-      @kelvin = Data::Temperature.c_to_k(c.to_f)
-      self.update_fahrenheit(c.to_f)
-    end
-
-    # store fahrenheit and kelvin
-    #
-    def f=(f)
-      return if !f || !(f.is_a?(Integer) || f.is_a?(Float))
-      @fahrenheit = f.to_f
-      @kelvin = Data::Temperature.f_to_k(f.to_f)
-      self.update_celsius(f.to_f)
-    end
-
-    # store kelvin, convert to all
-    #
-    def k=(k)
-      return if !k || !(k.is_a?(Integer) || k.is_a?(Float))
-      @kelvin = k.to_f
-      @celsius = Data::Temperature.k_to_c(k.to_f)
-      @fahrenheit = Data::Temperature.k_to_f(k.to_f)
-    end
+      def convert_imperial_to_metric(imperial_value)
+        (5.0/9.0)*(imperial_value.to_f-32.0)
+      end
 
-    # return the stored celsius or convert from Kelvin
-    #
-    def c(as_integer=true)
-      c = (@celsius || Data::Temperature.k_to_c(@kelvin))
-      c ? (as_integer ? c.to_i : (100*c).round/100.0) : nil
+      def convert_metric_to_imperial(metric_value)
+        ((9.0/5.0)*metric_value.to_f)+32.0
+      end
     end
-
-    # return the stored fahrenheit or convert from Kelvin
-    #
-    def f(as_integer=true)
-      f = (@fahrenheit || Data::Temperature.k_to_f(@kelvin))
-      f ? (as_integer ? f.to_i : (100*f).round/100.0) : nil
-    end
-
-    #
-    # OPERATORS
-    #
-
-    def <=>(other)
-      @kelvin <=> other.kelvin
-    end
-
-    #
-    # HELPERS
-    #
-
-    # will just return the value (no units)
-    #
-    def to_i(metric=nil)
-      (metric || (metric.nil? && self.metric?)) ? self.c : self.f
-    end
-
-    # will just return the value (no units) with more precision
-    #
-    def to_f(metric=nil)
-      (metric || (metric.nil? && self.metric?)) ? self.c(false) : self.f(false)
-    end
-
-    # will return the value with units
-    #
-    def to_s(metric=nil)
-      (metric || (metric.nil? && self.metric?)) ? "#{self.c} #{METRIC_UNITS}" : "#{self.f} #{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 fahrenheit, it is possible the a non-equivalent value of
-    # celsius remains.  if so, clear it.
-    #
-    def update_celsius(f)
-      return unless @celsius
-      difference = Data::Temperature.f_to_c(f.to_f) - @celsius
-      # only clear celsius if the stored celsius is off be more then 1 degree
-      # then the conversion of fahrenheit
-      @celsius = nil unless difference.abs <= 1.0
-    end
-
-    # when we set celsius, it is possible the a non-equivalent value of
-    # fahrenheit remains.  if so, clear it.
-    #
-    def update_fahrenheit(c)
-      return unless @fahrenheit
-      difference = Data::Temperature.c_to_f(c.to_f) - @fahrenheit
-      # only clear fahrenheit if the stored fahrenheit is off be more then 1 degree
-      # then the conversion of celsius
-      @fahrenheit = nil unless difference.abs <= 1.0
-    end
-
-    def nil?
-      (@celsius || @fahrenheit || @kelvin) ? false : true
-    end
-
   end
 end

data/lib/barometer/data/vector.rb

@@ -0,0 +1,44 @@
+module Barometer
+  module Data
+    class Vector < ConvertableUnits
+      attr_reader :bearing
+
+      def kph; metric; end
+      def mph; imperial; end
+
+      def units
+        metric? ? 'kph' : 'mph'
+      end
+
+      def to_s
+        [super, bearing_to_s].compact.join(' @ ')
+      end
+
+      def nil?
+        super && bearing.nil?
+      end
+
+      private
+
+      def convert_imperial_to_metric(imperial_value)
+        imperial_value.to_f * 1.609
+      end
+
+      def convert_metric_to_imperial(metric_value)
+        metric_value.to_f * 0.622
+      end
+
+      def parse_extra_values!(args)
+        @bearing = args.pop if args.size > 1
+      end
+
+      def bearing_to_s
+        "#{bearing} degrees" unless bearing.nil?
+      end
+
+      def freeze_extra
+        @bearing.freeze
+      end
+    end
+  end
+end