hocon 0.0.7 → 0.1.0

data/lib/hocon/config_value_type.rb

@@ -1,4 +1,7 @@
+# encoding: utf-8
+
 require 'hocon'
+require 'hocon/config_error'
 
 #
 # The type of a configuration value (following the <a
@@ -20,7 +23,7 @@ module Hocon::ConfigValueType
       when BOOLEAN then "BOOLEAN"
       when NULL then "NULL"
       when STRING then "STRING"
-      else raise ConfigBugError, "Unrecognized value type '#{config_value_type}'"
+      else raise Hocon::ConfigError::ConfigBugOrBrokenError, "Unrecognized value type '#{config_value_type}'"
     end
   end
-end
+end

data/lib/hocon/impl.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'hocon'
 
 module Hocon::Impl

data/lib/hocon/impl/abstract_config_node.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'hocon/impl'
+require 'hocon/parser/config_node'
+require 'hocon/config_error'
+
+module Hocon::Impl::AbstractConfigNode
+  include Hocon::Parser::ConfigNode
+  def tokens
+    raise Hocon::ConfigError::ConfigBugOrBrokenError, "subclasses of AbstractConfigNode should override `tokens` (#{self.class})"
+  end
+
+  def render
+    orig_text = StringIO.new
+    tokens.each do |t|
+      orig_text << t.token_text
+    end
+    orig_text.string
+  end
+
+  def ==(other)
+    other.is_a?(Hocon::Impl::AbstractConfigNode) &&
+        (render == other.render)
+  end
+
+  def hash
+    render.hash
+  end
+end

data/lib/hocon/impl/abstract_config_node_value.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'hocon/impl'
+require 'hocon/impl/abstract_config_node'
+
+# This essentially exists in the upstream so we can ensure only certain types of
+# config nodes can be passed into some methods. That's not a problem in Ruby, so this is
+# unnecessary, but it seems best to keep it around for consistency
+module Hocon::Impl::AbstractConfigNodeValue
+  include Hocon::Impl::AbstractConfigNode
+end

data/lib/hocon/impl/abstract_config_object.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 require 'hocon/impl/abstract_config_value'
 require 'hocon/impl/simple_config'
@@ -7,9 +9,13 @@ require 'hocon/impl/resolve_status'
 require 'hocon/impl/simple_config_origin'
 require 'hocon/config_error'
 require 'hocon/impl/config_impl'
+require 'hocon/impl/unsupported_operation_error'
+require 'hocon/impl/container'
 
-class Hocon::Impl::AbstractConfigObject < Hocon::Impl::AbstractConfigValue
+module Hocon::Impl::AbstractConfigObject
   include Hocon::ConfigObject
+  include Hocon::Impl::Container
+  include Hocon::Impl::AbstractConfigValue
 
   ConfigBugOrBrokenError = Hocon::ConfigError::ConfigBugOrBrokenError
   ConfigNotResolvedError = Hocon::ConfigError::ConfigNotResolvedError
@@ -27,17 +33,117 @@ class Hocon::Impl::AbstractConfigObject < Hocon::Impl::AbstractConfigValue
     self
   end
 
