libgeo 0.1.0

data/lib/libgeo/coordinate/hemi_helpers.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+module Libgeo
+  class Coordinate
+    module HemiHelpers
+
+      ##
+      # Make coordinate northen
+      #
+      def north!
+        return unless valid_hemisphere?(:N)
+        @hemisphere = :N
+      end
+
+      ##
+      # Make coordinate southern
+      #
+      def south!
+        return unless valid_hemisphere?(:S)
+        @hemisphere = :S
+      end
+
+      ##
+      # Make coordinate western
+      #
+      def west!
+        return unless valid_hemisphere?(:W)
+        @hemisphere = :W
+      end
+
+      ##
+      # Make coordinate eastern
+      #
+      def east!
+        return unless valid_hemisphere?(:E)
+        @hemisphere = :E
+      end
+
+      ##
+      # Check if coordinate in northen hemisphere
+      #
+      # Returns: {Boolean}
+      #
+      def north?
+        normalize_hemi
+        hemisphere == :N
+      end
+
+      ##
+      # Check if coordinate in southern hemisphere
+      #
+      # Returns: {Boolean}
+      #
+      def south?
+        normalize_hemi
+        hemisphere == :S
+      end
+
+      ##
+      # Check if coordinate in western hemisphere
+      #
+      # Returns: {Boolean}
+      #
+      def west?
+        normalize_hemi
+        hemisphere == :W
+      end
+
+      ##
+      # Check if coordinate in eastern hemisphere
+      #
+      # Returns: {Boolean}
+      #
+      def east?
+        normalize_hemi
+        hemisphere == :E
+      end
+    end
+  end
+end

data/lib/libgeo/coordinate/presenters.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+module Libgeo
+  class Coordinate
+    module Presenters
+
+      ##
+      # Represent coordinate as float
+      #
+      # Returns: {Float} decimal coordinate
+      #
+      def to_f
+        (negative_hemisphere? ? -1 : 1) * (degrees + minutes_only.to_d / 60).to_f
+      end
+
+      ##
+      # Represent coordinate in NMEA format
+      #
+      # Params:
+      # - formatter {Formatter} custom formatter (optional, default: '%2d%2M,%H')
+      #
+      # Returns: {String} formatted NMEA coordinate
+      #
+      def to_nmea(formatter=Format::NMEA_LAT)
+        to_s(formatter)
+      end
+
+      ##
+      # Format coordinate as string
+      #
+      # By default it uses standart DMS format
+      #
+      # Params:
+      # - formatter {Formatter} custom formatter (optional, default: '%2d°%2m′%S″%H')
+      #
+      # Returns: {String} formatted string
+      #
+      def to_s(formatter=Format::DMS)
+        formatter.format(self)
+      end
+      alias :to_dms :to_s
+
+      ##
+      # Represent coordinate as hash
+      #
+      # Returns: {Hash} with type, degrees, minutes, seconds and hemisphere
+      #
+      def to_hash
+        {
+          type:       type,
+          degrees:    degrees,
+          minutes:    minutes,
+          seconds:    seconds,
+          hemisphere: hemisphere
+        }
+      end
+
+      ##
+      # Inspect string
+      #
+      def inspect
+        "#<#{self.class} hemisphere=#{hemisphere} degrees=#{degrees} minutes=#{minutes} seconds=#{seconds}>"
+      end
+
+    end
+  end
+end

data/lib/libgeo/formatter.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'libgeo/formatter/compiler'
+require 'libgeo/formatter/evaluator'
+
+module Libgeo
+
+  ##
+  # Class: coordinate formatter
+  #
+  # Compiles sprintf-like patterns and present
+  # given Coordinate as a DMS string
+  #
+  # Example:
+  #
+  #     coord = Latitude.new(:N, 48, 4, 15.7)
+  #     my_format = Formatter.new('%H%d°%2M′')
+  #     my_format.format(coord) # => 'N48°04.26306′'
+  #
+  #
+  class Formatter
+
+    ##
+    # Source pattern
+    #
+    attr_reader :pattern
+
+    ##
+    # Create new string representing coordinate
+    #
+    # Params:
+    # - coordinate {Latitude|Longitude} source coordinate
+    # - evaluator  {Class}               private
+    #
+    # Returns: {String} formatted string
+    #
+    def format(coordinate, evaluator=Evaluator)
+      evaluator.new(coordinate).instance_eval(expression)
+    end
+
+    ##
+    # Represent instance as string
+    #
+    def inspect
+      "#<Libgeo::Formatter pattern=(#{pattern})>"
+    end
+    alias :to_s :inspect
+    alias :pretty_inspect :inspect
+
+  private
+
+    attr_reader :expression
+
+    def initialize(pattern)
+      @pattern    = pattern.freeze
+      @expression = Compiler.new(pattern).compile
+      freeze
+    end
+
+  end
+end

data/lib/libgeo/formatter/compiler.rb

