hocon 0.0.7 → 0.1.0

data/lib/hocon/impl/array_iterator.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'hocon/impl'
+
+class Hocon::Impl::ArrayIterator
+  def initialize(a)
+    @a = a
+    @index = 0
+  end
+
+  def has_next?
+    @index < @a.length
+  end
+
+  def next
+    @index += 1
+    @a[@index - 1]
+  end
+end

data/lib/hocon/impl/config_boolean.rb

@@ -1,12 +1,18 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 require 'hocon/impl/abstract_config_value'
 
-class Hocon::Impl::ConfigBoolean < Hocon::Impl::AbstractConfigValue
+class Hocon::Impl::ConfigBoolean
+  include Hocon::Impl::AbstractConfigValue
+
   def initialize(origin, value)
     super(origin)
     @value = value
   end
 
+  attr_reader :value
+
   def value_type
     Hocon::ConfigValueType::BOOLEAN
   end

data/lib/hocon/impl/config_concatenation.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 require 'hocon/impl/abstract_config_value'
 require 'hocon/impl/abstract_config_object'
@@ -6,14 +8,70 @@ require 'hocon/config_object'
 require 'hocon/impl/unmergeable'
 require 'hocon/impl/simple_config_origin'
 require 'hocon/impl/config_string'
+require 'hocon/impl/container'
 
-class Hocon::Impl::ConfigConcatenation < Hocon::Impl::AbstractConfigValue
+class Hocon::Impl::ConfigConcatenation
   include Hocon::Impl::Unmergeable
+  include Hocon::Impl::Container
+  include Hocon::Impl::AbstractConfigValue
 
   SimpleConfigList = Hocon::Impl::SimpleConfigList
   ConfigObject = Hocon::ConfigObject
+  ConfigString = Hocon::Impl::ConfigString
+  ResolveStatus = Hocon::Impl::ResolveStatus
   Unmergeable = Hocon::Impl::Unmergeable
   SimpleConfigOrigin = Hocon::Impl::SimpleConfigOrigin
+  ConfigBugOrBrokenError = Hocon::ConfigError::ConfigBugOrBrokenError
+  ConfigNotResolvedError = Hocon::ConfigError::ConfigNotResolvedError
+  ConfigWrongTypeError = Hocon::ConfigError::ConfigWrongTypeError
+
+  attr_reader :pieces
+
+  def initialize(origin, pieces)
+    super(origin)
+    @pieces = pieces
+
+    if pieces.size < 2
+      raise ConfigBugOrBrokenError, "Created concatenation with less than 2 items: #{self}"
+    end
+
+    had_unmergeable = false
+    pieces.each do |p|
+      if p.is_a?(Hocon::Impl::ConfigConcatenation)
+        raise ConfigBugOrBrokenError, "ConfigConcatenation should never be nested: #{self}"
+      end
+      if p.is_a?(Unmergeable)
+        had_unmergeable = true
+      end
+    end
+
+    unless had_unmergeable
+      raise ConfigBugOrBrokenError, "Created concatenation without an unmergeable in it: #{self}"
+    end
+  end
+
+  def value_type
+    raise not_resolved
+  end
+
+  def unwrapped
+    raise not_resolved
+  end
+
+  def new_copy(new_origin)
+    self.class.new(new_origin, @pieces)
+  end
+
+  def ignores_fallbacks?
+    # we can never ignore fallbacks because if a child ConfigReference
+    # is self-referential we have to look lower in the merge stack
+    # for its value.
+    false
+  end
+
+  def unmerged_values
+    [self]
+  end
 
   #
   # Add left and right, or their merger, to builder
@@ -25,9 +83,9 @@ class Hocon::Impl::ConfigConcatenation < Hocon::Impl::AbstractConfigValue
     # check for an object which can be converted to a list
     # (this will be an object with numeric keys, like foo.0, foo.1)
     if (left.is_a?(ConfigObject)) && (right.is_a?(SimpleConfigList))
-      left = DefaultTransformer.transform(left, ConfigValueType::LIST)
+      left = Hocon::Impl::DefaultTransformer.transform(left, Hocon::ConfigValueType::LIST)
     elsif (left.is_a?(SimpleConfigList)) && (right.is_a?(ConfigObject))
-      right = DefaultTransformer.transform(right, ConfigValueType::LIST)
+      right = Hocon::Impl::DefaultTransformer.transform(right, Hocon::ConfigValueType::LIST)
     end
 
     # Since this depends on the type of two instances, I couldn't think
