hocon 0.0.7 → 0.1.0

data/lib/hocon/impl/config_reference.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+require 'hocon'
+require 'hocon/impl'
+require 'hocon/impl/abstract_config_value'
+require 'hocon/impl/resolve_source'
+require 'hocon/impl/resolve_result'
+
+class Hocon::Impl::ConfigReference
+  include Hocon::Impl::Unmergeable
+  include Hocon::Impl::AbstractConfigValue
+
+  NotPossibleToResolve = Hocon::Impl::AbstractConfigValue::NotPossibleToResolve
+  UnresolvedSubstitutionError = Hocon::ConfigError::UnresolvedSubstitutionError
+
+  attr_reader :expr, :prefix_length
+
+  def initialize(origin, expr, prefix_length = 0)
+    super(origin)
+    @expr = expr
+    @prefix_length = prefix_length
+  end
+
+  def unmerged_values
+    [self]
+  end
+
+  # ConfigReference should be a firewall against NotPossibleToResolve going
+  # further up the stack; it should convert everything to ConfigException.
+  # This way it 's impossible for NotPossibleToResolve to "escape" since
+  # any failure to resolve has to start with a ConfigReference.
+  def resolve_substitutions(context, source)
+    new_context = context.add_cycle_marker(self)
+    begin
+      result_with_path = source.lookup_subst(new_context, @expr, @prefix_length)
+      new_context = result_with_path.result.context
+
+      if result_with_path.result.value != nil
+        if Hocon::Impl::ConfigImpl.trace_substitution_enabled
+          Hocon::Impl::ConfigImpl.trace(
+              "recursively resolving #{result_with_path} which was the resolution of #{expr} against #{source}",
+              context.depth)
+        end
+
+        recursive_resolve_source = Hocon::Impl::ResolveSource.new(
+            result_with_path.path_from_root.last, result_with_path.path_from_root)
+
+        if Hocon::Impl::ConfigImpl.trace_substitution_enabled
+          Hocon::Impl::ConfigImpl.trace("will recursively resolve against #{recursive_resolve_source}", context.depth)
+        end
+
+        result = new_context.resolve(result_with_path.result.value,
+                                     recursive_resolve_source)
+        v = result.value
+        new_context = result.context
+      else
+        v = nil
+      end
+    rescue NotPossibleToResolve => e
+      if Hocon::Impl::ConfigImpl.trace_substitution_enabled
+        Hocon::Impl::ConfigImpl.trace(
+            "not possible to resolve #{expr}, cycle involved: #{e.trace_string}", new_context.depth)
+      end
+      if @expr.optional
+        v = nil
+      else
+        raise UnresolvedSubstitutionError.new(
+                  origin,
+                  "#{@expr} was part of a cycle of substitutions involving #{e.trace_string}", e)
+      end
+    end
+
+    if v == nil && !@expr.optional
+      if new_context.options.allow_unresolved
+        ResolveResult.make(new_context.remove_cycle_marker(self), self)
+      else
+        raise UnresolvedSubstitutionError.new(origin, @expr.to_s)
+      end
+    else
+      Hocon::Impl::ResolveResult.make(new_context.remove_cycle_marker(self), v)
+    end
+
+  end
+
+  def value_type
+    raise not_resolved
+  end
+
+  def unwrapped
+    raise not_resolved
+  end
+
+  def new_copy(new_origin)
+    Hocon::Impl::ConfigReference.new(new_origin, @expr, @prefix_length)
+  end
+
+  def ignores_fallbacks?
+    false
+  end
+
+  def resolve_status
+    Hocon::Impl::ResolveStatus::UNRESOLVED
+  end
+
+  def relativized(prefix)
+    new_expr = @expr.change_path(@expr.path.prepend(prefix))
+
+    Hocon::Impl::ConfigReference.new(origin, new_expr, @prefix_length + prefix.length)
+  end
+
+  def can_equal(other)
+    other.is_a? Hocon::Impl::ConfigReference
+  end
+
+  def ==(other)
+    # note that "origin" is deliberately NOT part of equality
+    if other.is_a? Hocon::Impl::ConfigReference
+      can_equal(other) && @expr == other.expr
+    end
+  end
+
+  def hash
+    # note that "origin" is deliberately NOT part of equality
+    @expr.hash
+  end
+
+  def render_value_to_sb(sb, indent, at_root, options)
+    sb << @expr.to_s
+  end
+
+  def expression
+    @expr
+  end
+
+  private
+
+  def not_resolved
+    error_message = "need to Config#resolve, see the API docs for Config#resolve; substitution not resolved: #{self}"
+    Hocon::ConfigError::ConfigNotResolvedError.new(error_message, nil)
+  end
+
+end

