openc3 5.0.6

data/lib/openc3/topics/topic.rb

@@ -0,0 +1,53 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/utilities/store'
+
+module OpenC3
+  class Topic
+    if RUBY_VERSION < "3"
+      # Delegate all unknown class methods to delegate to the EphemeralStore
+      def self.method_missing(message, *args, &block)
+        EphemeralStore.public_send(message, *args, &block)
+      end
+    else
+      # Delegate all unknown class methods to delegate to the EphemeralStore
+      def self.method_missing(message, *args, **kwargs, &block)
+        EphemeralStore.public_send(message, *args, **kwargs, &block)
+      end
+    end
+
+    def self.clear_topics(topics, maxlen = 0)
+      topics.each { |topic| EphemeralStore.xtrim(topic, maxlen) }
+    end
+
+    def self.topics(scope, key)
+      EphemeralStore
+        .scan_each(match: "#{scope}__#{key}__*", type: 'stream', count: 100)
+        .to_a # Change the enumerator into an array
+        .uniq # Scan can return duplicates so ensure unique
+        .sort # Sort not entirely necessary but nice
+    end
+
+    def self.get_cnt(topic)
+      _, packet = EphemeralStore.get_newest_message(topic)
+      packet ? packet["received_count"].to_i : 0
+    end
+  end
+end

data/lib/openc3/utilities/authentication.rb

@@ -0,0 +1,141 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/version'
+
+module OpenC3
+
+  # Basic exception for known errors
+  class OpenC3AuthenticationError < StandardError; end
+
+  class OpenC3AuthenticationRetryableError < OpenC3AuthenticationError; end
+
+  # OpenC3 base / open source authentication code
+  class OpenC3Authentication
+    def initialize()
+      @token = ENV['OPENC3_API_PASSWORD'] || ENV['OPENC3_SERVICE_PASSWORD']
+      if @token.nil?
+        raise OpenC3AuthenticationError, "Authentication requires environment variables OPENC3_API_PASSWORD or OPENC3_SERVICE_PASSWORD"
+      end
+    end
+
+    # Load the token from the environment
+    def token()
+      @token
+    end
+  end
+
+  # OpenC3 enterprise Keycloak authentication code
+  class OpenC3KeycloakAuthentication < OpenC3Authentication
+    # {
+    #     "access_token": "",
+    #     "expires_in": 600,
+    #     "refresh_expires_in": 1800,
+    #     "refresh_token": "",
+    #     "token_type": "bearer",
+    #     "id_token": "",
+    #     "not-before-policy": 0,
+    #     "session_state": "",
+    #     "scope": "openid email profile"
+    # }
+
+    # @param url [String] The url of the openc3 or keycloak in the cluster
+    def initialize(url)
+      @url = url
+      @auth_mutex = Mutex.new
+      @refresh_token = nil
+      @expires_at = nil
+      @refresh_expires_at = nil
+      @token = nil
+      @log = [nil, nil]
+    end
+
+    # Load the token from the environment
+    def token()
+      @auth_mutex.synchronize do
+        @log = [nil, nil]
+        current_time = Time.now.to_i
+        if @token.nil?
+          _make_token(current_time)
+        elsif @refresh_expires_at < current_time
+          _make_token(current_time)
+        elsif @expires_at < current_time
+          _refresh_token(current_time)
+        end
+      end
+      "Bearer #{@token}"
+    end
+
+    private
+
+    # Make the token and save token to instance
+    def _make_token(current_time)
+      client_id = ENV['OPENC3_API_CLIENT'] || 'api'
+      data = "username=#{ENV['OPENC3_API_USER']}&password=#{ENV['OPENC3_API_PASSWORD']}"
+      data << "&client_id=#{client_id}"
+      data << '&grant_type=password&scope=openid'
+      headers = {
+        'Content-Type' => 'application/x-www-form-urlencoded',
+        'User-Agent' => "OpenC3KeycloakAuthorization / #{OPENC3_VERSION} (ruby/openc3/lib/utilities/authentication)",
+      }
+      oath = _make_request(headers, data)
+      @token = oath['access_token']
+      @refresh_token = oath['refresh_token']
+      @expires_at = current_time + oath['expires_in']
+      @refresh_expires_at = current_time + oath['refresh_expires_in']
+    end
+
+    # Refresh the token and save token to instance
+    def _refresh_token(current_time)
+      client_id = ENV['OPENC3_API_CLIENT'] || 'api'
+      data = "client_id=#{client_id}&refresh_token=#{@refresh_token}&grant_type=refresh_token"
+      headers = {
+        'Content-Type' => 'application/x-www-form-urlencoded',
+        'User-Agent' => "OpenC3KeycloakAuthorization / #{OPENC3_VERSION} (ruby/openc3/lib/utilities/authentication)",
+      }
+      oath = _make_request(headers, data)
+      @token = oath["access_token"]
+      @refresh_token = oath["refresh_token"]
+      @expires_at = current_time + oath["expires_in"]
+      @refresh_expires_at = current_time + oath["refresh_expires_in"]
+    end
+
+    # Make the post request to keycloak
+    def _make_request(headers, data)
+      uri = URI("#{@url}/auth/realms/openc3/protocol/openid-connect/token")
+      @log[0] = "request uri: #{uri.to_s} header: #{headers.to_s} body: #{data.to_s}"
+      STDOUT.puts @log[0] if JsonDRb.debug?
+      saved_verbose = $VERBOSE; $VERBOSE = nil
+      begin
+        resp = HTTPClient.new().post(uri, :body => data, :header => headers)
+      ensure
+        $VERBOSE = saved_verbose
+      end
+      @log[1] = "response status: #{resp.status} header: #{resp.headers} body: #{resp.body}"
+      STDOUT.puts @log[1] if JsonDRb.debug?
+      if resp.status >= 200 && resp.status <= 299
+        return JSON.parse(resp.body, :allow_nan => true, :create_additions => true)
+      elsif resp.status >= 500 && resp.status <= 599
+        raise OpenC3AuthenticationRetryableError, "authentication request retryable #{@log[0]} ::: #{@log[1]}"
+      else
+        raise OpenC3AuthenticationError, "authentication request failed #{@log[0]} ::: #{@log[1]}"
+      end
+    end
+  end
+end