+  def with_only_key(key)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `with_only_key`"
+  end
+
+  def without_key(key)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `without_key`"
+  end
+
+  def with_value(key, value)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `with_value`"
+  end
+
+  def with_only_path_or_nil(path)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `with_only_path_or_nil`"
+  end
+
+  def with_only_path(path)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `with_only_path`"
+  end
+
+  def without_path(path)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `without_path`"
+  end
+
+  def with_path_value(path, value)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `with_path_value`"
+  end
+
+  # This looks up the key with no transformation or type conversion of any
+  # kind, and returns null if the key is not present. The object must be
+  # resolved along the nodes needed to get the key or
+  # ConfigNotResolvedError will be thrown.
+  #
+  # @param key
+  # @return the unmodified raw value or null
+  def peek_assuming_resolved(key, original_path)
+    begin
+      attempt_peek_with_partial_resolve(key)
+    rescue ConfigNotResolvedError => e
+      raise Hocon::Impl::ConfigImpl.improve_not_resolved(original_path, e)
+    end
+  end
+
+  # Look up the key on an only-partially-resolved object, with no
+  # transformation or type conversion of any kind; if 'this' is not resolved
+  # then try to look up the key anyway if possible.
+  #
+  # @param key
+  #            key to look up
+  # @return the value of the key, or null if known not to exist
+  # @throws ConfigNotResolvedError
+  #             if can't figure out key's value (or existence) without more
+  #             resolving
+  def attempt_peek_with_partial_resolve(key)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `attempt_peek_with_partial_resolve`"
+  end
+
+  # Looks up the path with no transformation or type conversion. Returns null
+  # if the path is not found; throws ConfigException.NotResolved if we need
+  # to go through an unresolved node to look up the path.
+  def peek_path(path)
+    peek_path_from_obj(self, path)
+  end
+
+  def peek_path_from_obj(obj, path)
+    begin
+      # we'll fail if anything along the path can't be looked at without resolving
+      path_next = path.remainder
+      v = obj.attempt_peek_with_partial_resolve(path.first)
+
+      if path_next.nil?
+        v
+      else
+        if v.is_a?(Hocon::Impl::AbstractConfigObject)
+          peek_path_from_obj(v, path_next)
+        else
+          nil
+        end
+      end
+    rescue ConfigNotResolvedError => e
+      raise Hocon::Impl::ConfigImpl.improve_not_resolved(path, e)
+    end
+  end
+
   def value_type
     Hocon::ConfigValueType::OBJECT
   end
 
+  def new_copy_with_status(status, origin)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `new_copy_with_status`"
+  end
+
   def new_copy(origin)
     new_copy_with_status(resolve_status, origin)
   end
 
-  def merge_origins(stack)
+  def construct_delayed_merge(origin, stack)
+    Hocon::Impl::ConfigDelayedMergeObject.new(origin, stack)
+  end
+
+  def merged_with_object(fallback)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `merged_with_object`"
+  end
+
+  def with_fallback(mergeable)
+    super(mergeable)
+  end
+
+  def self.merge_origins(stack)
     if stack.empty?
-      raise ConfigBugError, "can't merge origins on empty list"
+      raise ConfigBugOrBrokenError, "can't merge origins on empty list"
     end
     origins = []
     first_origin = nil
@@ -67,47 +173,47 @@ class Hocon::Impl::AbstractConfigObject < Hocon::Impl::AbstractConfigValue
     Hocon::Impl::SimpleConfigOrigin.merge_origins(origins)
   end
 
-  def peek_assuming_resolved(key, original_path)
-    begin
-      attempt_peek_with_partial_resolve(key)
-    rescue ConfigNotResolvedError => e
-      raise Hocon::Impl::ConfigImpl.improve_not_resolved(original_path, e)
-    end
+  def resolve_substitutions(context, source)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `resolve_substituions`"
   end
 
-  def peek_path(path)
-    begin
-      return peek_path_impl(self, path, nil)
-    rescue ConfigNotResolvedError => e
-      raise ConfigBugOrBrokenError.new("NotPossibleToResolve happened though we had no ResolveContext in peek_path", nil)
-    end
+  def relativized(path)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `relativized`"
   end
 
-  def peek_path_impl(me, path, context)
-    begin
-      if not context.nil?
-        partially_resolved = context.restrict(path).resolve(me)
-        if partially_resolved.is_a?(self.class)
-          return peek_path_impl(partially_resolved, path, nil)
-        else
-          raise ConfigBugOrBrokenError.new(
-              "resolved object to non-object #{me} to #{partially_resolved}", nil)
-        end
-      else
-        remainder = path.remainder
-        v = me.attempt_peek_with_partial_resolve(path.first)
-        if remainder.nil?
-          return v
-        else
-          if v.is_a?(self.class)
-            return peek_path_impl(v, remainder, nil)
-          else
-            return nil
-          end
-        end
-      end
-    rescue ConfigNotResolvedError => e
-      raise Hocon::Impl::ConfigImpl.improve_not_resolved(path, e)
-    end
+  def [](key)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `[]`"
+  end
+
+  def render_value_to_sb(sb, indent, at_root, options)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigObject should override `render_value_to_sb`"
+  end
+
+  def we_are_immutable(method)
+    Hocon::Impl::UnsupportedOperationError.new("ConfigObject is immutable, you can't call Map.#{method}")
+  end
+
+  def clear
+    raise we_are_immutable("clear")
+  end
+
+  def []=(key, value)
+    raise we_are_immutable("[]=")
+  end
+
+  def putAll(map)
+    raise we_are_immutable("putAll")
+  end
+
+  def remove(key)
+    raise we_are_immutable("remove")
+  end
+
+  def delete(key)
+    raise we_are_immutable("delete")
+  end
+
+  def with_origin(origin)
+    super(origin)
   end