data/lib/hocon/impl/config_string.rb

@@ -1,14 +1,59 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 require 'hocon/impl/abstract_config_value'
 require 'hocon/config_value_type'
 require 'hocon/impl/config_impl_util'
 
-class Hocon::Impl::ConfigString < Hocon::Impl::AbstractConfigValue
+class Hocon::Impl::ConfigString
+  include Hocon::Impl::AbstractConfigValue
+
   ConfigImplUtil = Hocon::Impl::ConfigImplUtil
 
-  def initialize(origin, value)
-    super(origin)
-    @value = value
+  attr_reader :value
+
+  class Quoted < Hocon::Impl::ConfigString
+    def initialize(origin, value)
+      super(origin, value)
+    end
+
+    def new_copy(origin)
+      self.class.new(origin, @value)
+    end
+
+    private
+
+    # serialization all goes through SerializedConfigValue
+    def write_replace
+      Hocon::Impl::SerializedConfigValue.new(self)
+    end
+  end
+
+  # this is sort of a hack; we want to preserve whether whitespace
+  # was quoted until we process substitutions, so we can ignore
+  # unquoted whitespace when concatenating lists or objects.
+  # We dump this distinction when serializing and deserializing,
+  # but that 's OK because it isn' t in equals/hashCode, and we
+  # don 't allow serializing unresolved objects which is where
+  # quoted-ness matters. If we later make ConfigOrigin point
+  # to the original token range, we could use that to implement
+  # wasQuoted()
+  class Unquoted < Hocon::Impl::ConfigString
+    def initialize(origin, value)
+      super(origin, value)
+    end
+
+    def new_copy(origin)
+      self.class.new(origin, @value)
+    end
+
+    def write_replace
+      Hocon::Impl::SerializedConfigValue.new(self)
+    end
+  end
+
+  def was_quoted?
+    self.is_a?(Quoted)
   end
 
   def value_type
@@ -31,7 +76,10 @@ class Hocon::Impl::ConfigString < Hocon::Impl::AbstractConfigValue
     end
   end
 
-  def new_copy(origin)
-    Hocon::Impl::ConfigString.new(origin, @value)
+  private
+
+  def initialize(origin, value)
+    super(origin)
+    @value = value
   end
-end
+end

data/lib/hocon/impl/container.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'hocon/impl'
+require 'hocon/config_value'
+require 'hocon/config_error'
+
+# An AbstractConfigValue which contains other values. Java has no way to
+# express "this has to be an AbstractConfigValue also" other than making
+# AbstractConfigValue an interface which would be aggravating. But we can say
+# we are a ConfigValue.
+module Hocon::Impl::Container
+  include Hocon::ConfigValue
+  #
+  # Replace a child of this value. CAUTION if replacement is null, delete the
+  # child, which may also delete the parent, or make the parent into a
+  # non-container.
+  #
+  def replace_child(child, replacement)
+    raise Hocon::ConfigError::ConfigBugOrBrokenError, "subclasses of `Container` must implement `replace_child` (#{self.class})"
+  end
+
+  #
+  # Super-expensive full traversal to see if descendant is anywhere
+  # underneath this container.
+  #
+  def has_descendant?(descendant)
+    raise Hocon::ConfigError::ConfigBugOrBrokenError, "subclasses of `Container` must implement `has_descendant?` (#{self.class})"
+  end
+end

data/lib/hocon/impl/default_transformer.rb

@@ -1,15 +1,21 @@
+# encoding: utf-8
+
 require 'hocon/impl'
+require 'hocon/impl/config_string'
 require 'hocon/config_value_type'
+require 'hocon/impl/config_boolean'
 
 class Hocon::Impl::DefaultTransformer
 
   ConfigValueType = Hocon::ConfigValueType
