env_parser 1.3.1 → 1.3.2

data/lib/env_parser.rb

@@ -3,44 +3,44 @@ require 'env_parser/version'
 require 'active_support/all'
 require 'psych'
 
-## The EnvParser class simplifies parsing of environment variables as different data types.
-##
+# The EnvParser class simplifies parsing of environment variables as different data types.
+#
 class EnvParser
-  ## The default filename to use for {.autoregister} requests.
-  ##
+  # The default filename to use for {.autoregister} requests.
+  #
   AUTOREGISTER_FILE = '.env_parser.yml'.freeze
 
   class << self
-    ## Defines a new type for use as the "as" option on a subsequent {.parse} or {.register} call.
-    ##
-    ## @param name [Symbol]
-    ##   The name to assign to the type.
-    ##
-    ## @option options [Array<Symbol>] aliases
-    ##   An array of additional names you'd like to see refer to this same type.
-    ##
-    ## @option options if_unset (nil)
-    ##   Specifies a "sensible default" to return for this type if the value being parsed (via
-    ##   {.parse} or {.register}) is either unset (`nil`) or blank (`''`). Note this may be
-    ##   overridden by the user via the {.parse}/{.register} "if_unset" option.
-    ##
-    ## @yield [value]
-    ##   A block to act as the parser for the this type. If no block is given, an ArgumentError is
-    ##   raised.
-    ##
-    ##   When the type defined is used via a {.parse}/{.register} call, this block is invoked with
-    ##   the value to be parsed. Said value is guaranteed to be a non-empty String (the "if_unset"
-    ##   check will have already run), but no other assurances as to content are given. The block
-    ##   should return the final output of parsing the given String value as the type being defined.
-    ##
-    ##   If the value given cannot be sensibly parsed into the type defined, the block should raise
-    ##   an {EnvParser::ValueNotConvertibleError}.
-    ##
-    ## @return [nil]
-    ##   This generates no usable value.
-    ##
-    ## @raise [ArgumentError, EnvParser::TypeAlreadyDefinedError]
-    ##
+    # Defines a new type for use as the "as" option on a subsequent {.parse} or {.register} call.
+    #
+    # @param name [Symbol]
+    #   The name to assign to the type.
+    #
+    # @option options [Array<Symbol>] aliases
+    #   An array of additional names you'd like to see refer to this same type.
+    #
+    # @option options if_unset (nil)
+    #   Specifies a "sensible default" to return for this type if the value being parsed (via
+    #   {.parse} or {.register}) is either unset (`nil`) or blank (`''`). Note this may be
+    #   overridden by the user via the {.parse}/{.register} "if_unset" option.
+    #
+    # @yield [value]
+    #   A block to act as the parser for the this type. If no block is given, an ArgumentError is
+    #   raised.
+    #
+    #   When the type defined is used via a {.parse}/{.register} call, this block is invoked with
+    #   the value to be parsed. Said value is guaranteed to be a non-empty String (the "if_unset"
+    #   check will have already run), but no other assurances as to content are given. The block
+    #   should return the final output of parsing the given String value as the type being defined.
+    #
+    #   If the value given cannot be sensibly parsed into the type defined, the block should raise
+    #   an {EnvParser::ValueNotConvertibleError}.
+    #
+    # @return [nil]
+    #   This generates no usable value.
+    #
+    # @raise [ArgumentError, EnvParser::TypeAlreadyDefinedError]
+    #
     def define_type(name, options = {}, &parser)
       raise(ArgumentError, 'no parsing block given') unless block_given?
 
@@ -57,58 +57,58 @@ class EnvParser
       nil
     end
 