@@ -0,0 +1,128 @@
+# encoding: utf-8
+
+require 'strscan'
+
+module Libgeo
+  class Formatter
+
+    ##
+    # Class: template compiler
+    #
+    # Tooks the sprintf-like pattern string
+    # and compiles it to the ruby code
+    #
+    # Example:
+    #
+    #     Compiler.new('%d:%2m').compile
+    #
+    class Compiler
+
+      ##
+      # Constant: set of keywords
+      #
+      # Defines keywords and corresponding ruby methods
+      # where `c` is a given coordinate object
+      #
+      KEYWORDS = {
+        'd' => 'c.deg',
+        'm' => 'c.mins',
+        'M' => 'c.minutes_only',
+        's' => 'c.secs.to_i',
+        'S' => 'c.secs',
+        'h' => 'c.hemi.to_s.downcase',
+        'H' => 'c.hemi'
+      }.freeze
+
+      TOKEN_REG  = /%\d?\w/.freeze
+      STRING_REG = /./.freeze
+
+      ##
+      # Resulted ruby expression
+      #
+      attr_reader :result
+
+      ##
+      # Compile the template
+      #
+      # Returns: {String} ruby expression
+      #
+      def compile
+        return result if result
+
+        scan until scanner.eos?
+
+        finalize_string
+
+        @result = parts.join(' << ').freeze
+      end
+
+    private
+
+      attr_reader :scanner, :parts
+
+      ##
+      # Constructor:
+      #
+      # Params:
+      # - pattern {String} pattern string
+      #
+      def initialize(pattern)
+        @scanner = StringScanner.new(pattern)
+        @parts   = []
+        @curr_string = ''
+      end
+
+      ##
+      # Private: scan for subsrings and process them
+      #
+      def scan
+        if key = scanner.scan(TOKEN_REG)
+          finalize_string
+          process_token(key)
+        else
+          @curr_string << scanner.scan(STRING_REG)
+        end
+      end
+
+      ##
+      # Private: process % tokens
+      #
+      # When % token given - we split it to the parts: key and pad.
+      # For example `%2m` will have key `m` and pad `2`
+      # Then we add corresponding ruby code to buffer
+      # and wrap it with `pad()` function if pad given.
+      # For `%2m` we will receive `pad(c.mins.to_s, 2)` instruction
+      #
+      # Params:
+      # - key {String} matched % substring
+      #
+      def process_token(token)
+        key = token[-1]
+        pad = token[1..-2].to_i
+
+        instr = KEYWORDS[key] + '.to_s'
+        instr = "pad(#{instr}, #{pad})" if pad > 0
+
+        parts << instr
+      end
+
+      ##
+      # Private: finalize plain string
+      #
+      # To avoid redundant string operations in the final
+      # expression, we store each matched substring in the temporary
+      # instance variable. When the next % token given - we
+      # concatenate the content of this variable and clean it.
+      # As a result, we have string 'foo' instead of 'f' << 'o' << 'o'
+      #
+      def finalize_string
+        unless @curr_string.empty?
+          parts << %('#{@curr_string}')
+          @curr_string = ''
+        end
+      end
+
+    end
+
+  end
+end

data/lib/libgeo/formatter/evaluator.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Libgeo
+  class Formatter
+
+    ##
+    # Class: sandbox for evaluating compiled expressions
+    #
+    class Evaluator < BasicObject
+
+      ##
+      # Coordinate
+      #
+      attr_reader :c
+
+      ##
+      # Add leading zeroes if needed
+      #
+      # Adds leading zeroes in case if int part of
+      # number doesn't have needed length
+      #
+      # Example:
+      #
+      #     pad('3.14', 2)  # => '03.14'
+      #     pad('13.14', 2) # => '13.14'
+      #     pad(42, 3)      # => '042'
+      #
+      # Params:
+      # - val {String|Numeric} number to process
+      # - num {Fixnum}          length of int part
+      #
+      # Returns: {String} number with or without zeroes added
+      #
+      def pad(val, i)
+        val    = val.to_s.split('.')
+        val[0] = add_zeroes(val[0], i)
+        val.join('.')
+      end
+
+    private
+
+      def initialize(coordinate)
+        @c = coordinate
+      end
+
+      def add_zeroes(val, i)
+        num = i - val.length
+        num = num > 0 ? num : 0
+        ('0' * num) + val
+      end
+    end
+  end
+end

data/lib/libgeo/latitude.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Libgeo
+  class Latitude < Coordinate
+
+    ##
+    # Constant: Valid hemisphere values
+    #
+    HEMISPHERES = Set.new([:N, :S]).freeze
+
+    POSITIVE_HEMISPHERE = :N
+    NEGATIVE_HEMISPHERE = :S
+
+    MAX_DEGREES = 90
+
+    ##
+    # Coordinate type
+    #
+    def type
+      :latitude
+    end
+
+  private
+
+    CORRECTIONS = {
+      N: Set.new(['N', 'north', :north]).freeze,
+      S: Set.new(['S', 'south', :south]).freeze
+    }.freeze
+
+    DIRECTIONS = {
+      :> => :N,
+      :< => :S
+    }.freeze
+
+  end
+end

data/lib/libgeo/longitude.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module Libgeo
+  class Longitude < Coordinate
+
+    ##
+    # Constant: Valid hemisphere values
+    #
+    HEMISPHERES = Set.new([:W, :E]).freeze
+
+    POSITIVE_HEMISPHERE = :E
+    NEGATIVE_HEMISPHERE = :W
+
+    MAX_DEGREES = 180
+
+    ##
+    # Coordinate type
+    #
+    def type
+      :longitude
+    end
+
+    ##
+    # Represent coordinate in NMEA format
+    #
+    # Params:
+    # - formatter {Formatter} custom formatter (optional, default: '%2d%3M,%H')
+    #
+    # Returns: {String} formatted NMEA coordinate
+    #
+    def to_nmea(formatter=Format::NMEA_LON)
+      to_s(formatter)
+    end
+
+  private
+
+    CORRECTIONS = {
+      W: Set.new(['W', 'west', :west]).freeze,
+      E: Set.new(['E', 'east', :east]).freeze
+    }.freeze
+
+    DIRECTIONS = {
+      :> => :E,
+      :< => :W
+    }.freeze
+
+  end
+end