+  ConfigString = Hocon::Impl::ConfigString
+  ConfigBoolean = Hocon::Impl::ConfigBoolean
 
   def self.transform(value, requested)
-    if value.value == ConfigValueType::STRING
+    if value.value_type == ConfigValueType::STRING
       s = value.unwrapped
       case requested
-        when NUMBER
+        when ConfigValueType::NUMBER
           begin
             v = Integer(s)
             return ConfigInt.new(value.origin, v, s)
@@ -22,21 +28,21 @@ class Hocon::Impl::DefaultTransformer
           rescue ArgumentError
             # oh well.
           end
-        when NULL
+        when ConfigValueType::NULL
           if s == "null"
             return ConfigNull.new(value.origin)
           end
-        when BOOLEAN
+        when ConfigValueType::BOOLEAN
           if s == "true" || s == "yes" || s == "on"
             return ConfigBoolean.new(value.origin, true)
           elsif s == "false" || s == "no" || s == "off"
             return ConfigBoolean.new(value.origin, false)
           end
-        when LIST
+        when ConfigValueType::LIST
           # can't go STRING to LIST automatically
-        when OBJECT
+        when ConfigValueType::OBJECT
           # can't go STRING to OBJECT automatically
-        when STRING
+        when ConfigValueType::STRING
           # no-op STRING to STRING
       end
     elsif requested == ConfigValueType::STRING
@@ -44,17 +50,20 @@ class Hocon::Impl::DefaultTransformer
       # get a missing-value error if you tried to get a null value
       # as a string.
       case value.value_type
-        # NUMBER case removed since you can't fallthrough in a ruby case statement
-        when BOOLEAN
-          return ConfigString.new(value.origin, value.transform_to_string)
-        when NULL
+        # Ruby note: can't fall through in ruby. In the java code, NUMBER
+        # just rolls over to the BOOLEAN case
+        when ConfigValueType::NUMBER
+          return ConfigString::Quoted.new(value.origin, value.transform_to_string)
+        when ConfigValueType::BOOLEAN
+          return ConfigString::Quoted.new(value.origin, value.transform_to_string)
+        when ConfigValueType::NULL
           # want to be sure this throws instead of returning "null" as a
           # string
-        when OBJECT
+        when ConfigValueType::OBJECT
           # no OBJECT to STRING automatically
-        when LIST
+        when ConfigValueType::LIST
           # no LIST to STRING automatically
-        when STRING
+        when ConfigValueType::STRING
           # no-op STRING to STRING
       end
     elsif requested == ConfigValueType::LIST && value.value_type == ConfigValueType::OBJECT
@@ -94,4 +103,4 @@ class Hocon::Impl::DefaultTransformer
     end
     value
   end
-end
+end

data/lib/hocon/impl/from_map_mode.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 require 'hocon/config_error'
 
@@ -10,7 +12,7 @@ module Hocon::Impl::FromMapMode
     case from_map_mode
       when KEYS_ARE_PATHS then "KEYS_ARE_PATHS"
       when KEYS_ARE_KEYS then "KEYS_ARE_KEYS"
-      else raise ConfigBugOrBrokenError.new("Unrecognized FromMapMode #{from_map_mode}", nil)
+      else raise ConfigBugOrBrokenError.new("Unrecognized FromMapMode #{from_map_mode}")
     end
   end
 end

data/lib/hocon/impl/full_includer.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 
 class Hocon::Impl::FullIncluder

data/lib/hocon/impl/memo_key.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'hocon'
+require 'hocon/impl'
+
+class Hocon::Impl::MemoKey
+
+  def initialize(value, restrict_to_child_or_nil)
+    @value = value
+    @restrict_to_child_or_nil = restrict_to_child_or_nil
+  end
+
+  def hash
+    h = @value.hash
+    if @restrict_to_child_or_nil != nil
+      h + 41 * (41 + @restrict_to_child_or_nil.hash)
+    else
+      h
+    end
+  end
+
+  def ==(other)
+    if other.is_a?(self.class)
+      o = other
+      if !o.value.equal?(@value)
+        return false
+      elsif o.restrict_to_child_or_nil.equals(@restrict_to_child_or_nil)
+        return true
+      elsif o.restrict_to_child_or_nil == nil || @restrict_to_child_or_nil == nil
+        return false
+      else
+        return o.restrict_to_child_or_nil == @restrict_to_child_or_nil
+      end
+    else
+      false
+    end
+  end
+
+  def to_s
+    "MemoKey(#{@value}@#{@value.hash},#{@restrict_to_child_or_nil})"
+  end
+end