-    ## Interprets the given value as the specified type.
-    ##
-    ## @param value [String, Symbol]
-    ##   The value to parse/interpret. If a String is given, the value will be used as-is. If a
-    ##   Symbol is given, the ENV value for the matching string key will be used.
-    ##
-    ## @option options [Symbol] as
-    ##   The expected return type. A best-effort attempt is made to convert the source String to the
-    ##   requested type.
-    ##
-    ##   If no "as" option is given, an ArgumentError is raised. If the "as" option given is unknown
-    ##   (the given type has not been previously defined via {.define_type}), an
-    ##   {EnvParser::UnknownTypeError} is raised.
-    ##
-    ## @option options if_unset
-    ##   Specifies the default value to return if the given "value" is either unset (`nil`) or blank
-    ##   (`''`). Any "if_unset" value given will be returned as-is, with no type conversion or other
-    ##   change having been made.  If unspecified, the "default" value for `nil`/`''` input will
-    ##   depend on the "as" type.
-    ##
-    ## @option options [Array, Range] from_set
-    ##   Gives a limited set of allowed values (after type conversion). If, after parsing, the final
-    ##   value is not included in the "from_set" list/range, an {EnvParser::ValueNotAllowedError} is
-    ##   raised.
-    ##
-    ##   Note that if the "if_unset" option is given and the value to parse is `nil`/`''`, the
-    ##   "if_unset" value will be returned, even if it is not part of the "from_set" list/range.
-    ##
-    ##   Also note that, due to the nature of the lookup, the "from_set" option is only available
-    ##   for scalar values (i.e. not arrays, hashes, or other enumerables). An attempt to use the
-    ##   "from_set" option with a non-scalar value will raise an ArgumentError.
-    ##
-    ## @option options [Proc] validated_by
-    ##   If given, the "validated_by" Proc is called with the parsed value (after type conversion)
-    ##   as its sole argument. This allows for user-defined validation of the parsed value beyond
-    ##   what can be enforced by use of the "from_set" option alone. If the Proc's return value is
-    ##   `#blank?`, an {EnvParser::ValueNotAllowedError} is raised. To accomodate your syntax of
-    ##   choice, this validation Proc may be given as a block instead.
-    ##
-    ##   Note that this option is intended to provide an inspection mechanism only -- no mutation
-    ##   of the parsed value should occur within the given Proc. To that end, the argument passed is
-    ##   a *frozen* duplicate of the parsed value.
-    ##
-    ## @yield [value]
-    ##   A block (if given) is treated exactly as the "validated_by" Proc would.
-    ##
-    ##   Although there is no compelling reason to provide both a "validated_by" Proc *and* a
-    ##   validation block, there is no technical limitation preventing this. **If both are given,
-    ##   both validation checks must pass.**
-    ##
-    ## @raise [ArgumentError, EnvParser::UnknownTypeError, EnvParser::ValueNotAllowedError]
-    ##
+    # Interprets the given value as the specified type.
+    #
+    # @param value [String, Symbol]
+    #   The value to parse/interpret. If a String is given, the value will be used as-is. If a
+    #   Symbol is given, the ENV value for the matching string key will be used.
+    #
+    # @option options [Symbol] as
+    #   The expected return type. A best-effort attempt is made to convert the source String to the
+    #   requested type.
+    #
+    #   If no "as" option is given, an ArgumentError is raised. If the "as" option given is unknown
+    #   (the given type has not been previously defined via {.define_type}), an
+    #   {EnvParser::UnknownTypeError} is raised.
+    #
+    # @option options if_unset
+    #   Specifies the default value to return if the given "value" is either unset (`nil`) or blank
+    #   (`''`). Any "if_unset" value given will be returned as-is, with no type conversion or other
+    #   change having been made.  If unspecified, the "default" value for `nil`/`''` input will
+    #   depend on the "as" type.
+    #
+    # @option options [Array, Range] from_set
+    #   Gives a limited set of allowed values (after type conversion). If, after parsing, the final
+    #   value is not included in the "from_set" list/range, an {EnvParser::ValueNotAllowedError} is
+    #   raised.
+    #
+    #   Note that if the "if_unset" option is given and the value to parse is `nil`/`''`, the
+    #   "if_unset" value will be returned, even if it is not part of the "from_set" list/range.
+    #
+    #   Also note that, due to the nature of the lookup, the "from_set" option is only available
+    #   for scalar values (i.e. not arrays, hashes, or other enumerables). An attempt to use the
+    #   "from_set" option with a non-scalar value will raise an ArgumentError.
+    #
+    # @option options [Proc] validated_by
+    #   If given, the "validated_by" Proc is called with the parsed value (after type conversion)
+    #   as its sole argument. This allows for user-defined validation of the parsed value beyond
+    #   what can be enforced by use of the "from_set" option alone. If the Proc's return value is
+    #   `#blank?`, an {EnvParser::ValueNotAllowedError} is raised. To accomodate your syntax of
+    #   choice, this validation Proc may be given as a block instead.
+    #
+    #   Note that this option is intended to provide an inspection mechanism only -- no mutation
+    #   of the parsed value should occur within the given Proc. To that end, the argument passed is
+    #   a *frozen* duplicate of the parsed value.
+    #
+    # @yield [value]
+    #   A block (if given) is treated exactly as the "validated_by" Proc would.
+    #
+    #   Although there is no compelling reason to provide both a "validated_by" Proc *and* a
+    #   validation block, there is no technical limitation preventing this. **If both are given,
+    #   both validation checks must pass.**
+    #
+    # @raise [ArgumentError, EnvParser::UnknownTypeError, EnvParser::ValueNotAllowedError]
+    #
     def parse(value, options = {}, &validation_block)
       value = ENV[value.to_s] if value.is_a? Symbol
       value = value.to_s