@@ -38,9 +96,13 @@ class Hocon::Impl::ConfigConcatenation < Hocon::Impl::AbstractConfigValue
       joined = right.with_fallback(left)
     elsif (left.is_a?(SimpleConfigList)) && (right.is_a?(SimpleConfigList))
       joined = left.concatenate(right)
+    elsif (left.is_a?(SimpleConfigList) || left.is_a?(ConfigObject)) &&
+           is_ignored_whitespace(right)
+      joined = left
+      # it should be impossible that left is whitespace and right is a list or object
     elsif (left.is_a?(Hocon::Impl::ConfigConcatenation)) ||
         (right.is_a?(Hocon::Impl::ConfigConcatenation))
-      raise ConfigBugError, "unflattened ConfigConcatenation"
+      raise ConfigBugOrBrokenError, "unflattened ConfigConcatenation"
     elsif (left.is_a?(Unmergeable)) || (right.is_a?(Unmergeable))
       # leave joined=null, cannot join
     else
@@ -50,10 +112,10 @@ class Hocon::Impl::ConfigConcatenation < Hocon::Impl::AbstractConfigValue
       if s1.nil? || s2.nil?
         raise ConfigWrongTypeError.new(left.origin,
                 "Cannot concatenate object or list with a non-object-or-list, #{left} " +
-                    "and #{right} are not compatible")
+                    "and #{right} are not compatible", nil)
       else
         joined_origin = SimpleConfigOrigin.merge_origins([left.origin, right.origin])
-        joined = Hocon::Impl::ConfigString.new(joined_origin, s1 + s2)
+        joined = Hocon::Impl::ConfigString::Quoted.new(joined_origin, s1 + s2)
       end
     end
 
@@ -98,39 +160,126 @@ class Hocon::Impl::ConfigConcatenation < Hocon::Impl::AbstractConfigValue
     elsif consolidated.length == 1
       consolidated[0]
     else
-      merged_origin = SimpleConfigOrigin.merge_origins(consolidated)
+      merged_origin = SimpleConfigOrigin.merge_value_origins(consolidated)
       Hocon::Impl::ConfigConcatenation.new(merged_origin, consolidated)
     end
   end
 
-
-  def initialize(origin, pieces)
-    super(origin)
-    @pieces = pieces
-
-    if pieces.size < 2
-      raise ConfigBugError, "Created concatenation with less than 2 items: #{self}"
+  def resolve_substitutions(context, source)
+    if Hocon::Impl::ConfigImpl.trace_substitution_enabled
+      indent = context.depth + 2
+      Hocon::Impl::ConfigImpl.trace("concatenation has #{@pieces.size} pieces",
+                                    indent - 1)
+      count = 0
+      @pieces.each { |v|
+        Hocon::Impl::ConfigImpl.trace("#{count}: #{v}", count)
+        count += 1
+      }
     end
 
-    had_unmergeable = false
-    pieces.each do |p|
-      if p.is_a?(Hocon::Impl::ConfigConcatenation)
-        raise ConfigBugError, "ConfigConcatenation should never be nested: #{self}"
+    # Right now there's no reason to pushParent here because the
+    # content of ConfigConcatenation should not need to replaceChild,
+    # but if it did we'd have to do this.
+    source_with_parent = source
+    new_context = context
+
+    resolved = []
+    @pieces.each { |p|
+      # to concat into a string we have to do a full resolve,
+      # so unrestrict the context, then put restriction back afterward
+      restriction = new_context.restrict_to_child
+      result = new_context.unrestricted
+                   .resolve(p, source_with_parent)
+      r = result.value
+      new_context = result.context.restrict(restriction)
+      if Hocon::Impl::ConfigImpl.trace_substitution_enabled
+        Hocon::Impl::ConfigImpl.trace("resolved concat piece to #{r}",
+                                      context.depth)
       end
-      if p.is_a?(Unmergeable)
-        had_unmergeable = true
+
+      if r
+        resolved << r
       end
+      # otherwise, it was optional ... omit
+    }
+
+    # now need to concat everything
+    joined = self.class.consolidate(resolved)
+    # if unresolved is allowed we can just become another
+    # ConfigConcatenation
+    if joined.size > 1 and context.options.allow_unresolved
+      Hocon::Impl::ResolveResult.make(new_context, Hocon::Impl::ConfigConcatenation.new(origin, joined))
+    elsif joined.empty?
+      # we had just a list of optional references using ${?}
+      Hocon::Impl::ResolveResult.make(new_context, nil)
+    elsif joined.size == 1
+      Hocon::Impl::ResolveResult.make(new_context, joined[0])
+    else
+      raise ConfigBugOrBrokenError.new(
+                "Bug in the library; resolved list was joined to too many values: #{joined}")
     end
