[ruby-core:42551] [ruby-trunk - Feature #1436] Please consider this addition to resolv.rb which adds methods for resolving LOC resources

Issue #1436 has been updated by Yusuke Endoh.


Hello, akr

Any update here?

-- 
Yusuke Endoh <[e-mail]>
----------------------------------------
Feature #1436: Please consider this addition to resolv.rb which adds methods for resolving LOC resources
https://bugs.ruby-lang.org/issues/1436

Author: JB Smith
Status: Assigned
Priority: Normal
Assignee: Akira Tanaka
Category: core
Target version: 2.0.0


=begin
 Please consider this diff which would add support to resolv.rb to permit parsing of LOC resources.
 I would welcome any criticism or guidance that would make this more suitable for inclusion.
 Regards,
 
 JB Smith
 
 
 
 
 Index: lib/resolv.rb
 ===================================================================
 --- lib/resolv.rb	(revision 23349)
 +++ lib/resolv.rb	(working copy)
 @@ -1835,6 +1835,97 @@
        end
  
        ##
 +      # Location resource
 +      
 +      class LOC < Resource
 +      
 +        TypeValue = 29 # :nodoc:
 +        
 +        def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude)
 +          @version    = version
 +          @ssize      = Resolv::LOC::Size.create(ssize)
 +          @hprecision = Resolv::LOC::Size.create(hprecision)
 +          @vprecision = Resolv::LOC::Size.create(vprecision)
 +          @latitude   = Resolv::LOC::Coord.create(latitude)
 +          @longitude  = Resolv::LOC::Coord.create(longitude)
 +          @altitude   = Resolv::LOC::Alt.create(altitude)
 +        end
 +        
 +        ##
 +        # Returns the version value for this LOC record which should always be 00
 +        
 +        attr_reader :version
 +        
 +        ##
 +        # The spherical size of this LOC
 +        # in meters using scientific notation as 2 integers of XeY
 +        
 +        attr_reader :ssize
 +        
 +        ##
 +        # The horizontal precision using ssize type values
 +        # in meters using scientific notation as 2 integers of XeY
 +        # for precision use value/2 e.g. 2m = +/-1m
 +        
 +        attr_reader :hprecision
 +        
 +        ##
 +        # The vertical precision using ssize type values
 +        # in meters using scientific notation as 2 integers of XeY
 +        # for precision use value/2 e.g. 2m = +/-1m
 +        
 +        attr_reader :vprecision
 +        
 +        ##
 +        # The latitude for this LOC where 2**31 is the equator
 +        # in thousandths of an arc second as an unsigned 32bit integer
 +        
 +        attr_reader :latitude
 +        
 +        ##
 +        # The longitude for this LOC where 2**31 is the prime meridian
 +        # in thousandths of an arc second as an unsigned 32bit integer
 +        
 +        attr_reader :longitude
 +        
 +        ##
 +        # The altitude of the LOC above a reference sphere whose surface sits 100km below the WGS84 spheroid
 +        # in centimeters as an unsigned 32bit integer
 +        
 +        attr_reader :altitude
 +        
 +        
 +        def encode_rdata(msg) # :nodoc:
 +          msg.put_bytes(@version)
 +          msg.put_bytes(@ssize.scalar)
 +          msg.put_bytes(@hprecision.scalar)
 +          msg.put_bytes(@vprecision.scalar)
 +          msg.put_bytes(@latitude.coordinates)
 +          msg.put_bytes(@longitude.coordinates)
 +          msg.put_bytes(@altitude.altitude)
 +        end
 +        
 +        def self.decode_rdata(msg) # :nodoc:
 +          version    = msg.get_bytes(1)
 +          ssize      = msg.get_bytes(1)
 +          hprecision = msg.get_bytes(1)
 +          vprecision = msg.get_bytes(1)
 +          latitude   = msg.get_bytes(4)
 +          longitude  = msg.get_bytes(4)
 +          altitude   = msg.get_bytes(4)
 +          return self.new(
 +            version, 
 +            Resolv::LOC::Size.new(ssize), 
 +            Resolv::LOC::Size.new(hprecision), 
 +            Resolv::LOC::Size.new(vprecision), 
 +            Resolv::LOC::Coord.new(latitude,"lat"), 
 +            Resolv::LOC::Coord.new(longitude,"lon"), 
 +            Resolv::LOC::Alt.new(altitude)
 +          )
 +        end
 +      end
 +
 +      ##
        # A Query type requesting any RR.
  
        class ANY < Query
 @@ -1842,7 +1933,7 @@
        end
  
        ClassInsensitiveTypes = [ # :nodoc:
 -        NS, CNAME, SOA, PTR, HINFO, MINFO, MX, TXT, ANY
 +        NS, CNAME, SOA, PTR, HINFO, MINFO, MX, TXT, LOC, ANY
        ]
  
        ##
 @@ -2260,6 +2351,223 @@
      end
    end
  
 +  module LOC
 +  
 +    ##
 +    # A Resolv::LOC::Size
 +    
 +    class Size
 +    
 +      Regex = /^(\d+\.*\d*)[m]$/
 +      
 +      ##
 +      # Creates a new LOC::Size from +arg+ which may be:
 +      #
 +      # LOC::Size:: returns +arg+.
 +      # String:: +arg+ must match the LOC::Size::Regex constant
 +      
 +      def self.create(arg)
 +        case arg
 +        when Size
 +          return arg
 +        when String
 +          scalar = ''
 +          if Regex =~ arg
 +            scalar = [(($1.to_f*(1e2)).to_i.to_s[0].to_i*(2**4)+(($1.to_f*(1e2)).to_i.to_s.length-1))].pack("C")
 +          else
 +            raise ArgumentError.new("not a properly formed Size string: " + arg)
 +          end
 +          return Size.new(scalar) 
 +        else
 +          raise ArgumentError.new("cannot interpret as Size: #{arg.inspect}")
 +        end
 +      end
 +      
 +      def initialize(scalar)
 +        @scalar = scalar
 +      end
 +      
 +      ##
 +      # The raw size
 +      
 +      attr_reader :scalar
 +      
 +      def to_s # :nodoc:
 +        s = @scalar.unpack("H2").join.to_s
 +        return ((s[0].to_i)*(10**(s[1].to_i-2))).to_s << "m"
 +      end
 +      
 +      def inspect # :nodoc:
 +        return "#<#{self.class} #{self.to_s}>"
 +      end
 +      
 +      def ==(other) # :nodoc:
 +        return @scalar == other.scalar
 +      end
 +  
 +      def eql?(other) # :nodoc:
 +        return self == other
 +      end
 +  
 +      def hash # :nodoc:
 +        return @scalar.hash
 +      end
 +      
 +    end
 +    
 +    ##
 +    # A Resolv::LOC::Coord
 +    
 +    class Coord
 +    
 +      Regex = /^(\d+)\s(\d+)\s(\d+\.\d+)\s([NESW])$/
 +      
 +      ##
 +      # Creates a new LOC::Coord from +arg+ which may be:
 +      #
 +      # LOC::Coord:: returns +arg+.
 +      # String:: +arg+ must match the LOC::Coord::Regex constant
 +      
 +      def self.create(arg)
 +        case arg
 +        when Coord
 +          return arg
 +        when String
 +          coordinates = ''
 +          if Regex =~ arg &&  $1<180
 +            hemi = ($4[/([NE])/,1]) || ($4[/([SW])/,1]) ? 1 : -1
 +            coordinates = [(($1.to_i*(36e5))+($2.to_i*(6e4))+($3.to_f*(1e3)))*hemi+(2**31)].pack("N")
 +            (orientation ||= '') << $4[[/NS/],1] ? 'lat' : 'lon'
 +          else
 +            raise ArgumentError.new("not a properly formed Coord string: " + arg)
 +          end
 +          return Coord.new(coordinates,orientation) 
 +        else
 +          raise ArgumentError.new("cannot interpret as Coord: #{arg.inspect}")
 +        end
 +      end
 +          
 +      def initialize(coordinates,orientation)
 +        unless coordinates.kind_of?(String)
 +          raise ArgumentError.new("Coord must be a 32bit unsigned integer in hex format: #{coordinates.inspect}")
 +        end
 +        unless orientation.kind_of?(String) && orientation[/^lon$|^lat$/] 
 +          raise ArgumentError.new('Coord expects orientation to be a String argument of "lat" or "lon"')
 +        end  
 +        @coordinates = coordinates
 +        @orientation = orientation
 +      end
 +  
 +      ##
 +      # The raw coordinates
 +  
 +      attr_reader :coordinates
 +      
 +      ## The orientation of the hemisphere as 'lat' or 'lon'
 +      
 +      attr_reader :orientation
 +      
 +      def to_s # :nodoc:
 +          c = @coordinates.unpack("N").join.to_i
 +          val      = (c - (2**31)).abs
 +          fracsecs = (val % 1e3).to_i.to_s 
 +          val      = val / 1e3
 +          secs     = (val % 60).to_i.to_s 
 +          val      = val / 60
 +          mins     = (val % 60).to_i.to_s 
 +          degs     = (val / 60).to_i.to_s
 +          posi = (c >= 2**31)
 +          case posi
 +          when true
 +            hemi = @orientation[/^lat$/] ? "N" : "E"
 +          else
 +            hemi = @orientation[/^lon$/] ? "W" : "S"
 +          end
 +          return degs << " " << mins << " " << secs << "." << fracsecs << " " << hemi
 +      end
 +      
 +      def inspect # :nodoc:
 +        return "#<#{self.class} #{self.to_s}>"
 +      end
 +      
 +      def ==(other) # :nodoc:
 +        return @coordinates == other.coordinates
 +      end
 +  
 +      def eql?(other) # :nodoc:
 +        return self == other
 +      end
 +  
 +      def hash # :nodoc:
 +        return @coordinates.hash
 +      end
 +      
 +    end
 +    
 +    ##
 +    # A Resolv::LOC::Alt
 +    
 +    class Alt
 +      
 +      Regex = /^([+-]*\d+\.*\d*)[m]$/
 +      
 +      ##
 +      # Creates a new LOC::Alt from +arg+ which may be:
 +      #
 +      # LOC::Alt:: returns +arg+.
 +      # String:: +arg+ must match the LOC::Alt::Regex constant
 +      
 +      def self.create(arg)
 +        case arg
 +        when Alt
 +          return arg
 +        when String
 +          altitude = ''
 +          if Regex =~ arg
 +            altitude = [($1.to_f*(1e2))+(1e7)].pack("N")
 +          else
 +            raise ArgumentError.new("not a properly formed Alt string: " + arg)
 +          end
 +          return Alt.new(altitude) 
 +        else
 +          raise ArgumentError.new("cannot interpret as Alt: #{arg.inspect}")
 +        end
 +      end
 +      
 +      def initialize(altitude)
 +        @altitude = altitude
 +      end
 +      
 +      ##
 +      # The raw altitude
 +      
 +      attr_reader :altitude
 +      
 +      def to_s # :nodoc:
 +        a = @altitude.unpack("N").join.to_i
 +        return ((a.to_f/1e2)-1e5).to_s + "m"
 +      end
 +      
 +      def inspect # :nodoc:
 +        return "#<#{self.class} #{self.to_s}>"
 +      end
 +      
 +      def ==(other) # :nodoc:
 +        return @altitude == other.altitude
 +      end
 +  
 +      def eql?(other) # :nodoc:
 +        return self == other
 +      end
 +  
 +      def hash # :nodoc:
 +        return @altitude.hash
 +      end
 +      
 +    end
 +  
 +  end
 +
    ##
    # Default resolver to use for Resolv class methods.
=end



-- 
http://bugs.ruby-lang.org/