@@ -126,57 +126,57 @@ class EnvParser
       value
     end
 
-    ## Parses the referenced value and creates a matching constant in the requested context.
-    ##
-    ## Multiple calls to {.register} may be shortcutted by passing in a Hash whose keys are the
-    ## variable names and whose values are the options set for each variable's {.register} call.
-    ##
-    ## <pre>
-    ##   ## Example shortcut usage:
-    ##
-    ##   EnvParser.register :A, from: one_hash, as: :integer
-    ##   EnvParser.register :B, from: another_hash, as: :string, if_unset: 'none'
-    ##
-    ##   ## ... is equivalent to ...
-    ##
-    ##   EnvParser.register(
-    ##     A: { from: one_hash, as: :integer }
-    ##     B: { from: another_hash, as: :string, if_unset: 'none' }
-    ##   )
-    ## </pre>
-    ##
-    ## @param name
-    ##   The name of the value to parse/interpret from the "from" Hash. If the "from" value is
-    ##   `ENV`, you may give a Symbol and the corresponding String key will be used instead.
-    ##
-    ## @option options [Hash] from (ENV)
-    ##   The source Hash from which to pull the value referenced by the "name" key.
-    ##
-    ## @option options [Module, Class] within (Kernel)
-    ##   The module or class in which the constant should be created. Creates global constants by
-    ##   default.
-    ##
-    ## @option options [Symbol] as
-    ##   See {.parse}.
-    ##
-    ## @option options if_unset
-    ##   See {.parse}.
-    ##
-    ## @option options [Array, Range] from_set
-    ##   See {.parse}.
-    ##
-    ## @option options [Proc] validated_by
-    ##   See {.parse}.
-    ##
-    ## @yield [value]
-    ##   A block (if given) is treated exactly as in {.parse}. Note, however, that a single block
-    ##   cannot be used to register multiple constants simultaneously -- each value needing
-    ##   validation must give its own "validated_by" Proc.
-    ##
-    ## @raise [ArgumentError]
-    ##
+    # Parses the referenced value and creates a matching constant in the requested context.
+    #
+    # Multiple calls to {.register} may be shortcutted by passing in a Hash whose keys are the
+    # variable names and whose values are the options set for each variable's {.register} call.
+    #
+    # <pre>
+    #   ## Example shortcut usage:
+    #
+    #   EnvParser.register :A, from: one_hash, as: :integer
+    #   EnvParser.register :B, from: another_hash, as: :string, if_unset: 'none'
+    #
+    #   ## ... is equivalent to ...
+    #
+    #   EnvParser.register(
+    #     A: { from: one_hash, as: :integer }
+    #     B: { from: another_hash, as: :string, if_unset: 'none' }
+    #   )
+    # </pre>
+    #
+    # @param name
+    #   The name of the value to parse/interpret from the "from" Hash. If the "from" value is
+    #   `ENV`, you may give a Symbol and the corresponding String key will be used instead.
+    #
+    # @option options [Hash] from (ENV)
+    #   The source Hash from which to pull the value referenced by the "name" key.
+    #
+    # @option options [Module, Class] within (Kernel)
+    #   The module or class in which the constant should be created. Creates global constants by
+    #   default.
+    #
+    # @option options [Symbol] as
+    #   See {.parse}.
+    #
+    # @option options if_unset
+    #   See {.parse}.
+    #
+    # @option options [Array, Range] from_set
+    #   See {.parse}.
+    #
+    # @option options [Proc] validated_by
+    #   See {.parse}.
+    #
+    # @yield [value]
+    #   A block (if given) is treated exactly as in {.parse}. Note, however, that a single block
+    #   cannot be used to register multiple constants simultaneously -- each value needing
+    #   validation must give its own "validated_by" Proc.
+    #
+    # @raise [ArgumentError]
+    #
     def register(name, options = {}, &validation_block)