data/lib/openc3/utilities/authorization.rb

@@ -0,0 +1,51 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/models/auth_model'
+
+begin
+  require 'openc3-enterprise/utilities/authorization'
+rescue LoadError
+  # If we're not in openc3-enterprise we define our own
+  module OpenC3
+    class AuthError < StandardError
+    end
+
+    class ForbiddenError < StandardError
+    end
+
+    module Authorization
+      private
+
+      # Raises an exception if unauthorized, otherwise does nothing
+      def authorize(permission: nil, target_name: nil, packet_name: nil, interface_name: nil, router_name: nil, scope: nil, token: nil)
+        raise AuthError.new("Scope is required") unless scope
+
+        if $openc3_authorize
+          raise AuthError.new("Token is required") unless token
+          raise AuthError.new("Token is invalid for '#{permission}' permission") unless OpenC3::AuthModel.verify(token, permission: permission)
+        end
+      end
+
+      def user_info(_token)
+        {} # EE does stuff here
+      end
+    end
+  end
+end

data/lib/openc3/utilities/crc.rb

@@ -0,0 +1,278 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/ext/crc' if RUBY_ENGINE == 'ruby' and !ENV['OPENC3_NO_EXT']
+
+module OpenC3
+  # Abstract base class which {Crc16}, {Crc32} and {Crc64} use. Do NOT use this
+  # class directly but instead use one of the subclasses.
+  class Crc
+    BIT_REVERSE_TABLE = [
+      0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0,
+      0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8,
+      0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4,
+      0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC,
+      0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2,
+      0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA,
+      0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6,
+      0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE,
+      0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1,
+      0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9,
+      0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5,
+      0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD,
+      0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3,
+      0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB,
+      0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7,
+      0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF
+    ]
+
+    # @return [Integer] The polynomial used when calcuating the CRC
+    attr_reader :poly
+    # @return [Integer] Seed value used to start the calulation
+    attr_reader :seed
+    # @return [Boolean] Whether the result is XORed with 0xFFFF
+    attr_reader :xor
+    # @return [Boolean] Whether to bit reverse each byte
+    attr_reader :reflect
+    # @return [String] Binary lookup table used to perform the calculation
+    attr_reader :table
+
+    # Creates a CRC algorithm instance.
+    #
+    # @param poly [Integer] Polynomial to use when calculating the CRC
+    # @param seed [Integer] Seed value to start the calculation
+    # @param xor [Boolean] Whether to XOR the CRC result with 0xFFFF
+    # @param reflect [Boolean] Whether to bit reverse each byte of data before
+    #   calculating the CRC
+    def initialize(poly, seed, xor, reflect)
+      @poly = poly
+      @seed = seed
+      @xor = xor
+      @reflect = reflect
+      if RUBY_ENGINE == 'ruby' and !ENV['OPENC3_NO_EXT']
+        @table = ''
+      else
+        @table = []
+      end
+
+      # Determine which class we're using: Crc16, Crc32, Crc64
+      @bit_size = self.class.name[-2..-1].to_i
+      case @bit_size
+      when 16
+        pack = 'S'
+        filter_mask = 0xFFFF
+      when 32
+        pack = 'I'
+        filter_mask = 0xFFFFFFFF
+      when 64
+        pack = 'Q'
+        filter_mask = 0xFFFFFFFFFFFFFFFF
+      end
+      if RUBY_ENGINE == 'ruby' and !ENV['OPENC3_NO_EXT']
+        (0..255).each do |index|
+          @table << [compute_table_entry(index, @bit_size)].pack(pack)
+        end
+      else
+        (0..255).each do |index|
+          @table << (compute_table_entry(index, @bit_size) & filter_mask)
+        end
+      end
+    end
+
+    # @!method calc(data, seed = nil)
+    #   Calculates the CRC across the data buffer using the optional seed.
+    #   Implemented in C for speed.
+    #
+    #   @param data [String] String buffer of binary data to calculate a CRC on
+    #   @param seed [Integer|nil] Seed value to start the calculation. Pass nil
+    #     to use the default seed set in the constructor.
+    #   @return [Integer] The CRC value
+
+    # Bit reverse the 8 bit value
+    # @param value [Integer]
+    # @return [Integer] Bit reversed value
+    def bit_reverse_8(value)
+      BIT_REVERSE_TABLE[value & 0xFF]
+    end
+
+    def bit_reverse_16(value)
+      (BIT_REVERSE_TABLE[value & 0xFF] << 8) |
+        (BIT_REVERSE_TABLE[(value >> 8) & 0xFF])
+    end
+
+    def bit_reverse_32(value)
+      (BIT_REVERSE_TABLE[value & 0xFF] << 24) |
+        (BIT_REVERSE_TABLE[(value >> 8) & 0xFF] << 16) |
+        (BIT_REVERSE_TABLE[(value >> 16) & 0xFF] << 8) |
+        (BIT_REVERSE_TABLE[(value >> 24) & 0xFF])
+    end
+
+    def bit_reverse_64(value)
+      (BIT_REVERSE_TABLE[value & 0x00000000000000FF] << 56) |
+        (BIT_REVERSE_TABLE[(value >> 8) & 0x00000000000000FF] << 48) |
+        (BIT_REVERSE_TABLE[(value >> 16) & 0x00000000000000FF] << 40) |
+        (BIT_REVERSE_TABLE[(value >> 24) & 0x00000000000000FF] << 32) |
+        (BIT_REVERSE_TABLE[(value >> 32) & 0x00000000000000FF] << 24) |
+        (BIT_REVERSE_TABLE[(value >> 40) & 0x00000000000000FF] << 16) |
+        (BIT_REVERSE_TABLE[(value >> 48) & 0x00000000000000FF] << 8) |
+        (BIT_REVERSE_TABLE[(value >> 56) & 0x00000000000000FF])
+    end
+
+    if RUBY_ENGINE != 'ruby' or ENV['OPENC3_NO_EXT']
+      def calc(data, seed = @seed)
+        crc = seed
+
+        case @bit_size
+        when 16
+          right_shift = 8
+          filter_mask = 0xFFFF
+          final_bit_reverse = method(:bit_reverse_16)
+        when 32
+          right_shift = 24
+          filter_mask = 0xFFFFFFFF
+          final_bit_reverse = method(:bit_reverse_32)
+        when 64
+          right_shift = 56
+          filter_mask = 0xFFFFFFFFFFFFFFFF
+          final_bit_reverse = method(:bit_reverse_64)
+        end
+
+        if @reflect
+          data.each_byte do |byte|
+            crc = ((crc << 8) & filter_mask) ^ @table[(crc >> right_shift) ^ bit_reverse_8(byte)]
+          end
+
+          if @xor
+            return final_bit_reverse.call(crc ^ filter_mask)
+          else
+            return final_bit_reverse.call(crc)
+          end
+        else
+          data.each_byte do |byte|
+            crc = ((crc << 8) & filter_mask) ^ @table[(crc >> right_shift) ^ byte]
+          end
+
+          if @xor
+            return crc ^ filter_mask
+          else
+            return crc
+          end
+        end
+      end
+    end
+
+    protected
+
+    # Compute a single entry in the crc lookup table
+    def compute_table_entry(index, digits)
+      # Start by shifting the index
+      crc = index << (digits - 8)
+
+      # The mask is 0x8000 for Crc16, 0x80000000 for Crc32, etc
+      mask = (1 << (digits - 1))
+
+      8.times do
+        if (crc & mask) != 0
+          crc = (crc << 1) ^ @poly
+        else
+          crc = crc << 1
+        end
+      end
+
+      # XOR the mask and or back in the top bit to get all ones
+      mask = ~mask | mask
+      return (crc & mask)
+    end
+  end
+
+  # Calculates 16-bit CRCs over a buffer of data.
+  class Crc16 < Crc
+    # CRC-16-CCITT default polynomial
+    DEFAULT_POLY = 0x1021
+    # Seed for 16-bit CRC
+    DEFAULT_SEED = 0xFFFF
+
+    # Creates a 16 bit CRC algorithm instance. By default it is initialzed to
+    # use the CRC-16-CCITT algorithm.
+    #
+    # @param poly [Integer] Polynomial to use when calculating the CRC
+    # @param seed [Integer] Seed value to start the calculation
+    # @param xor [Boolean] Whether to XOR the CRC result with 0xFFFF
+    # @param reflect [Boolean] Whether to bit reverse each byte of data before
+    #   calculating the CRC
+    def initialize(poly = DEFAULT_POLY,
+                   seed = DEFAULT_SEED,
+                   xor  = false,
+                   reflect = false)
+      super(poly, seed, xor, reflect)
+    end
+
+    alias calculate_crc16 calc
+  end # class Crc16
+
+  # Calculates 32-bit CRCs over a buffer of data.
+  class Crc32 < Crc
+    # CRC-32 default polynomial
+    DEFAULT_POLY = 0x04C11DB7
+    # Default Seed for 32-bit CRC
+    DEFAULT_SEED = 0xFFFFFFFF
+
+    # Creates a 32 bit CRC algorithm instance. By default it is initialzed to
+    # use the CRC-32 algorithm.
+    #
+    # @param poly [Integer] Polynomial to use when calculating the CRC
+    # @param seed [Integer] Seed value to start the calculation
+    # @param xor [Boolean] Whether to XOR the CRC result with 0xFFFF
+    # @param reflect [Boolean] Whether to bit reverse each byte of data before
+    #   calculating the CRC
+    def initialize(poly = DEFAULT_POLY,
+                   seed = DEFAULT_SEED,
+                   xor = true,
+                   reflect = true)
+      super(poly, seed, xor, reflect)
+    end
+
+    alias calculate_crc32 calc
+  end
+
+  # Calculates 64-bit CRCs over a buffer of data.
+  class Crc64 < Crc
+    # CRC-64-ECMA default polynomial
+    DEFAULT_POLY = 0x42F0E1EBA9EA3693
+    # Default Seed for 64-bit CRC
+    DEFAULT_SEED = 0xFFFFFFFFFFFFFFFF
+
+    # Creates a 64 bit CRC algorithm instance. By default it is initialzed to
+    # use the algorithm.
+    #
+    # @param poly [Integer] Polynomial to use when calculating the CRC
+    # @param seed [Integer] Seed value to start the calculation
+    # @param xor [Boolean] Whether to XOR the CRC result with 0xFFFF
+    # @param reflect [Boolean] Whether to bit reverse each byte of data before
+    #   calculating the CRC
+    def initialize(poly = DEFAULT_POLY,
+                   seed = DEFAULT_SEED,
+                   xor = true,
+                   reflect = true)
+      super(poly, seed, xor, reflect)
+    end
+
+    alias calculate_crc64 calc
+  end
+end