+  end
 
-    unless had_unmergeable
-      raise ConfigBugError, "Created concatenation without an unmergeable in it: #{self}"
+  def resolve_status
+    ResolveStatus::UNRESOLVED
+  end
+
+  def replace_child(child, replacement)
+    new_pieces = replace_child_in_list(@pieces, child, replacement)
+    if new_pieces == nil
+      nil
+    else
+      self.class.new(origin, new_pieces)
     end
   end
 
-  def ignores_fallbacks?
-    # we can never ignore fallbacks because if a child ConfigReference
-    # is self-referential we have to look lower in the merge stack
-    # for its value.
-    false
+  def has_descendant?(descendant)
+    has_descendant_in_list?(@pieces, descendant)
+  end
+
+  # when you graft a substitution into another object,
+  # you have to prefix it with the location in that object
+  # where you grafted it; but save prefixLength so
+  # system property and env variable lookups don 't get
+  # broken.
+  def relativized(prefix)
+    new_pieces = []
+    @pieces.each { |p|
+      new_pieces << p.relativized(prefix)
+    }
+    self.class.new(origin, new_pieces)
+  end
+
+  def can_equal(other)
+    other.is_a? Hocon::Impl::ConfigConcatenation
+  end
+
+  def ==(other)
+    if other.is_a? Hocon::Impl::ConfigConcatenation
+      can_equal(other) && @pieces == other.pieces
+    else
+      false
+    end
+  end
+
+  def hash
+    # note that "origin" is deliberately NOT part of equality
+    @pieces.hash
+  end
+
+  def render_value_to_sb(sb, indent, at_root, options)
+    @pieces.each do |piece|
+      piece.render_value_to_sb(sb, indent, at_root, options)
+    end
+  end
+
+  private
+
+  def not_resolved
+    ConfigNotResolvedError.new("need to Config#resolve(), see the API docs for Config#resolve(); substitution not resolved: #{self}")
+  end
+
+  def self.is_ignored_whitespace(value)
+    return value.is_a?(ConfigString) && !value.was_quoted?
   end
-end
+end

data/lib/hocon/impl/config_delayed_merge.rb