-      ## Allow for registering multiple variables simultaneously via a single call.
+      # Allow for registering multiple variables simultaneously via a single call.
       if name.is_a? Hash
         raise(ArgumentError, 'cannot register multiple values with one block') if block_given?
         return register_all(name)
@@ -185,20 +185,17 @@ class EnvParser
       from = options.fetch(:from, ENV)
       within = options.fetch(:within, Kernel)
 
-      ## ENV *seems* like a Hash and it does *some* Hash-y things, but it is NOT a Hash and that can
-      ## bite you in some cases. Making sure we're working with a straight-up Hash saves a lot of
-      ## sanity checks later on. This is also a good place to make sure we're working with a String
-      ## key.
+      # ENV *seems* like a Hash and it does *some* Hash-y things, but it is NOT a Hash and that can
+      # bite you in some cases. Making sure we're working with a straight-up Hash saves a lot of
+      # sanity checks later on. This is also a good place to make sure we're working with a String
+      # key.
       if from == ENV
         from = from.to_h
         name = name.to_s
       end
 
       raise ArgumentError, "invalid `from` parameter: #{from.class}" unless from.is_a? Hash
-
-      unless within.is_a?(Module) || within.is_a?(Class)
-        raise ArgumentError, "invalid `within` parameter: #{within.inspect}"
-      end
+      raise ArgumentError, "invalid `within` parameter: #{within.inspect}" unless within.is_a?(Module) || within.is_a?(Class)
 
       value = from[name]
       value = parse(value, options, &validation_block)
@@ -207,15 +204,15 @@ class EnvParser
       value
     end
 
-    ## Creates ENV bindings for {.parse} and {.register} proxy methods.
-    ##
-    ## The sole difference between these proxy methods and their EnvParser counterparts is that
-    ## ENV.parse will interpret any value given as an ENV key (as a String), not the given value
-    ## itself.  i.e. ENV.parse('XYZ', ...) is equivalent to EnvParser.parse(ENV['XYZ'], ...)
-    ##
-    ## @return [ENV]
-    ##   This generates no usable value.
-    ##
+    # Creates ENV bindings for {.parse} and {.register} proxy methods.
+    #
+    # The sole difference between these proxy methods and their EnvParser counterparts is that
+    # ENV.parse will interpret any value given as an ENV key (as a String), not the given value
+    # itself.  i.e. ENV.parse('XYZ', ...) is equivalent to EnvParser.parse(ENV['XYZ'], ...)
+    #
+    # @return [ENV]
+    #   This generates no usable value.
+    #
     def add_env_bindings
       ENV.instance_eval do
         def parse(name, options = {}, &validation_block)
@@ -230,21 +227,21 @@ class EnvParser
       ENV
     end
 
-    ## Reads an "autoregister" file and registers the ENV constants defined therein.
-    ##
-    ## The "autoregister" file is read, parsed as YAML, sanitized for use as a parameter to
-    ## {.register_all}, and then passed along for processing. The return value from that
-    ## {.register_all} call is passed through.
-    ##
-    ## @param filename [String]
-    ##   A path for the autoregister file to parse and process. Defaults to
-    ##   {EnvParser::AUTOREGISTER_FILE} if unset.
-    ##
-    ## @return [Hash]
-    ##   The return value from the {.register_all} call that handles the actual registration.
-    ##
-    ## @raise [EnvParser::AutoregisterFileNotFound, EnvParser::UnparseableAutoregisterSpec]
-    ##
+    # Reads an "autoregister" file and registers the ENV constants defined therein.
+    #
+    # The "autoregister" file is read, parsed as YAML, sanitized for use as a parameter to
+    # {.register_all}, and then passed along for processing. The return value from that
+    # {.register_all} call is passed through.
+    #
+    # @param filename [String]
+    #   A path for the autoregister file to parse and process. Defaults to
+    #   {EnvParser::AUTOREGISTER_FILE} if unset.
+    #
+    # @return [Hash]
+    #   The return value from the {.register_all} call that handles the actual registration.
+    #
+    # @raise [EnvParser::AutoregisterFileNotFound, EnvParser::UnparseableAutoregisterSpec]
+    #
     def autoregister(filename = nil)
       filename ||= AUTOREGISTER_FILE
       autoregister_spec = Psych.load_file(filename)
@@ -260,58 +257,53 @@ class EnvParser
 
       register_all autoregister_spec
 