data/lib/openc3/utilities/csv.rb

@@ -0,0 +1,153 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'csv'
+
+module OpenC3
+  # Reads in a comma separated values (CSV) configuration file and
+  # allows access via the Hash bracket syntax. It allows the user to write
+  # back data to the configuration file to store state.
+  class CSV
+    # @return [String] The name of the archive file
+    attr_reader :archive_file
+
+    # @param input_file [String] CSV filename to read
+    def initialize(input_file)
+      @filename = input_file
+      @hash = {}
+      @archive = nil
+      @archive_file = ""
+      Object::CSV.read(input_file).each do |line|
+        next if line[0].strip()[0] == '#' # Ignore Ruby comment lines
+
+        @hash[line[0]] = line[1..-1]
+      end
+    end
+
+    # @return [Array<String>] All the values in the first column of the CSV file.
+    #   These values are used as keys to access the data in columns 2-n.
+    def keys
+      @hash.keys
+    end
+
+    # @return [Array<String>] The values in columns 2-n corresponding to the
+    #   given key in column 1. The values are always returned as Strings so the
+    #   user must convert if necessary.
+    def [](index)
+      @hash[index]
+    end
+
+    # Convenience method to access a value by key and convert it to a boolean.
+    # The csv value must be 'TRUE' or 'FALSE' (case doesn't matter)
+    # and will be converted to Ruby true or false values.
+    #
+    # @param item [String] Key to access the value
+    # @param index [Integer] Which value to return
+    # @return [Boolean] Single value converted to a boolean (true or false)
+    def bool(item, index = 0)
+      raise "#{item} not found" unless keys.include?(item)
+
+      if Range === index
+        @hash[item][index].map do |x|
+          case x.upcase
+          when 'TRUE'
+            true
+          when 'FALSE'
+            false
+          else
+            raise "#{item} value of #{x} not boolean. Must be 'TRUE' 'or 'FALSE'."
+          end
+        end
+      else
+        case @hash[item][index].upcase
+        when 'TRUE'
+          true
+        when 'FALSE'
+          false
+        else
+          raise "#{item} value of #{@hash[item][index]} not boolean. Must be 'TRUE' 'or 'FALSE'."
+        end
+      end
+    end
+    alias boolean bool
+
+    # Convenience method to access a value by key and convert it to an integer
+    #
+    # @param item [String] Key to access the value
+    # @param index [Integer] Which value to return
+    # @return [Integer] Single value converted to an integer
+    def int(item, index = 0)
+      raise "#{item} not found" unless keys.include?(item)
+
+      if Range === index
+        @hash[item][index].map { |x| x.to_i }
+      else
+        @hash[item][index].to_i
+      end
+    end
+    alias integer int
+
+    # Convenience method to access a value by key and convert it to a float
+    #
+    # @param item [String] Key to access the value
+    # @param index [Integer] Which value to return
+    # @return [Float] Single value converted to a float
+    def float(item, index = 0)
+      raise "#{item} not found" unless keys.include?(item)
+
+      if Range === index
+        @hash[item][index].map { |x| x.to_f }
+      else
+        @hash[item][index].to_f
+      end
+    end
+
+    # Convenience method to access a value by key and convert it to a string
+    #
+    # @param item [String] Key to access the value
+    # @param index [Integer] Which value to return
+    # @return [String] Single value converted to a string
+    def string(item, index = 0)
+      raise "#{item} not found" unless keys.include?(item)
+
+      if Range === index
+        @hash[item][index].map { |x| x.to_s }
+      else
+        @hash[item][index].to_s
+      end
+    end
+    alias str string
+
+    # Convenience method to access a value by key and convert it to a symbol
+    #
+    # @param item [String] Key to access the value
+    # @param index [Integer] Which value to return
+    # @return [Symbol] Single value converted to a symbol
+    def symbol(item, index = 0)
+      raise "#{item} not found" unless keys.include?(item)
+
+      if Range === index
+        @hash[item][index].map { |x| x.intern }
+      else
+        @hash[item][index].intern
+      end
+    end
+    alias sym symbol
+  end
+end