@@ -0,0 +1,329 @@
+require 'hocon/impl'
+require 'hocon/impl/replaceable_merge_stack'
+require 'hocon/impl/config_delayed_merge_object'
+require 'hocon/impl/config_impl'
+require 'hocon/impl/resolve_result'
+require 'hocon/impl/abstract_config_value'
+
+#
+# The issue here is that we want to first merge our stack of config files, and
+# then we want to evaluate substitutions. But if two substitutions both expand
+# to an object, we might need to merge those two objects. Thus, we can't ever
+# "override" a substitution when we do a merge; instead we have to save the
+# stack of values that should be merged, and resolve the merge when we evaluate
+# substitutions.
+#
+class Hocon::Impl::ConfigDelayedMerge
+  include Hocon::Impl::Unmergeable
+  include Hocon::Impl::ReplaceableMergeStack
+  include Hocon::Impl::AbstractConfigValue
+
+  ConfigImpl = Hocon::Impl::ConfigImpl
+  ResolveResult = Hocon::Impl::ResolveResult
+
+  def initialize(origin, stack)
+    super(origin)
+    @stack = stack
+
+    if stack.empty?
+      raise Hocon::ConfigError::ConfigBugOrBrokenError.new("creating empty delayed merge value", nil)
+    end
+
+    stack.each do |v|
+      if v.is_a?(Hocon::Impl::ConfigDelayedMerge) || v.is_a?(Hocon::Impl::ConfigDelayedMergeObject)
+        error_message = "placed nested DelayedMerge in a ConfigDelayedMerge, should have consolidated stack"
+        raise Hocon::ConfigError::ConfigBugOrBrokenError.new(error_message, nil)
+      end
+    end
+  end
+
+  attr_reader :stack
+
+
+  def value_type
+    error_message = "called value_type() on value with unresolved substitutions, need to Config#resolve() first, see API docs"
+    raise Hocon::ConfigError::ConfigNotResolvedError.new(error_message, nil)
+  end
+
+  def unwrapped
+    error_message = "called unwrapped() on value with unresolved substitutions, need to Config#resolve() first, see API docs"
+    raise Hocon::ConfigError::ConfigNotResolvedError.new(error_message, nil)
+  end
+
+  def resolve_substitutions(context, source)
+    self.class.resolve_substitutions(self, stack, context, source)
+  end
+
+  def self.resolve_substitutions(replaceable, stack, context, source)
+    if ConfigImpl.trace_substitution_enabled
+      ConfigImpl.trace("delayed merge stack has #{stack.size} items:", context.depth)
+      count = 0
+      stack.each do |v|
+        ConfigImpl.trace("#{count}: #{v}", context.depth)
+        count += 1
+      end
+    end
+
+    # to resolve substitutions, we need to recursively resolve
+    # the stack of stuff to merge, and merge the stack so
+    # we won't be a delayed merge anymore. If restrictToChildOrNull
+    # is non-null, or resolve options allow partial resolves,
+    # we may remain a delayed merge though.
+
+    new_context = context
+    count = 0
+    merged = nil
+    stack.each do |stack_end|
+      # the end value may or may not be resolved already
+
+      if stack_end.is_a?(Hocon::Impl::ReplaceableMergeStack)
+        raise ConfigBugOrBrokenError, "A delayed merge should not contain another one: #{replaceable}"
+      elsif stack_end.is_a?(Hocon::Impl::Unmergeable)
+        # the remainder could be any kind of value, including another
+        # ConfigDelayedMerge
+        remainder = replaceable.make_replacement(context, count + 1)
+
+        if ConfigImpl.trace_substitution_enabled
+          ConfigImpl.trace("remainder portion: #{remainder}", new_context.depth)
+        end
+
+        # If, while resolving 'end' we come back to the same
+        # merge stack, we only want to look _below_ 'end'
+        # in the stack. So we arrange to replace the
+        # ConfigDelayedMerge with a value that is only
+        # the remainder of the stack below this one.
+
+        if ConfigImpl.trace_substitution_enabled
+          ConfigImpl.trace("building sourceForEnd", new_context.depth)
+        end
+
+        # we resetParents() here because we'll be resolving "end"
+        # against a root which does NOT contain "end"
+        source_for_end = source.replace_within_current_parent(replaceable, remainder)
+
+        if ConfigImpl.trace_substitution_enabled
+          ConfigImpl.trace("  sourceForEnd before reset parents but after replace: #{source_for_end}", new_context.depth)
+        end
+
+        source_for_end = source_for_end.reset_parents
+      else
+        if ConfigImpl.trace_substitution_enabled
+          ConfigImpl.trace("will resolve end against the original source with parent pushed",
+                           new_context.depth)
+        end
+
+        source_for_end = source.push_parent(replaceable)
+      end
+
+      if ConfigImpl.trace_substitution_enabled
+        ConfigImpl.trace("sourceForEnd      =#{source_for_end}", new_context.depth)
+      end
+
+      if ConfigImpl.trace_substitution_enabled
+        ConfigImpl.trace("Resolving highest-priority item in delayed merge #{stack_end}" +
+                          " against #{source_for_end} endWasRemoved=#{(source != source_for_end)}")
+      end
+
+      result = new_context.resolve(stack_end, source_for_end)
+      resolved_end = result.value
+      new_context = result.context
+
+      if ! resolved_end.nil?
+        if merged.nil?
+          merged = resolved_end
+        else
+          if ConfigImpl.trace_substitution_enabled
+            ConfigImpl.trace("merging #{merged} with fallback #{resolved_end}",
+                             new_context.depth + 1)
+          end
+          merged = merged.with_fallback(resolved_end)
+        end
+      end
+
+      count += 1
+
+      if ConfigImpl.trace_substitution_enabled
+        ConfigImpl.trace("stack merged, yielding: #{merged}",
+                         new_context.depth)
+      end
+    end
+
+    ResolveResult.make(new_context, merged)
+  end
+
+  def make_replacement(context, skipping)
+    self.class.make_replacement(context, @stack, skipping)
+  end
+
+  # static method also used by ConfigDelayedMergeObject; end may be null
+  def self.make_replacement(context, stack, skipping)
+    sub_stack = stack.slice(skipping..stack.size)
+
+    if sub_stack.empty?
+      if ConfigImpl.trace_substitution_enabled
+        ConfigImpl.trace("Nothing else in the merge stack, replacing with null", context.depth)
+        return nil
+      end
+    else
+      # generate a new merge stack from only the remaining items
+      merged = nil
+      sub_stack.each do |v|
+        if merged.nil?
+          merged = v
+        else
+          merged = merged.with_fallback(v)
+        end
+      end
+      merged
+    end
+  end
+
+  def resolve_status
+    Hocon::Impl::ResolveStatus::UNRESOLVED
+  end
+
+  def replace_child(child, replacement)
+    new_stack = replace_child_in_list(stack, child, replacement)
+    if new_stack.nil?
+      nil
+    else
+      self.class.new(origin, new_stack)
+    end
+  end
+
+  def has_descendant?(descendant)
+    Hocon::Impl::AbstractConfigValue.has_descendant_in_list?(stack, descendant)
+  end
+
+  def relativized(prefix)
+    new_stack = stack.map { |o| o.relativized(prefix) }
+    self.class.new(origin, new_stack)
+  end
+
+  # static utility shared with ConfigDelayedMergeObject
+  def self.stack_ignores_fallbacks?(stack)
+    last = stack[-1]
+    last.ignores_fallbacks?
+  end
+
+  def ignores_fallbacks?
+    self.class.stack_ignores_fallbacks?(stack)
+  end
+
+  def new_copy(new_origin)
+    self.class.new(new_origin, stack)
+  end
+
+  def merged_with_the_unmergeable(fallback)
+    merged_stack_with_the_unmergeable(stack, fallback)
+  end
+
+  def merged_with_object(fallback)
+    merged_stack_with_object(stack, fallback)
+  end
+
+  def merged_with_non_object(fallback)
+    merged_stack_with_non_object(stack, fallback)
+  end
+
+  def unmerged_values
+    stack
+  end
+
+  def can_equal(other)
+    other.is_a? Hocon::Impl::ConfigDelayedMerge
+  end
+
+  def ==(other)
+    # note that "origin" is deliberately NOT part of equality
+    if other.is_a? Hocon::Impl::ConfigDelayedMerge
+      can_equal(other) && (@stack == other.stack || @stack.equal?(other.stack))
+    else
+      false
+    end
+  end
+
+  def hash
+    # note that "origin" is deliberately NOT part of equality
+    @stack.hash
+  end
+
+  def render_to_sb(sb, indent, at_root, at_key, options)
+    self.class.render_value_to_sb_from_stack(stack, sb, indent, at_root, at_key, options)
+  end
+
+  # static method also used by ConfigDelayedMergeObject.
+  def self.render_value_to_sb_from_stack(stack, sb, indent, at_root, at_key, options)
+    comment_merge = options.comments
+
+    if comment_merge
+      sb << "# unresolved merge of #{stack.size} values follows (\n"
+      if at_key.nil?
+        self.indent(sb, indent, options)
+        sb << "# this unresolved merge will not be parseable because it's at the root of the object\n"
+        self.indent(sb, indent, options)
+        sb << "# the HOCON format has no way to list multiple root objects in a single file\n"
+      end
+    end
+
+    reversed = stack.reverse
+
+    i = 0
+
+    reversed.each do |v|
+      if comment_merge
+        self.indent(sb, indent, options)
+        if !at_key.nil?
+          rendered_key = Hocon::Impl::ConfigImplUtil.render_json_string(at_key)
+          sb << "#     unmerged value #{i} for key #{rendered_key}"
+        else
+          sb << "#     unmerged value #{i} from "
+        end
+        i += 1
+
+        sb << v.origin.description
+        sb << "\n"
+
+        v.origin.comments.each do |comment|
+          self.indent(sb, indent, options)
+          sb << "# "
+          sb << comment
+          sb << "\n"
+        end
+      end
+      Hocon::Impl::AbstractConfigValue.indent(sb, indent, options)
+
+      if !at_key.nil?
+        sb << Hocon::Impl::ConfigImplUtil.render_json_string(at_key)
+        if options.formatted
+          sb << " : "
+        else
+          sb << ":"
+        end
+      end
+
+      v.render_value_to_sb(sb, indent, at_root, options)
+      sb << ","
+
+      if options.formatted
+        sb.append "\n"
+      end
+    end
+
+    # chop comma or newline
+    # couldn't figure out a better way to chop characters off of the end of
+    # the StringIO.  This relies on making sure that, prior to returning the
+    # final string, we take a substring that ends at sb.pos.
+    sb.pos = sb.pos - 1
+    if options.formatted
+      sb.pos = sb.pos - 1
+      sb << "\n"
+    end
+
+    if comment_merge
+      self.indent(sb, indent, options)
+      sb << "# ) end of unresolved merge\n"
+    end
+  end
+
+end