-    ## Psych raises an Errno::ENOENT on file-not-found.
-    ##
+    # Psych raises an Errno::ENOENT on file-not-found.
+    #
     rescue Errno::ENOENT
       raise EnvParser::AutoregisterFileNotFound, %(file not found: "#{filename}")
 
-    ## Psych raises a Psych::SyntaxError on unparseable YAML.
-    ##
+    # Psych raises a Psych::SyntaxError on unparseable YAML.
+    #
     rescue Psych::SyntaxError => e
       raise EnvParser::UnparseableAutoregisterSpec, "malformed YAML in spec file: #{e.message}"
     end
 
     private
 
-    ## Class instance variable for storing known type data.
-    ##
+    # Class instance variable for storing known type data.
+    #
     def known_types
       @known_types ||= {}
     end
 
-    ## Verifies that the given "value" is included in the "set".
-    ##
-    ## @param value
-    ## @param set [Array, Range]
-    ##
-    ## @return [nil]
-    ##   This generates no usable value.
-    ##
-    ## @raise [ArgumentError, EnvParser::ValueNotAllowedError]
-    ##
+    # Verifies that the given "value" is included in the "set".
+    #
+    # @param value
+    # @param set [Array, Range]
+    #
+    # @return [nil]
+    #   This generates no usable value.
+    #
+    # @raise [ArgumentError, EnvParser::ValueNotAllowedError]
+    #
     def check_for_set_inclusion(value, set: nil)
-      if value.respond_to?(:each)
-        raise ArgumentError, "`from_set` option is not compatible with #{value.class} values"
-      end
-
-      unless set.is_a?(Array) || set.is_a?(Range)
-        raise ArgumentError, "invalid `from_set` parameter type: #{set.class}"
-      end
+      raise ArgumentError, "`from_set` option is not compatible with #{value.class} values" if value.respond_to?(:each)
+      raise ArgumentError, "invalid `from_set` parameter type: #{set.class}" unless set.is_a?(Array) || set.is_a?(Range)
 
       raise(ValueNotAllowedError, 'parsed value not in allowed set') unless set.include?(value)
     end
 
-    ## Verifies that the given "value" passes both the "proc" and "block" validations.
-    ##
-    ## @param value
-    ## @param proc [Proc, nil]
-    ## @param block [Proc, nil]
-    ##
-    ## @return [nil]
-    ##   This generates no usable value.
-    ##
-    ## @raise [EnvParser::ValueNotAllowedError]
-    ##
+    # Verifies that the given "value" passes both the "proc" and "block" validations.
+    #
+    # @param value
+    # @param proc [Proc, nil]
+    # @param block [Proc, nil]
+    #
+    # @return [nil]
+    #   This generates no usable value.
+    #
+    # @raise [EnvParser::ValueNotAllowedError]
+    #
     def check_user_defined_validations(value, proc: nil, block: nil)
       immutable_value = value.dup.freeze
       all_tests_passed = [proc, block].compact.all? { |i| i.call(immutable_value) }
@@ -319,15 +311,15 @@ class EnvParser
       raise(ValueNotAllowedError, 'parsed value failed user validation') unless all_tests_passed
     end
 
-    ## Receives a list of {.register} calls to make, as a Hash keyed with variable names and the
-    ## values being each {.register} call's option set.
-    ##
-    ## @param list [Hash]
-    ##
-    ## @return [Hash]
-    ##
-    ## @raise [ArgumentError]
-    ##
+    # Receives a list of {.register} calls to make, as a Hash keyed with variable names and the
+    # values being each {.register} call's option set.
+    #
+    # @param list [Hash]
+    #
+    # @return [Hash]
+    #
+    # @raise [ArgumentError]
+    #
     def register_all(list)
       raise(ArgumentError, "invalid 'list' parameter type: #{list.class}") unless list.is_a? Hash
 
@@ -338,6 +330,6 @@ class EnvParser
   end
 end
 
-## Load predefined types.
-##
+# Load predefined types.
+#
 require 'env_parser/types'

data/spec/env_parser/types/base_types_spec.rb

