hocon 0.0.1

data/lib/hocon/impl/path.rb

@@ -0,0 +1,59 @@
+require 'hocon/impl'
+require 'stringio'
+
+class Hocon::Impl::Path
+  # this doesn't have a very precise meaning, just to reduce
+  # noise from quotes in the rendered path for average cases
+  def self.has_funky_chars?(s)
+    length = s.length
+    if length == 0
+      return false
+    end
+
+    # if the path starts with something that could be a number,
+    # we need to quote it because the number could be invalid,
+    # for example it could be a hyphen with no digit afterward
+    # or the exponent "e" notation could be mangled.
+    first = s[0]
+    unless first =~ /[[:alpha:]]/
+      return true
+    end
+
+    s.chars.each do |c|
+      unless (c =~ /[[:alnum:]]/) || (c == '-') || (c == '_')
+        return true
+      end
+    end
+
+    false
+  end
+
+  def initialize(first, remainder)
+    @first = first
+    @remainder = remainder
+  end
+  attr_reader :first, :remainder
+
+  #
+  # toString() is a debugging-oriented version while this is an
+  # error-message-oriented human-readable one.
+  #
+  def render
+    sb = StringIO.new
+    append_to_string_builder(sb)
+    sb.string
+  end
+
+  def append_to_string_builder(sb)
+    if self.class.has_funky_chars?(@first) || @first.empty?
+      sb << ConfigImplUtil.render_json_string(@first)
+    else
+      sb << @first
+    end
+
+    unless @remainder.nil?
+      sb << "."
+      @remainder.append_to_string_builder(sb)
+    end
+  end
+end

data/lib/hocon/impl/path_builder.rb

@@ -0,0 +1,36 @@
+require 'hocon/impl'
+require 'hocon/impl/path'
+
+class Hocon::Impl::PathBuilder
+  Path = Hocon::Impl::Path
+
+  def initialize
+    @keys = []
+    @result = nil
+  end
+
+  def check_can_append
+    if @result
+      raise ConfigBugError, "Adding to PathBuilder after getting result"
+    end
+  end
+
+  def append_key(key)
+    check_can_append
+    @keys.push(key)
+  end
+
+  def result
+    # note: if keys is empty, we want to return null, which is a valid
+    # empty path
+    if @result.nil?
+      remainder = nil
+      while !@keys.empty?
+        key = @keys.pop
+        remainder = Path.new(key, remainder)
+      end
+      @result = remainder
+    end
+    @result
+  end
+end

data/lib/hocon/impl/resolve_status.rb

@@ -0,0 +1,18 @@
+require 'hocon/impl'
+
+class Hocon::Impl::ResolveStatus
+  UNRESOLVED = 0
+  RESOLVED = 1
+
+  def self.from_values(values)
+    if values.any? { |v| v.resolve_status == UNRESOLVED }
+      UNRESOLVED
+    else
+      RESOLVED
+    end
+  end
+
+  def self.from_boolean(resolved)
+    resolved ? RESOLVED : UNRESOLVED
+  end
+end

data/lib/hocon/impl/simple_config.rb

@@ -0,0 +1,11 @@
+require 'hocon/impl'
+
+class Hocon::Impl::SimpleConfig
+  def initialize(object)
+    @object = object
+  end
+
+  def root
+    @object
+  end
+end

data/lib/hocon/impl/simple_config_list.rb

