barometer 0.8.0 → 0.9.0

data/lib/barometer/data/attributes/zone.rb

@@ -0,0 +1,11 @@
+module Barometer
+  module Data
+    module Attribute
+      class Zone < Virtus::Attribute
+        def coerce(value)
+          value.nil? || value.is_a?(Barometer::Data::Zone) ? value : raise(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/lib/barometer/data/convertable_units.rb

@@ -0,0 +1,145 @@
+require 'delegate'
+
+module Barometer
+  module Data
+    class ConvertableUnits < SimpleDelegator
+      include Comparable
+
+      def initialize(*args)
+        parse_metric!(args)
+        parse_values!(args)
+        super(magnitude)
+        freeze_all
+      end
+
+      def to_s
+        magnitude_to_s
+      end
+
+      def nil?
+        magnitude.nil?
+      end
+
+      def <=>(other)
+        round(metric) <=> round(other.metric)
+      end
+
+      def metric
+        @metric_value || metric_from_imperial
+      end
+
+      def imperial
+        @imperial_value || imperial_from_metric
+      end
+
+      def units
+        metric? ? 'METRIC' : 'IMPERIAL'
+      end
+
+      def metric?
+        !!@metric
+      end
+
+      private
+
+      def metric=(value)
+        if detect_imperial?(value)
+          @metric = false
+        else
+          @metric = true
+        end
+      end
+
+      def metric_from_imperial
+        return unless @imperial_value
+        round(convert_imperial_to_metric(@imperial_value))
+      end
+
+      def convert_imperial_to_metric(value)
+        value
+      end
+
+      def imperial_from_metric
+        return unless @metric_value
+        round(convert_metric_to_imperial(@metric_value))
+      end
+
+      def magnitude
+        metric? ? metric : imperial
+      end
+
+      def parse_metric!(args)
+        unless detect_number?(args.first)
+          self.metric = args.shift
+        else
+          self.metric = true
+        end
+      end
+
+      def parse_values!(args)
+        parse_extra_values!(args)
+
+        if args.length == 1
+          parse_single_value!(args.shift)
+        else
+          parse_multiple_values!(args)
+        end
+        freeze_magnitude
+      end
+
+      def parse_extra_values!(args)
+        args
+      end
+
+      def parse_single_value!(value)
+        if metric?
+          @metric_value = value
+        else
+          @imperial_value = value
+        end
+      end
+
+      def parse_multiple_values!(values)
+        @metric_value = values.shift
+        @imperial_value = values.shift
+      end
+
+      def detect_imperial?(value)
+        value == :imperial || value.is_a?(FalseClass)
+      end
+
+      def detect_number?(value)
+        value.nil? || value.is_a?(Numeric) || string_is_number?(value)
+      end
+
+      def string_is_number?(value)
+        value.is_a?(String) &&
+          ((value.to_i.to_s == value) || (value.to_f.to_s == value))
+      end
+
+      def round(number)
+        (10*number.to_f).round/10.0
+      end
+
+      def magnitude_to_s
+        return if magnitude.nil?
+        "#{magnitude} #{units}"
+      end
+
+      def freeze_all
+        freeze_magnitude
+        freeze_extra
+      end
+
+      def freeze_extra
+        nil
+      end
+
+      def freeze_magnitude
+        @metric_value.freeze
+        @imperial_value.freeze
+        @metric.freeze
+      end
+    end
+  end
+end

data/lib/barometer/data/coordinates.rb

@@ -0,0 +1,16 @@
+require 'virtus'
+
+module Barometer
+  module Data
+    class Coordinates
+      include Virtus.value_object
+
+      attribute :latitude, Float
+      attribute :longitude, Float
+
+      def coordinates
+        [latitude, longitude].join(',')
+      end
+    end
+  end
+end

data/lib/barometer/data/distance.rb

@@ -1,141 +1,22 @@
 module Barometer
-  #
-  # A simple Distance 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: this currently only supports the scale of
-  #       kilometers (km) and miles (m).  There is currently
-  #       no way to scale to smaller units (eg km -> m -> mm)
-  #
-  class Data::Distance < Data::Units
+  module Data
+    class Distance < ConvertableUnits
+      def km; metric; end
+      def m; imperial; end
 
-    METRIC_UNITS = "km"
-    IMPERIAL_UNITS = "m"
+      def units
+        metric? ? 'km' : 'm'
+      end
 
-    attr_accessor :kilometers, :miles
+      private
 
-    def initialize(metric=true)
-      @kilometers = nil
-      @miles = nil
-      super(metric)
-    end
-
-    def metric_default=(value); self.km = value; end
-    def imperial_default=(value); self.m = 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
-    #
-    def km=(km)
-      return if !km || !(km.is_a?(Integer) || km.is_a?(Float))
-      @kilometers = km.to_f
-      self.update_miles(km.to_f)
-    end
-
-    # store miles
-    #
-    def m=(m)
-      return if !m || !(m.is_a?(Integer) || m.is_a?(Float))
-      @miles = m.to_f
-      self.update_kilometers(m.to_f)
-    end
-
-    # return the stored kilometers or convert from miles
-    #
-    def km(as_integer=true)
-      km = (@kilometers || Data::Distance.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 m(as_integer=true)
-      m = (@miles || Data::Distance.km_to_m(@kilometers))
-      m ? (as_integer ? m.to_i : (100*m).round/100.0) : nil
-    end
-
-    #
-    # OPERATORS
-    #
+      def convert_imperial_to_metric(imperial_value)
+        imperial_value.to_f * 1.609
+      end
 
-    def <=>(other)
-      self.km <=> other.km
+      def convert_metric_to_imperial(metric_value)
+        metric_value.to_f * 0.622
+      end
     end
-
-    #
-    # HELPERS
-    #
-
-    # will just return the value (no units)
-    #
-    def to_i(metric=nil)
-      (metric || (metric.nil? && self.metric?)) ? self.km : self.m
-    end
-
-    # will just return the value (no units) with more precision
-    #
-    def to_f(metric=nil)
-      (metric || (metric.nil? && self.metric?)) ? self.km(false) : self.m(false)
-    end
-
-    # will return the value with units
-    #
-    def to_s(metric=nil)
-      (metric || (metric.nil? && self.metric?)) ? "#{self.km} #{METRIC_UNITS}" : "#{self.m} #{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::Distance.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::Distance.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/geo.rb

@@ -1,68 +1,31 @@
 module Barometer
-  #
-  # A simple Geo class
-  #
-  # Used to store location data
-  #
-  class Data::Geo
-
-    attr_accessor :latitude, :longitude, :query
-    attr_accessor :locality, :region, :country, :country_code, :address
-
-    def initialize(location=nil)
-      return unless location
-      raise ArgumentError unless location.is_a?(Hash)
-      self.build_from_hash(location)
-      self
-    end
-
-    def build_from_hash(location=nil)
-      return nil unless location
-      raise ArgumentError unless location.is_a?(Hash)
-
-      if location["geometry"] && location["geometry"]["location"]
-        @latitude = location["geometry"]["location"]["lat"].to_f
-        @longitude = location["geometry"]["location"]["lng"].to_f
+  module Data
+    class Geo < Coordinates
+      attribute :query, String
+      attribute :address, String
+      attribute :locality, String
+      attribute :region, String
+      attribute :country, String
+      attribute :country_code, String
+      attribute :postal_code, String
+
+      def to_s
+        [address, locality, region, country || country_code].
+          compact.reject(&:empty?).join(', ')
       end
 
-      query_parts = []
-      if location["address_components"]
-        location["address_components"].each do |address_components|
-          skip unless address_components["types"]
-          # sublocality trumps locality
-          if address_components["types"].include?('sublocality')
-            @locality = address_components["long_name"]
-          end
-          if address_components["types"].include?('locality')
-            @locality ||= address_components["long_name"]
-          end
-          if address_components["types"].include?('administrative_area_level_1')
-            #@region = address_components["long_name"]
-            @region = address_components["short_name"]
-          end
-          if address_components["types"].include?('country')
-            @country = address_components["long_name"]
-            @country_code = address_components["short_name"]
-          end
-          if !(address_components["types"] & location["types"]).empty?
-            query_parts << address_components["long_name"]
-          end
-        end
+      def merge(other_geo)
+        return unless other_geo.is_a?(Data::Geo)
+        Data::Geo.new(merged_attributes(other_geo))
       end
 
-      @query = query_parts.join(', ')
-      @address = ""
-    end
-
-    def coordinates
-      [@latitude, @longitude].join(',')
-    end
+      private
 
-    def to_s
-      s = [@address, @locality, @region, @country || @country_code]
-      s.delete("")
-      s.compact.join(', ')
+      def merged_attributes(other_geo)
+        attributes.merge(other_geo.attributes) do |key, oldval, newval|
+          oldval || newval
+        end
+      end
     end
-
   end
 end

data/lib/barometer/data/location.rb

@@ -1,25 +1,19 @@
 module Barometer
-  #
-  # A simple Location class
-  #
-  # Used to store location information about the station that
-  # gave the measurement data for a weather query, or the location
-  # that was queried
-  #
-  class Data::Location
+  module Data
+    class Location < Coordinates
+      attribute :id, String
+      attribute :name, String
+      attribute :city, String
+      attribute :state_name, String
+      attribute :state_code, String
+      attribute :country, String
+      attribute :country_code, String
+      attribute :zip_code, String
 
-    attr_accessor :id, :name, :city
-    attr_accessor :state_name, :state_code, :country, :country_code, :zip_code
-    attr_accessor :latitude, :longitude
-
-    def coordinates
-      [@latitude, @longitude].join(',')
-    end
-
-    def to_s
-      [@name, @city, @state_name || @state_cocde,
-        @country || @country_code].compact.join(', ')
+      def to_s
+        [name, city, state_name || state_code,
+          country || country_code].compact.join(', ')
+      end
     end
-
   end
 end