data/lib/hocon/impl/mergeable_value.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+require 'hocon/impl'
+require 'hocon/config_mergeable'
+
+class Hocon::Impl::MergeableValue < Hocon::ConfigMergeable
+  # TODO
+end

data/lib/hocon/impl/origin_type.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 
 module Hocon::Impl::OriginType
@@ -5,5 +7,9 @@ module Hocon::Impl::OriginType
   GENERIC = 0
   FILE = 1
   #URL = 2
-  #RESOURCE = 3
-end
+  # We don't actually support loading from the classpath / loadpath, which is
+  # what 'RESOURCE' is about in the upstream library.  However, some code paths
+  # still flow through our simplistic implementation of `ParseableResource`, so
+  # we need this constant.
+  RESOURCE = 3
+end

data/lib/hocon/impl/parseable.rb

@@ -1,4 +1,7 @@
+# encoding: utf-8
+
 require 'stringio'
+require 'pathname'
 require 'hocon/impl'
 require 'hocon/config_error'
 require 'hocon/config_syntax'
@@ -7,78 +10,108 @@ require 'hocon/impl/simple_include_context'
 require 'hocon/impl/simple_config_object'
 require 'hocon/impl/simple_config_origin'
 require 'hocon/impl/tokenizer'
-require 'hocon/impl/parser'
+require 'hocon/impl/config_parser'
+require 'hocon/config_parseable'
+require 'hocon/impl/config_document_parser'
+require 'hocon/impl/simple_config_document'
 
+#
+# Internal implementation detail, not ABI stable, do not touch.
+# For use only by the {@link com.typesafe.config} package.
+# The point of this class is to avoid "propagating" each
+# overload on "thing which can be parsed" through multiple
+# interfaces. Most interfaces can have just one overload that
+# takes a Parseable. Also it's used as an abstract "resource
+# handle" in the ConfigIncluder interface.
+#
 class Hocon::Impl::Parseable
-  class ParseableFile < Hocon::Impl::Parseable
-    def initialize(file_path, options)
-      @input = file_path
-      post_construct(options)
-    end
+  include Hocon::ConfigParseable
 
-    def guess_syntax
-      Hocon::Impl::Parseable.syntax_from_extension(File.basename(@input))
+  # Internal implementation detail, not ABI stable, do not touch
+  module Relativizer
+    def relative_to(filename)
+      raise Hocon::ConfigError::ConfigBugOrBrokenError, "subclasses of `Relativizer` must implement `relative_to` (#{self.class})"
     end
+  end
 
-    def create_origin
-      Hocon::Impl::SimpleConfigOrigin.new_file(@input)
-    end
+  # Changed this to a class variable because the upstream library seems to use it
+  # as a global way of keeping track of how many files have been included, to
+  # avoid cycles
+  @@parse_stack= []
 
-    def reader
-      self
-    end
+  MAX_INCLUDE_DEPTH = 50
+
+  def initialize
 
-    def open
-      if block_given?
-        File.open(@input) do |f|
-          yield f
-        end
-      else
-        File.open(@input)
-      end
-    end
   end
 
-  class ParseableString < Hocon::Impl::Parseable
-    def initialize(string, options)
-      @input = string
-      post_construct(options)
+  def fixup_options(base_options)
+    syntax = base_options.syntax
+    if !syntax
+      syntax = guess_syntax
     end
-
-    def create_origin
-      Hocon::Impl::SimpleConfigOrigin.new_simple("String")
+    if !syntax
+      syntax = Hocon::ConfigSyntax::CONF
     end
+    modified = base_options.set_syntax(syntax)
 
-    def reader
-      self
-    end
+    # make sure the app-provided includer falls back to default
+    modified = modified.append_includer(Hocon::Impl::ConfigImpl.default_includer)
+    # make sure the app-provided includer is complete
+    modified = modified.set_includer(Hocon::Impl::SimpleIncluder.make_full(modified.includer))
 