-end
+end

data/lib/hocon/impl/abstract_config_value.rb

@@ -1,19 +1,27 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 require 'stringio'
 require 'hocon/config_render_options'
 require 'hocon/config_object'
 require 'hocon/impl/resolve_status'
+require 'hocon/impl/resolve_result'
 require 'hocon/impl/unmergeable'
-require 'hocon/impl/abstract_config_object'
 require 'hocon/impl/config_impl_util'
+require 'hocon/config_error'
+require 'hocon/config_value'
 
 ##
 ## Trying very hard to avoid a parent reference in config values; when you have
 ## a tree like this, the availability of parent() tends to result in a lot of
 ## improperly-factored and non-modular code. Please don't add parent().
 ##
-class Hocon::Impl::AbstractConfigValue
+module Hocon::Impl::AbstractConfigValue
+  include Hocon::ConfigValue
+
   ConfigImplUtil = Hocon::Impl::ConfigImplUtil
+  ConfigBugOrBrokenError = Hocon::ConfigError::ConfigBugOrBrokenError
+  ResolveStatus = Hocon::Impl::ResolveStatus
 
   def initialize(origin)
     @origin = origin
@@ -21,10 +29,110 @@ class Hocon::Impl::AbstractConfigValue
 
   attr_reader :origin
 
+  # This exception means that a value is inherently not resolveable, at the
+  # moment the only known cause is a cycle of substitutions. This is a
+  # checked exception since it's internal to the library and we want to be
+  # sure we handle it before passing it out to public API. This is only
+  # supposed to be thrown by the target of a cyclic reference and it's
+  # supposed to be caught by the ConfigReference looking up that reference,
+  # so it should be impossible for an outermost resolve() to throw this.
+  #
+  # Contrast with ConfigException.NotResolved which just means nobody called
+  # resolve().
+  class NotPossibleToResolve < Exception
+    def initialize(context)
+      super("was not possible to resolve")
+      @trace_string = context.trace_string
+    end
+
+    attr_reader :trace_string
+  end
+
+  # Called only by ResolveContext.resolve
+  #
+  # @param context
+  #            state of the current resolve
+  # @param source
+  #            where to look up values
+  # @return a new value if there were changes, or this if no changes
+  def resolve_substitutions(context, source)
+    Hocon::Impl::ResolveResult.make(context, self)
+  end
+
   def resolve_status
     Hocon::Impl::ResolveStatus::RESOLVED
   end
 