@@ -0,0 +1,70 @@
+require 'hocon/impl'
+require 'hocon/impl/resolve_status'
+require 'hocon/config_value_type'
+
+class Hocon::Impl::SimpleConfigList < Hocon::Impl::AbstractConfigValue
+  ResolveStatus = Hocon::Impl::ResolveStatus
+
+  def initialize(origin, value, status = ResolveStatus.from_values(value))
+    super(origin)
+    @value = value
+    @resolved = (status == ResolveStatus::RESOLVED)
+
+    # kind of an expensive debug check (makes this constructor pointless)
+    if status != ResolveStatus.from_values(value)
+      raise ConfigBugError, "SimpleConfigList created with wrong resolve status: #{self}"
+    end
+  end
+
+  def value_type
+    Hocon::ConfigValueType::LIST
+  end
+
+  def unwrapped
+    @value.map { |v| v.unwrapped }
+  end
+
+  def render_value_to_sb(sb, indent_size, at_root, options)
+    if @value.empty?
+      sb << "[]"
+    else
+      sb << "["
+      if options.formatted?
+        sb << "\n"
+      end
+      @value.each do |v|
+        if options.origin_comments?
+          indent(sb, indent_size + 1, options)
+          sb << "# "
+          sb << v.origin.description
+          sb << "\n"
+        end
+        if options.comments?
+          v.origin.comments.each do |comment|
+            sb << "# "
+            sb << comment
+            sb << "\n"
+          end
+        end
+        indent(sb, indent_size + 1, options)
+
+        v.render_value_to_sb(sb, indent_size + 1, at_root, options)
+        sb << ","
+        if options.formatted?
+          sb << "\n"
+        end
+      end
+
+      # 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 # chop or newline
+      if options.formatted?
+        sb.pos = sb.pos - 1 # also chop comma
+        sb << "\n"
+        indent(sb, indent_size, options)
+      end
+      sb << "]"
+    end
+  end
+end

data/lib/hocon/impl/simple_config_object.rb

@@ -0,0 +1,178 @@
+require 'hocon/impl'
+require 'hocon/impl/simple_config_origin'
+require 'hocon/impl/abstract_config_object'
+require 'hocon/impl/resolve_status'
+require 'set'
+
+class Hocon::Impl::SimpleConfigObject < Hocon::Impl::AbstractConfigObject
+  def self.empty_missing(base_origin)
+    self.new(
+        Hocon::Impl::SimpleConfigOrigin.new_simple("#{base_origin.description} (not found)"),
+        {})
+  end
+
+  def initialize(origin, value,
+                  status = Hocon::Impl::ResolveStatus.from_values(value.values),
+                  ignores_fallbacks = false)
+    super(origin)
+    if value.nil?
+      raise ConfigBugError, "creating config object with null map"
+    end
+    @value = value
+    @resolved = (status == Hocon::Impl::ResolveStatus::RESOLVED)
+    @ignores_fallbacks = ignores_fallbacks
+
+    # Kind of an expensive debug check. Comment out?
+    if status != Hocon::Impl::ResolveStatus.from_values(value.values)
+      raise ConfigBugError, "Wrong resolved status on #{self}"
+    end
+  end
+
+  attr_reader :value
+
+  def new_copy_with_status(new_status, new_origin, new_ignores_fallbacks = nil)
+    Hocon::Impl::SimpleConfigObject.new(new_origin,
+              @value, new_status, new_ignores_fallbacks)
+  end
+
+  def ignores_fallbacks?
+    @ignores_fallbacks
+  end
+
+  def unwrapped
+    @value.merge(@value) { |k,v| v.unwrapped }
+  end
+
+  def merged_with_object(abstract_fallback)
+    require_not_ignoring_fallbacks
+
+    unless abstract_fallback.is_a?(Hocon::Impl::SimpleConfigObject)
+      raise ConfigBugError, "should not be reached (merging non-SimpleConfigObject)"
+    end
+
+    fallback = abstract_fallback
+    changed = false
+    all_resolved = true
+    merged = {}
+    all_keys = key_set.union(fallback.key_set)
+    all_keys.each do |key|
+      first = @value[key]
+      second = fallback.value[key]
+      kept =
+          if first.nil?
+            second
+          elsif second.nil?
+            first
+          else
+            first.with_fallback(second)
+          end
+      merged[key] = kept
+
+      if first != kept
+        changed = true
+      end
+
+      if kept.resolve_status == Hocon::Impl::ResolveStatus::UNRESOLVED
+        all_resolved = false
+      end
+    end
+
+    new_resolve_status = Hocon::Impl::ResolveStatus.from_boolean(all_resolved)
+    new_ignores_fallbacks = fallback.ignores_fallbacks?
+
+    if changed
+      Hocon::Impl::SimpleConfigObject.new(merge_origins([self, fallback]),
+                             merged, new_resolve_status,
+                             new_ignores_fallbacks)
+    elsif (new_resolve_status != resolve_status) || (new_ignores_fallbacks != ignores_fallbacks?)
+      newCopy(new_resolve_status, origin, new_ignores_fallbacks)
+    else
+      self
+    end
+  end
+
+  def render_value_to_sb(sb, indent_size, at_root, options)
+    if empty?
+      sb << "{}"
+    else
+      outer_braces = options.json? || !at_root
+
+      inner_indent =
+        if outer_braces
+          sb << "{"
+          if options.formatted?
+            sb << "\n"
+          end
+          indent_size + 1
+        else
+          indent_size
+        end
+
+      separator_count = 0
+      key_set.each do |k|
+        v = @value[k]
+
+        if options.origin_comments?
+          indent(sb, inner_indent, options)
+          sb << "# "
+          sb << v.origin.description
+          sb << "\n"
+        end
+        if options.comments?
+          v.origin.comments.each do |comment|
+            indent(sb, inner_indent, options)
+            sb << "#"
+            if !comment.start_with?(" ")
+              sb << " "
+            end
+            sb << comment
+            sb << "\n"
+          end
+        end
+        indent(sb, inner_indent, options)
+        v.render_to_sb(sb, inner_indent, false, k.to_s, options)
+
+        if options.formatted?
+          if options.json?
+            sb << ","
+            separator_count = 2
+          else
+            separator_count = 1
+          end
+          sb << "\n"
+        else
+          sb << ","
+          separator_count = 1
+        end
+      end
+      # chop last commas/newlines
+      # 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 - separator_count
+
+      if outer_braces
+        if options.formatted?
+          sb << "\n" # put a newline back
+          if outer_braces
+            indent(sb, indent_size, options)
+          end
+        end
+        sb << "}"
+      end
+    end
+    if at_root && options.formatted?
+      sb << "\n"
+    end
+  end
+
+
+  def key_set
+    Set.new(@value.keys)
+  end
+
+  def empty?
+    @value.empty?
+  end
+
+end