-    def open
-      if block_given?
-        StringIO.open(@input) do |f|
-          yield f
-        end
-      else
-        StringIO.open(@input)
-      end
+    modified
+  end
+
+  def post_construct(base_options)
+    @initial_options = fixup_options(base_options)
+    @include_context = Hocon::Impl::SimpleIncludeContext.new(self)
+    if @initial_options.origin_description
+      @initial_origin = Hocon::Impl::SimpleConfigOrigin.new_simple(@initial_options.origin_description)
+    else
+      @initial_origin = create_origin
     end
+  end
 
+  # the general idea is that any work should be in here, not in the
+  # constructor, so that exceptions are thrown from the public parse()
+  # function and not from the creation of the Parseable.
+  # Essentially this is a lazy field. The parser should close the
+  # reader when it's done with it.
+  #{//}# ALSO, IMPORTANT: if the file or URL is not found, this must throw.
+  #{//}# to support the "allow missing" feature.
+  def custom_reader
+    raise Hocon::ConfigError::ConfigBugOrBrokenError, "subclasses of `Parseable` must implement `custom_reader` (#{self.class})"
   end
 
-  def self.new_file(file_path, options)
-    ParseableFile.new(file_path, options)
+  def reader(options)
+    custom_reader
   end
 
-  def self.new_string(string, options)
-    ParseableString.new(string, options)
+  def self.trace(message)
+    if Hocon::Impl::ConfigImpl.trace_loads_enabled
+      Hocon::Impl::ConfigImpl.trace(message)
+    end
   end
 
   def guess_syntax
     nil
   end
 
-  def options
-    @initial_options
+  def content_type
+    nil
+  end
+
+  def relative_to(filename)
+    # fall back to classpath; we treat the "filename" as absolute
+    # (don't add a package name in front),
+    # if it starts with "/" then remove the "/", for consistency
+    # with ParseableResources.relativeTo
+    resource = filename
+    if filename.start_with?("/")
+      resource = filename.slice(1)
+    end
+    self.class.new_resources(resource, options.set_origin_description(nil))
   end
 
   def include_context
@@ -89,17 +122,40 @@ class Hocon::Impl::Parseable
     if value.is_a? Hocon::Impl::AbstractConfigObject
       value
     else