@@ -0,0 +1,98 @@
+RSpec.describe EnvParser::Types::BaseTypes do
+  it 'can parse strings' do
+    expect(EnvParser.parse(nil, as: :string)).to eq('')
+    expect(EnvParser.parse('', as: :string)).to eq('')
+
+    expect(EnvParser.parse('value', as: :string)).to eq('value')
+  end
+
+  it 'can parse symbols' do
+    expect(EnvParser.parse(nil, as: :symbol)).to eq(:'')
+    expect(EnvParser.parse('', as: :symbol)).to eq(:'')
+
+    expect(EnvParser.parse('value', as: :symbol)).to eq(:value)
+  end
+
+  it 'can parse booleans' do
+    expect(EnvParser.parse(nil, as: :boolean)).to eq(false)
+    expect(EnvParser.parse('', as: :boolean)).to eq(false)
+
+    expect(EnvParser.parse('0', as: :boolean)).to eq(false)
+    expect(EnvParser.parse('f', as: :boolean)).to eq(false)
+    expect(EnvParser.parse('false', as: :boolean)).to eq(false)
+
+    expect(EnvParser.parse('1', as: :boolean)).to eq(true)
+    expect(EnvParser.parse('t', as: :boolean)).to eq(true)
+    expect(EnvParser.parse('true', as: :boolean)).to eq(true)
+  end
+
+  it 'can parse integers' do
+    %i[int integer].each do |type|
+      expect(EnvParser.parse(nil, as: type)).to eq(0)
+      expect(EnvParser.parse('', as: type)).to eq(0)
+
+      expect(EnvParser.parse('-1.9', as: type)).to eq(-1)
+      expect(EnvParser.parse('-1.1', as: type)).to eq(-1)
+      expect(EnvParser.parse('-1', as: type)).to eq(-1)
+      expect(EnvParser.parse('0', as: type)).to eq(0)
+      expect(EnvParser.parse('1', as: type)).to eq(1)
+      expect(EnvParser.parse('1.1', as: type)).to eq(1)
+      expect(EnvParser.parse('1.9', as: type)).to eq(1)
+
+      expect(EnvParser.parse('non-numeric', as: type)).to eq(0)
+    end
+  end
+
+  it 'can parse floats' do
+    %i[float decimal number].each do |type|
+      expect(EnvParser.parse(nil, as: type)).to eq(0.0)
+      expect(EnvParser.parse('', as: type)).to eq(0.0)
+
+      expect(EnvParser.parse('-1.9', as: type)).to eq(-1.9)
+      expect(EnvParser.parse('-1.1', as: type)).to eq(-1.1)
+      expect(EnvParser.parse('-1', as: type)).to eq(-1.0)
+      expect(EnvParser.parse('0', as: type)).to eq(0.0)
+      expect(EnvParser.parse('1', as: type)).to eq(1.0)
+      expect(EnvParser.parse('1.1', as: type)).to eq(1.1)
+      expect(EnvParser.parse('1.9', as: type)).to eq(1.9)
+
+      expect(EnvParser.parse('non-numeric', as: type)).to eq(0.0)
+    end
+  end
+
+  it 'can parse json' do
+    expect(EnvParser.parse(nil, as: :json)).to eq(nil)
+    expect(EnvParser.parse('', as: :json)).to eq(nil)
+
+    expect { EnvParser.parse('non-json-parseable string', as: :json) }.to raise_error(JSON::ParserError)
+
+    expect(EnvParser.parse('null', as: :json)).to eq(nil)
+    expect(EnvParser.parse('true', as: :json)).to eq(true)
+    expect(EnvParser.parse('false', as: :json)).to eq(false)
+    expect(EnvParser.parse('1', as: :json)).to eq(1)
+    expect(EnvParser.parse('1.1', as: :json)).to eq(1.1)
+    expect(EnvParser.parse('"some string"', as: :json)).to eq('some string')
+    expect(EnvParser.parse('["one", 2, "three"]', as: :json)).to eq(['one', 2, 'three'])
+    expect(EnvParser.parse('{ "one": 1, "two": 2, "three": "three" }', as: :json)).to eq('one' => 1, 'two' => 2, 'three' => 'three')
+  end
+
+  it 'can parse arrays' do
+    expect(EnvParser.parse(nil, as: :array)).to eq([])
+    expect(EnvParser.parse('', as: :array)).to eq([])
+
+    expect { EnvParser.parse('non-json-parseable string', as: :array) }.to raise_error(JSON::ParserError)
+    expect { EnvParser.parse('"parseable json, but not an array"', as: :array) }.to raise_error(EnvParser::ValueNotConvertibleError)
+
+    expect(EnvParser.parse('["one", 2, "three"]', as: :array)).to eq(['one', 2, 'three'])
+  end
+
+  it 'can parse hashes' do
+    expect(EnvParser.parse(nil, as: :hash)).to eq({})
+    expect(EnvParser.parse('', as: :hash)).to eq({})
+
+    expect { EnvParser.parse('non-json-parseable string', as: :hash) }.to raise_error(JSON::ParserError)
+    expect { EnvParser.parse('"parseable json, but not a hash"', as: :hash) }.to raise_error(EnvParser::ValueNotConvertibleError)
+
+    expect(EnvParser.parse('{ "one": 1, "two": 2, "three": "three" }', as: :hash)).to eq('one' => 1, 'two' => 2, 'three' => 'three')
+  end
+end