+  def self.replace_child_in_list(list, child, replacement)
+    i = 0
+    while (i < list.size) && (! list[i].equal?(child))
+      i += 1
+    end
+    if (i == list.size)
+      raise ConfigBugOrBrokenError, "tried to replace #{child} which is not in #{list}"
+    end
+
+    new_stack = list.clone
+    if ! replacement.nil?
+      new_stack[i] = replacement
+    else
+      new_stack.delete(i)
+    end
+
+    if new_stack.empty?
+      nil
+    else
+      new_stack
+    end
+  end
+
+  def self.has_descendant_in_list?(list, descendant)
+    list.each do |v|
+      if v.equal?(descendant)
+        return true
+      end
+    end
+    # now the expensive traversal
+    list.each do |v|
+      if v.is_a?(Hocon::Impl::Container) && v.has_descendant?(descendant)
+        return true
+      end
+    end
+    false
+  end
+
+  # This is used when including one file in another; the included file is
+  # relativized to the path it's included into in the parent file. The point
+  # is that if you include a file at foo.bar in the parent, and the included
+  # file as a substitution ${a.b.c}, the included substitution now needs to
+  # be ${foo.bar.a.b.c} because we resolve substitutions globally only after
+  # parsing everything.
+  #
+  # @param prefix
+  # @return value relativized to the given path or the same value if nothing
+  #         to do
+  def relativized(prefix)
+    self
+  end
+
+  module NoExceptionsModifier
+    def modify_child_may_throw(key_or_nil, v)
+      begin
+        modify_child(key_or_nil, v)
+      rescue Hocon::ConfigError => e
+        raise e
+      end
+    end
+  end
+
+  def to_fallback_value
+    self
+  end
+
+  def new_copy(origin)
+    raise ConfigBugOrBrokenError, "subclasses of AbstractConfigValue should provide their own implementation of `new_copy` (#{self.class})"
+  end
+
   # this is virtualized rather than a field because only some subclasses
   # really need to store the boolean, and they may be able to pack it
   # with another boolean to save space.
@@ -34,16 +142,97 @@ class Hocon::Impl::AbstractConfigValue
     resolve_status == Hocon::Impl::ResolveStatus::RESOLVED
   end
 
+  def with_fallbacks_ignored
+    if ignores_fallbacks?
+      self
+    else
+      raise ConfigBugOrBrokenError, "value class doesn't implement forced fallback-ignoring #{self}"
+    end
+  end
+
   # the withFallback() implementation is supposed to avoid calling
   # mergedWith* if we're ignoring fallbacks.
   def require_not_ignoring_fallbacks
     if ignores_fallbacks?
-      raise ConfigBugError, "method should not have been called with ignoresFallbacks=true #{self.class.name}"
+      raise ConfigBugOrBrokenError, "method should not have been called with ignoresFallbacks=true #{self.class.name}"
     end
   end
 
+  def construct_delayed_merge(origin, stack)
+    # TODO: this might not work because ConfigDelayedMerge inherits
+    # from this class, so we can't `require` it from this file
+    require 'hocon/impl/config_delayed_merge'
+    Hocon::Impl::ConfigDelayedMerge.new(origin, stack)
+  end
+
+  def merged_stack_with_the_unmergeable(stack, fallback)
+    require_not_ignoring_fallbacks
+
+    # if we turn out to be an object, and the fallback also does,
+    # then a merge may be required; delay until we resolve.
+    new_stack = stack.clone
+    new_stack.concat(fallback.unmerged_values)
+    # TODO: this might not work because AbstractConfigObject inherits
+    # from this class, so we can't `require` it from this file
+    construct_delayed_merge(Hocon::Impl::AbstractConfigObject.merge_origins(new_stack), new_stack)
+  end
+
+  def delay_merge(stack, fallback)
+    # if we turn out to be an object, and the fallback also does,
+    # then a merge may be required.
+    # if we contain a substitution, resolving it may need to look
+    # back to the fallback
+    new_stack = stack.clone
+    new_stack << fallback
+    # TODO: this might not work because AbstractConfigObject inherits
+    # from this class, so we can't `require` it from this file
+    construct_delayed_merge(Hocon::Impl::AbstractConfigObject.merge_origins(new_stack), new_stack)
+  end
+
+  def merged_stack_with_object(stack, fallback)
+    require_not_ignoring_fallbacks
+
+    # TODO: this might not work because AbstractConfigObject inherits
+    # from this class, so we can't `require` it from this file
+    if self.is_a?(Hocon::Impl::AbstractConfigObject)
+      raise ConfigBugOrBrokenError, "Objects must reimplement merged_with_object"
+    end
+
+    merged_stack_with_non_object(stack, fallback)
+  end
+
+  def merged_stack_with_non_object(stack, fallback)
+    require_not_ignoring_fallbacks
+
+    if resolve_status == ResolveStatus::RESOLVED
+      # falling back to a non-object doesn't merge anything, and also
+      # prohibits merging any objects that we fall back to later.
+      # so we have to switch to ignoresFallbacks mode.
+      with_fallbacks_ignored
+    else
+      # if unresolved we may have to look back to fallbacks as part of
+      # the resolution process, so always delay
+      delay_merge(stack, fallback)
+    end
+  end
+
+  def merged_with_the_unmergeable(fallback)
+    require_not_ignoring_fallbacks
+    merged_stack_with_the_unmergeable([self], fallback)
+  end
+
+  def merged_with_object(fallback)
+    require_not_ignoring_fallbacks
+    merged_stack_with_object([self], fallback)
+  end
+
+  def merged_with_non_object(fallback)
+    require_not_ignoring_fallbacks
+    merged_stack_with_non_object([self], fallback)
+  end
+
   def with_origin(origin)