-      raise Hocon::ConfigError::ConfigWrongTypeError.new(value.origin, "",
+      raise Hocon::ConfigError::ConfigWrongTypeError.with_expected_actual(value.origin,
+                                                         "",
                                                          "object at file root",
                                                          value.value_type.name)
     end
   end
 
-  def parse
-    self.class.force_parsed_to_object(parse_value(options))
+  def parse(base_options = nil)
+    if (base_options.nil?)
+      base_options = options
+    end
+    stack = @@parse_stack
+    if stack.length >= MAX_INCLUDE_DEPTH
+      raise Hocon::ConfigError::ConfigParseError.new(@initial_origin,
+            "include statements nested more than #{MAX_INCLUDE_DEPTH} times, " +
+            "you probably have a cycle in your includes.  Trace: #{stack}",
+            nil)
+    end
+
+    # Push into beginning of stack
+    stack.unshift(self)
+    begin
+      self.class.force_parsed_to_object(parse_value(base_options))
+    ensure
+      # Pop from beginning of stack
+      stack.shift
+    end
   end
 
-  def parse_value(base_options)
+  def parse_value(base_options = nil)
+    if base_options.nil?
+      base_options = options
+    end
+
     # note that we are NOT using our "initialOptions",
     # but using the ones from the passed-in options. The idea is that
     # callers can get our original options and then parse with different
@@ -116,55 +172,49 @@ class Hocon::Impl::Parseable
     parse_value_from_origin(origin, options)
   end
 
-
-  private
-
-  def self.syntax_from_extension(filename)
-    case File.extname(filename)
-      when ".json"
-        Hocon::ConfigSyntax::JSON
-      when ".conf"
-        Hocon::ConfigSyntax::CONF
-      when ".properties"
-        Hocon::ConfigSyntax::PROPERTIES
+  def parse_value_from_origin(origin, final_options)
+    begin
+      raw_parse_value(origin, final_options)
+    rescue IOError => e
+      if final_options.allow_missing?
+        Hocon::Impl::SimpleConfigObject.empty_missing(origin)
       else
-        nil
-    end
-  end
-
-  def post_construct(base_options)
-    @initial_options = fixup_options(base_options)
-    @include_context = Hocon::Impl::SimpleIncludeContext.new(self)
-    if @initial_options.origin_description
-      @initial_origin = SimpleConfigOrigin.new_simple(@initial_options.origin_description)
-    else
-      @initial_origin = create_origin
+        self.class.trace("exception loading #{origin.description}: #{e.class}: #{e.message}")
+        raise Hocon::ConfigError::ConfigIOError.new(origin, "#{e.class.name}: #{e.message}", e)
+      end
     end
   end
 
-  def fixup_options(base_options)
-    syntax = base_options.syntax
-    if !syntax
-      syntax = guess_syntax
-    end
-    if !syntax
-      syntax = Hocon::ConfigSyntax::CONF
+  def parse_document(base_options = nil)
+    if base_options.nil?
+      base_options = options
     end
 
-    modified = base_options.with_syntax(syntax)
-    modified = modified.append_includer(Hocon::Impl::ConfigImpl.default_includer)
-    modified = modified.with_includer(Hocon::Impl::SimpleIncluder.make_full(modified.includer))
+    # note that we are NOT using our "initialOptions",
+    # but using the ones from the passed-in options. The idea is that
+    # callers can get our original options and then parse with different
+    # ones if they want.
+    options = fixup_options(base_options)
 
-    modified
+    # passed-in option can override origin
+    origin = nil
+    if ! options.origin_description.nil?
+      origin = Hocon::Impl::SimpleConfigOrigin.new_simple(options.origin_description)
+    else
+      origin = @initial_origin
+    end
+    parse_document_from_origin(origin, options)
   end
 
-  def parse_value_from_origin(origin, final_options)
+  def parse_document_from_origin(origin, final_options)
     begin
-      raw_parse_value(origin, final_options)
+      raw_parse_document(origin, final_options)
     rescue IOError => e
       if final_options.allow_missing?
-        Hocon::Impl::SimpleConfigObject.empty_missing(origin)
+        Hocon::Impl::SimpleConfigDocument.new(
+          Hocon::Impl::ConfigNodeObject.new([]), final_options)
       else
+        self.class.trace("exception loading #{origin.description}: #{e.class}: #{e.message}")
         raise ConfigIOError.new(origin, "#{e.class.name}: #{e.message}", e)
       end
     end
@@ -173,16 +223,330 @@ class Hocon::Impl::Parseable
   # this is parseValue without post-processing the IOException or handling
   # options.getAllowMissing()
   def raw_parse_value(origin, final_options)
-    ## TODO: if we were going to support loading from URLs, this
-    ##  method would need to deal with the content-type.
+    reader = reader(final_options)
+
+    # after reader() we will have loaded the Content-Type
+    content_type = content_type()
+
+    options_with_content_type = nil
+    if !(content_type.nil?)
+      if Hocon::Impl::ConfigImpl.trace_loads_enabled && (! final_options.get_syntax.nil?)
+        self.class.trace("Overriding syntax #{final_options.get_syntax} with Content-Type which specified #{content-type}")
+      end
+      options_with_content_type = final_options.set_syntax(content_type)
+    else
+      options_with_content_type = final_options
+    end
 
     reader.open { |io|
-      raw_parse_value_from_io(io, origin, final_options)
+      raw_parse_value_from_io(io, origin, options_with_content_type)
     }
   end
 
   def raw_parse_value_from_io(io, origin, final_options)
     tokens = Hocon::Impl::Tokenizer.tokenize(origin, io, final_options.syntax)
-    Hocon::Impl::Parser.parse(tokens, origin, final_options, include_context)
+    document = Hocon::Impl::ConfigDocumentParser.parse(tokens, origin, final_options)
+    Hocon::Impl::ConfigParser.parse(document, origin, final_options, include_context)
+  end
+
+  def raw_parse_document(origin, final_options)
+    reader = reader(final_options)
+    content_type = content_type()
+
+    options_with_content_type = nil
+    if !(content_type.nil?)
+      if Hocon::Impl::ConfigImpl.trace_loads_enabled && (! final_options.get_syntax.nil?)
+        self.class.trace("Overriding syntax #{final_options.get_syntax} with Content-Type which specified #{content-type}")
+      end
+      options_with_content_type = final_options.set_syntax(content_type)
+    else
+      options_with_content_type = final_options
+    end
+
+    reader.open { |io|
+      raw_parse_document_from_io(io, origin, options_with_content_type)
+    }
+  end
+
+  def raw_parse_document_from_io(reader, origin, final_options)
+    tokens = Hocon::Impl::Tokenizer.tokenize(origin, reader, final_options.syntax)
+    Hocon::Impl::SimpleConfigDocument.new(
+                   Hocon::Impl::ConfigDocumentParser.parse(tokens, origin, final_options),
+                   final_options)
+  end
+
+  def parse_config_document
+    parse_document(options)
+  end
+
+  def origin
+    @initial_origin
+  end
+
+  def create_origin
+    raise Hocon::ConfigError::ConfigBugOrBrokenError, "subclasses of `Parseable` must implement `create_origin` (#{self.class})"
+  end
+
+  def options
+    @initial_options
+  end
+
+  def to_s
+    self.class.name.split('::').last
+  end
+
+  def self.syntax_from_extension(name)
+    if name.end_with?(".json")
+      Hocon::ConfigSyntax::JSON
+    elsif name.end_with?(".conf")
+      Hocon::ConfigSyntax::CONF
+    else
+      # Skipping PROPERTIES because we can't really support that in ruby
+      nil
+    end
+  end
+
+  # NOTE: skipping `readerFromStream` and `doNotClose` because they don't seem relevant in Ruby
+
+  # NOTE: skipping `relativeTo(URL, String)` because we're not supporting URLs for now
+  def self.relative_to(file, filename)
+    child = Pathname.new(filename)
+    file = Pathname.new(file)
+
+    if child.absolute?
+      nil
+    end
+
+    parent = file.parent
+
+    if parent.nil?
+      nil
+    else
+      File.join(parent, filename)
+    end
   end
+
+  # this is a parseable that doesn't exist and just throws when you try to parse it
+  class ParseableNotFound < Hocon::Impl::Parseable
+    def initialize(what, message, options)
+      super()
+      @what = what
+      @message = message
+      post_construct(options)
+    end
+
+    def custom_reader
+      raise Hocon::ConfigError::ConfigBugOrBrokenError, @message
+    end
+
+    def create_origin
+      Hocon::Impl::SimpleConfigOrigin.new_simple(@what)
+    end
+  end
+
+  def self.new_not_found(what_not_found, message, options)
+    ParseableNotFound.new(what_not_found, message, options)
+  end
+
+  # NOTE: skipping `ParseableReader` until we know we need it (probably should
+  #  have done that with `ParseableNotFound`)
+
+  class ParseableString < Hocon::Impl::Parseable
+    def initialize(string, options)
+      super()
+      @input = string
+      post_construct(options)
+    end
+
+    def custom_reader
+      if Hocon::Impl::ConfigImpl.trace_loads_enabled
+        self.class.trace("Loading config from a String: #{@input}")
+      end
+      # we return self here, which will cause `open` to be called on us, so
+      # we can provide an implementation of that.
+      self
+    end
+
+    def open
+      if block_given?
+        StringIO.open(@input) do |f|
+          yield f
+        end
+      else
+        StringIO.open(@input)
+      end
+    end
+
+    def create_origin
+      Hocon::Impl::SimpleConfigOrigin.new_simple("String")
+    end
+
+    def to_s
+      "#{self.class.name.split('::').last} (#{@input})"
+    end
+  end
+
+  def self.new_string(string, options)
+    ParseableString.new(string, options)
+  end
+
+  # NOTE: Skipping `ParseableURL` for now as we probably won't support this right away
+
+  class ParseableFile < Hocon::Impl::Parseable
+    def initialize(input, options)
+      super()
+      @input = input
+      post_construct(options)
+    end
+
+    def custom_reader
+      if Hocon::Impl::ConfigImpl.trace_loads_enabled
+        self.class.trace("Loading config from a String: #{@input}")
+      end
+      # we return self here, which will cause `open` to be called on us, so
+      # we can provide an implementation of that.
+      self
+    end
+
+    def open
+      begin
+        if block_given?
+          File.open(@input) do |f|
+            yield f
+          end
+        else
+          File.open(@input)
+        end
+      rescue Errno::ENOENT
+        if @initial_options.allow_missing?
+          return Hocon::Impl::SimpleConfigObject.empty
+        end
+
+        raise Hocon::ConfigError::ConfigIOError.new(nil, "File not found. No file called #{@input}")
+      end
+    end
+
+    def guess_syntax
+      Hocon::Impl::Parseable.syntax_from_extension(File.basename(@input))
+    end
+
+    def relative_to(filename)
+      sibling = nil
+      if Pathname.new(filename).absolute?
+        sibling = File.new(filename)
+      else
+        # this may return nil
+        sibling = Hocon::Impl::Parseable.relative_to(@input, filename)
+      end
+      if sibling.nil?
+        nil
+      elsif File.exists?(sibling)
+        self.class.trace("#{sibling} exists, so loading it as a file")
+        Hocon::Impl::Parseable.new_file(sibling, options.set_origin_description(nil))
+      else
+        self.class.trace("#{sibling} does not exist, so trying it as a resource")
+        super(filename)
+      end
+    end
+
+    def create_origin
+      Hocon::Impl::SimpleConfigOrigin.new_file(@input)
+    end
+
+    def to_s
+      "#{self.class.name.split('::').last} (#{@input})"
+    end
+
+  end
+
+
+  def self.new_file(file_path, options)
+    ParseableFile.new(file_path, options)
+  end
+
+  # NOTE: skipping `ParseableResourceURL`, we probably won't support that
+
+  # NOTE: this is not a faithful port of the `ParseableResources` class from the
+  # upstream, because at least for now we're not going to try to do anything
+  # crazy like look for files on the ruby load path.  However, there is a decent
+  # chunk of logic elsewhere in the codebase that is written with the assumption
+  # that this class will provide the 'last resort' attempt to find a config file
+  # before giving up, so we're basically port just enough to have it provide
+  # that last resort behavior
+  class ParseableResources < Hocon::Impl::Parseable
+    include Relativizer
+
+    def initialize(resource, options)
+      super()
+      @resource = resource
+      post_construct(options)
+    end
+
+    def reader
+      raise Hocon::ConfigError::ConfigBugOrBrokenError, "reader() should not be called on resources"
+    end
+
+    def raw_parse_value(origin, final_options)
+      # this is where the upstream code would go out and look for a file on the
+      # classpath.  We're not going to do that, and instead we're just going to
+      # raise the same exception that the upstream code would raise if it failed
+      # to find the file.
+      raise IOError, "resource not found: #{@resource}"
+    end
+
+    def guess_syntax
+      Hocon::Impl::Parseable.syntax_from_extension(@resource)
+    end
+
+    def self.parent(resource)
+      # the "resource" is not supposed to begin with a "/"
+      # because it's supposed to be the raw resource
+      # (ClassLoader#getResource), not the
+      # resource "syntax" (Class#getResource)
+      i = resource.rindex("/")
+      if i < 0
+        nil
+      else
+        resource.slice(0..i)
+      end
+    end
+
+    def relative_to(sibling)
+      if sibling.start_with?("/")
+        # if it starts with "/" then don't make it relative to the
+        # including resource
+        Hocon::Impl::Parseable.new_resources(sibling.slice(1), options.set_origin_description(nil))
+      else
+        # here we want to build a new resource name and let
+        # the class loader have it, rather than getting the
+        # url with getResource() and relativizing to that url.
+        # This is needed in case the class loader is going to
+        # search a classpath.
+        parent = self.class.parent(@resource)
+        if parent.nil?
+          Hocon::Impl::Parseable.new_resources(sibling, options.set_origin_description(nil))
+        else
+          Hocon::Impl::Parseable.new_resources("#{parent}/sibling", options.set_origin_description(nil))
+        end
+      end
+    end
+
+    def create_origin
+      Hocon::Impl::SimpleConfigOrigin.new_resource(@resource)
+    end
+
+    def to_s
+      "#{self.class.name.split('::').last}(#{@resource})"
+    end
+  end
+
+  def self.new_resources(resource, options)
+    ParseableResources.new(resource, options)
+  end
+
+
+
+
+  # NOTE: skipping `ParseableProperties`, we probably won't support that
+
 end