data/spec/env_parser/types/chronology_types_spec.rb

@@ -0,0 +1,49 @@
+RSpec.describe EnvParser::Types::ChronologyTypes do
+  it 'can parse dates' do
+    expect(EnvParser.parse(nil, as: :date)).to eq(nil)
+    expect(EnvParser.parse('', as: :date)).to eq(nil)
+
+    expect(EnvParser.parse('11/05/1955 06:00', as: :date)).to eq(Date.new(1955, 11, 5))
+    expect(EnvParser.parse('11/12/1955 22:04', as: :date)).to eq(Date.new(1955, 11, 12))
+    expect(EnvParser.parse('1885-09-02 08:00', as: :date)).to eq(Date.new(1885, 9, 2))
+    expect(EnvParser.parse('1885-09-07', as: :date)).to eq(Date.new(1885, 9, 7))
+
+    expect(EnvParser.parse('tomorrow', as: :date)).to eq(Date.today + 1.day)
+
+    expect { EnvParser.parse('not a date', as: :date) }.to raise_error(EnvParser::ValueNotConvertibleError)
+    expect { EnvParser.parse('2018-02-29', as: :date) }.to raise_error(EnvParser::ValueNotConvertibleError)
+  end
+
+  it 'can parse times' do
+    %i[time datetime].each do |type|
+      expect(EnvParser.parse(nil, as: type)).to eq(nil)
+      expect(EnvParser.parse('', as: type)).to eq(nil)
+
+      expect(EnvParser.parse('11/05/1955 06:00', as: type)).to eq(Time.new(1955, 11, 5, 6, 0))
+      expect(EnvParser.parse('11/12/1955 22:04', as: type)).to eq(Time.new(1955, 11, 12, 22, 4))
+      expect(EnvParser.parse('1885-09-02 08:00', as: type)).to eq(Time.new(1885, 9, 2, 8, 0))
+      expect(EnvParser.parse('1885-09-07', as: type)).to eq(Time.new(1885, 9, 7))
+
+      expect(EnvParser.parse('today at 07:15', as: type)).to eq(Date.today + 7.hours + 15.minutes)
+
+      expect { EnvParser.parse('not a date/time', as: type) }.to raise_error(EnvParser::ValueNotConvertibleError)
+      expect { EnvParser.parse('today at 33:25', as: type) }.to raise_error(EnvParser::ValueNotConvertibleError)
+    end
+  end
+
+  it 'can parse durations' do
+    expect(EnvParser.parse(nil, as: :duration)).to eq(nil)
+    expect(EnvParser.parse('', as: :duration)).to eq(nil)
+
+    expect(EnvParser.parse('12 seconds', as: :duration)).to eq(12)
+    expect(EnvParser.parse('5 minutes', as: :duration)).to eq(5 * 60)
+    expect(EnvParser.parse('24 hours', as: :duration)).to eq(24 * 60 * 60)
+    expect(EnvParser.parse('1.5 days', as: :duration)).to eq(1.5 * 24 * 60 * 60)
+    expect(EnvParser.parse('1 day', as: :duration)).to eq(24 * 60 * 60)
+    expect(EnvParser.parse('2 weeks, 1 day', as: :duration)).to eq((2 * 7 * 24 * 60 * 60) + (24 * 60 * 60))
+    expect(EnvParser.parse('P2W1DT3H', as: :duration)).to eq((2 * 7 * 24 * 60 * 60) + (24 * 60 * 60) + (3 * 60 * 60))
+
+    expect { EnvParser.parse('not a duration', as: :duration) }.to raise_error(EnvParser::ValueNotConvertibleError)
+    expect { EnvParser.parse('37 dinglebops', as: :duration) }.to raise_error(EnvParser::ValueNotConvertibleError)
+  end
+end