-    if @origin == origin
+    if @origin.equal?(origin)
       self
     else
       new_copy(origin)
@@ -57,6 +246,8 @@ class Hocon::Impl::AbstractConfigValue
       other = mergeable.to_fallback_value
       if other.is_a?(Hocon::Impl::Unmergeable)
         merged_with_the_unmergeable(other)
+        # TODO: this probably isn't going to work because AbstractConfigObject inherits
+        # from this class, so we can't `require` it from this file
       elsif other.is_a?(Hocon::Impl::AbstractConfigObject)
         merged_with_object(other)
       else
@@ -65,13 +256,42 @@ class Hocon::Impl::AbstractConfigValue
     end
   end
 
+  def can_equal(other)
+    other.is_a?(Hocon::Impl::AbstractConfigValue)
+  end
+
+  def ==(other)
+    # note that "origin" is deliberately NOT part of equality
+    if other.is_a?(Hocon::Impl::AbstractConfigValue)
+      can_equal(other) &&
+          value_type == other.value_type &&
+          ConfigImplUtil.equals_handling_nil?(unwrapped, other.unwrapped)
+    else
+      false
+    end
+  end
+
+  def hash
+    # note that "origin" is deliberately NOT part of equality
+    unwrapped_value = unwrapped
+    if unwrapped_value.nil?
+      0
+    else
+      unwrapped_value.hash
+    end
+  end
+
   def to_s
     sb = StringIO.new
     render_to_sb(sb, 0, true, nil, Hocon::ConfigRenderOptions.concise)
-    "#{self.class.name}(#{sb.string})"
+    "#{self.class.name.split('::').last}(#{sb.string})"
   end
 
-  def indent(sb, indent_size, options)
+  def inspect
+    to_s
+  end
+
+  def self.indent(sb, indent_size, options)
     if options.formatted?
       remaining = indent_size
       while remaining > 0
@@ -127,20 +347,40 @@ class Hocon::Impl::AbstractConfigValue
     sb.string[0, sb.pos]
   end
 
-  def at_key(origin, key)
+  # toString() is a debugging-oriented string but this is defined
+  # to create a string that would parse back to the value in JSON.
+  # It only works for primitive values (that would be a single
+  # which are auto-converted to strings when concatenating with
+  # other strings or by the DefaultTransformer.
+  def transform_to_string
+    nil
+  end
+
+  def at_key(key)
+    at_key_with_origin(Hocon::Impl::SimpleConfigOrigin.new_simple("at_key(#{key})"), key)
+  end
+
+  # Renamed this to be consistent with the other at_key* overloaded methods
+  def at_key_with_origin(origin, key)
     m = {key=>self}
     Hocon::Impl::SimpleConfigObject.new(origin, m).to_config
   end
 
-  def at_path(origin, path)
+  # In java this is an overloaded version of atPath
+  def at_path_with_origin(origin, path)
     parent = path.parent
-    result = at_key(origin, path.last)
+    result = at_key_with_origin(origin, path.last)
     while not parent.nil? do
       key = parent.last
-      result = result.at_key(origin, key)
+      result = result.at_key_with_origin(origin, key)
       parent = parent.parent
     end
     result
   end
 
-end
+  def at_path(path_expression)
+    origin = Hocon::Impl::SimpleConfigOrigin.new_simple("at_path(#{path_expression})")
+    at_path_with_origin(origin, Hocon::Impl::Path.new_path(path_expression))
+  end
+
+end