data/lib/hocon/impl/simple_config_origin.rb

@@ -0,0 +1,174 @@
+require 'uri'
+require 'hocon/impl'
+require 'hocon/impl/origin_type'
+
+class Hocon::Impl::SimpleConfigOrigin
+
+  MERGE_OF_PREFIX = "merge of "
+
+  def self.new_file(file_path)
+    url = URI.join('file:///', file_path)
+    self.new(file_path, -1, -1,
+             Hocon::Impl::OriginType::FILE,
+             url, nil)
+  end
+
+  def self.new_simple(description)
+    self.new(description, -1, -1,
+             Hocon::Impl::OriginType::GENERIC,
+             nil, nil)
+  end
+
+  def self.remove_merge_of_prefix(desc)
+    if desc.start_with?(MERGE_OF_PREFIX)
+      desc = desc[MERGE_OF_PREFIX.length, desc.length - 1]
+    end
+    desc
+  end
+
+  def self.merge_two(a, b)
+    merged_desc = nil
+    merged_start_line = nil
+    merged_end_line = nil
+    merged_comments = nil
+
+    merged_type =
+        if a.origin_type == b.origin_type
+          a.origin_type
+        else
+          Hocon::Impl::OriginType.GENERIC
+        end
+
+    # first use the "description" field which has no line numbers
+    # cluttering it.
+    a_desc = remove_merge_of_prefix(a.description)
+    b_desc = remove_merge_of_prefix(b.description)
+
+    if a_desc == b_desc
+      merged_desc = a_desc
+      if a.line_number < 0
+        merged_start_line = b.line_number
+      elsif b.line_number < 0
+        merged_start_line = a.line_number
+      else
+        merged_start_line = [a.line_number, b.line_number].min
+      end
+
+      merged_end_line = [a.end_line_number, b.end_line_number].max
+    else
+      # this whole merge song-and-dance was intended to avoid this case
+      # whenever possible, but we've lost. Now we have to lose some
+      # structured information and cram into a string.
+      #
+      # description() method includes line numbers, so use it instead
+      # of description field.
+      a_full = remove_merge_of_prefix(a.description)
+      b_full = remove_merge_of_prefix(b.description)
+
+      merged_desc = "#{MERGE_OF_PREFIX}#{a_full},#{b_full}"
+      merged_start_line = -1
+      merged_end_line = -1
+    end
+
+    merged_url =
+        if Hocon::Impl::ConfigImplUtil.equals_handling_nil?(a.url_or_nil, b.url_or_nil)
+          a.url_or_nil
+        else
+          nil
+        end
+
+    if Hocon::Impl::ConfigImplUtil.equals_handling_nil?(a.comments_or_nil, b.comments_or_nil)
+      merged_comments = a.comments_or_nil
+    else
+      merged_comments = []
+      if a.comments_or_nil
+        merged_comments.concat(a.comments_or_nil)
+      end
+      if b.comments_or_nil
+        merged_comments.concat(b.comments_or_nil)
+      end
+    end
+
+    Hocon::Impl::SimpleConfigOrigin.new(
+        merged_desc, merged_start_line, merged_end_line,
+        merged_type, merged_url, merged_comments)
+  end
+
+  def self.merge_origins(stack)
+    if stack.empty?
+      raise ConfigBugError, "can't merge empty list of origins"
+    elsif stack.length == 1
+      stack[0]
+    elsif stack.length == 2
+      merge_two(stack[0], stack[1])
+    else
+      remaining = stack.clone
+      while remaining.length > 2
+        merged = merge_three(remaining[0], remaining[1], remaining[2])
+        remaining.pop
+        remaining.pop
+        remaining.pop
+      end
+
+      # should be down to either 1 or 2
+      merge_origins(remaining)
+    end
+  end
+
+
+  def initialize(description, line_number, end_line_number,
+                  origin_type, url, comments)
+    if !description
+      raise ArgumentError, "description may not be nil"
+    end
+
+    @description = description
+    @line_number = line_number
+    @end_line_number = end_line_number
+    @origin_type = origin_type
+    @url_or_nil = url
+    @comments_or_nil = comments
+  end
+
+  attr_reader :description, :line_number, :end_line_number, :origin_type,
+              :url_or_nil, :comments_or_nil
+
+  def set_line_number(line_number)
+    if (line_number == @line_number) and
+        (line_number == @end_line_number)
+      self
+    else
+      Hocon::Impl::SimpleConfigOrigin.new(
+          @description, line_number, line_number,
+          @origin_type, @url_or_nil, @comments_or_nil)
+    end
+  end
+
+  def set_comments(comments)
+    if Hocon::Impl::ConfigImplUtil.equals_handling_nil?(comments, @comments_or_nil)
+      self
+    else
+      Hocon::Impl::SimpleConfigOrigin.new(
+          @description, @line_number, @end_line_number,
+          @origin_type, @url_or_nil, comments)
+    end
+  end
+
+  def prepend_comments(comments)
+    if Hocon::Impl::ConfigImplUtil.equals_handling_nil?(comments, @comments_or_nil)
+      self
+    elsif @comments_or_nil.nil?
+      set_comments(comments)
+    else
+      merged = []
+      merged.concat(comments)
+      merged.concat(@comments_or_nil)
+      set_comments(merged)
+    end
+  end
+
+  def comments
+    @comments_or_nil || []
+  end
+
+end