ruby_hocon 0.0.1

data/lib/hocon/impl/abstract_config_value.rb

@@ -0,0 +1,130 @@
+require 'hocon/impl'
+require 'stringio'
+require 'hocon/config_render_options'
+require 'hocon/config_object'
+require 'hocon/impl/resolve_status'
+require 'hocon/impl/unmergeable'
+require 'hocon/impl/abstract_config_object'
+require 'hocon/impl/config_impl_util'
+
+##
+## 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
+  ConfigImplUtil = Hocon::Impl::ConfigImplUtil
+
+  def initialize(origin)
+    @origin = origin
+  end
+
+  attr_reader :origin
+
+  def resolve_status
+    Hocon::Impl::ResolveStatus::RESOLVED
+  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.
+  def ignores_fallbacks?
+    # if we are not resolved, then somewhere in this value there's
+    # a substitution that may need to look at the fallbacks.
+    resolve_status == Hocon::Impl::ResolveStatus::RESOLVED
+  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}"
+    end
+  end
+
+  def with_origin(origin)
+    if @origin == origin
+      self
+    else
+      new_copy(origin)
+    end
+  end
+
+  def with_fallback(mergeable)
+    if ignores_fallbacks?
+      self
+    else
+      other = mergeable.to_fallback_value
+      if other.is_a?(Hocon::Impl::Unmergeable)
+        merged_with_the_unmergeable(other)
+      elsif other.is_a?(Hocon::Impl::AbstractConfigObject)
+        merged_with_object(other)
+      else
+        merged_with_non_object(other)
+      end
+    end
+  end
+
+  def to_s
+    sb = StringIO.new
+    render_to_sb(sb, 0, true, nil, Hocon::ConfigRenderOptions.concise)
+    "#{self.class.name}(#{sb.string})"
+  end
+
+  def indent(sb, indent_size, options)
+    if options.formatted?
+      remaining = indent_size
+      while remaining > 0
+        sb << "    "
+        remaining -= 1
+      end
+    end
+  end
+
+  def render_to_sb(sb, indent, at_root, at_key, options)
+    if !at_key.nil?
+      rendered_key =
+          if options.json?
+            ConfigImplUtil.render_json_string(at_key)
+          else
+            ConfigImplUtil.render_string_unquoted_if_possible(at_key)
+          end
+
+      sb << rendered_key
+
+      if options.json?
+        if options.formatted?
+          sb << " : "
+        else
+          sb << ":"
+        end
+      else
+        # in non-JSON we can omit the colon or equals before an object
+        if self.is_a?(Hocon::ConfigObject)
+          if options.formatted?
+            sb << ' '
+          end
+        else
+          sb << "="
+        end
+      end
+    end
+    render_value_to_sb(sb, indent, at_root, options)
+  end
+
+  # to be overridden by subclasses
+  def render_value_to_sb(sb, indent, at_root, options)
+    u = unwrapped
+    sb << u.to_s
+  end
+
+  def render(options = Hocon::ConfigRenderOptions.defaults)
+    sb = StringIO.new
+    render_to_sb(sb, 0, true, nil, options)
+    # We take a substring that ends at sb.pos, because we've been decrementing
+    # sb.pos at various points in the code as a means to remove characters from
+    # the end of the StringIO
+    sb.string[0, sb.pos]
+  end
+
+end

data/lib/hocon/impl/config_concatenation.rb

@@ -0,0 +1,136 @@
+require 'hocon/impl'
+require 'hocon/impl/abstract_config_value'
+require 'hocon/impl/abstract_config_object'
+require 'hocon/impl/simple_config_list'
+require 'hocon/config_object'
+require 'hocon/impl/unmergeable'
+require 'hocon/impl/simple_config_origin'
+require 'hocon/impl/config_string'
+
+class Hocon::Impl::ConfigConcatenation < Hocon::Impl::AbstractConfigValue
+  include Hocon::Impl::Unmergeable
+
+  SimpleConfigList = Hocon::Impl::SimpleConfigList
+  ConfigObject = Hocon::ConfigObject
+  Unmergeable = Hocon::Impl::Unmergeable
+  SimpleConfigOrigin = Hocon::Impl::SimpleConfigOrigin
+
+  #
+  # Add left and right, or their merger, to builder
+  #
+  def self.join(builder, orig_right)
+    left = builder[builder.size - 1]
+    right = orig_right
+
+    # 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)
+    elsif (left.is_a?(SimpleConfigList)) && (right.is_a?(ConfigObject))
+      right = DefaultTransformer.transform(right, ConfigValueType::LIST)
+    end
+
+    # Since this depends on the type of two instances, I couldn't think
+    # of much alternative to an instanceof chain. Visitors are sometimes
+    # used for multiple dispatch but seems like overkill.
+    joined = nil
+    if (left.is_a?(ConfigObject)) && (right.is_a?(ConfigObject))
+      joined = right.with_fallback(left)
+    elsif (left.is_a?(SimpleConfigList)) && (right.is_a?(SimpleConfigList))
+      joined = left.concatenate(right)
+    elsif (left.is_a?(Hocon::Impl::ConfigConcatenation)) ||
+        (right.is_a?(Hocon::Impl::ConfigConcatenation))
+      raise ConfigBugError, "unflattened ConfigConcatenation"
+    elsif (left.is_a?(Unmergeable)) || (right.is_a?(Unmergeable))
+      # leave joined=null, cannot join
+    else
+      # handle primitive type or primitive type mixed with object or list
+      s1 = left.transform_to_string
+      s2 = right.transform_to_string
+      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")
+      else
+        joined_origin = SimpleConfigOrigin.merge_origins([left.origin, right.origin])
+        joined = Hocon::Impl::ConfigString.new(joined_origin, s1 + s2)
+      end
+    end
+
+    if joined.nil?
+      builder.push(right)
+    else
+      builder.pop
+      builder.push(joined)
+    end
+  end
+
+  def self.consolidate(pieces)
+    if pieces.length < 2
+      pieces
+    else
+      flattened = []
+      pieces.each do |v|
+        if v.is_a?(Hocon::Impl::ConfigConcatenation)
+          flattened.concat(v.pieces)
+        else
+          flattened.push(v)
+        end
+      end
+
+      consolidated = []
+      flattened.each do |v|
+        if consolidated.empty?
+          consolidated.push(v)
+        else
+          join(consolidated, v)
+        end
+      end
+
+      consolidated
+    end
+  end
+
+  def self.concatenate(pieces)
+    consolidated = consolidate(pieces)
+    if consolidated.empty?
+      nil
+    elsif consolidated.length == 1
+      consolidated[0]
+    else
+      merged_origin = SimpleConfigOrigin.merge_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}"
+    end
+
+    had_unmergeable = false
+    pieces.each do |p|
+      if p.is_a?(Hocon::Impl::ConfigConcatenation)
+        raise ConfigBugError, "ConfigConcatenation should never be nested: #{self}"
+      end
+      if p.is_a?(Unmergeable)
+        had_unmergeable = true
+      end
+    end
+
+    unless had_unmergeable
+      raise ConfigBugError, "Created concatenation without an unmergeable in it: #{self}"
+    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
+  end
+end

data/lib/hocon/impl/config_float.rb

@@ -0,0 +1,9 @@
+require 'hocon/impl'
+require 'hocon/impl/config_number'
+
+class Hocon::Impl::ConfigFloat < Hocon::Impl::ConfigNumber
+  def initialize(origin, value, original_text)
+    super(origin, original_text)
+    @value = value
+  end
+end

data/lib/hocon/impl/config_impl.rb

@@ -0,0 +1,10 @@
+require 'hocon/impl'
+require 'hocon/impl/simple_includer'
+
+class Hocon::Impl::ConfigImpl
+  @default_includer = Hocon::Impl::SimpleIncluder.new
+
+  def self.default_includer
+    @default_includer
+  end
+end

data/lib/hocon/impl/config_impl_util.rb

@@ -0,0 +1,78 @@
+require 'hocon/impl'
+require 'stringio'
+
+class Hocon::Impl::ConfigImplUtil
+  def self.equals_handling_nil?(a, b)
+    # This method probably doesn't make any sense in ruby... not sure
+    if a.nil? && !b.nil?
+      false
+    elsif !a.nil? && b.nil?
+      false
+    # in ruby, the == and .equal? are the opposite of what they are in Java
+    elsif a.equal?(b)
+      true
+    else
+      a == b
+    end
+  end
+
+  #
+  # This is public ONLY for use by the "config" package, DO NOT USE this ABI
+  # may change.
+  #
+  def self.render_json_string(s)
+    sb = StringIO.new
+    sb << '"'
+    s.chars.each do |c|
+      case c
+        when '"' then sb << "\\\""
+        when "\\" then sb << "\\\\"
+        when "\n" then sb << "\\n"
+        when "\b" then sb << "\\b"
+        when "\f" then sb << "\\f"
+        when "\r" then sb << "\\r"
+        when "\t" then sb << "\\t"
+        else
+          if c =~ /[[:cntrl:]]/
+            sb << ("\\u%04x" % c)
+          else
+            sb << c
+          end
+      end
+    end
+    sb << '"'
+    sb.string
+  end
+
+  def self.render_string_unquoted_if_possible(s)
+    # this can quote unnecessarily as long as it never fails to quote when
+    # necessary
+    if s.length == 0
+      return render_json_string(s)
+    end
+
+    # if it starts with a hyphen or number, we have to quote
+    # to ensure we end up with a string and not a number
+    first = s.chars.first
+    if (first =~ /[[:digit:]]/) || (first == '-')
+      return render_json_string(s)
+    end
+
+    # only unquote if it's pure alphanumeric
+    s.chars.each do |c|
+      unless (c =~ /[[:alnum:]]/) || (c == '-')
+        return render_json_string(s)
+      end
+    end
+
+    s
+  end
+
+  def self.whitespace?(c)
+    # this implementation is *not* a port of the java code, because it relied on
+    # the method java.lang.Character#isWhitespace.  This is probably
+    # insanely slow (running a regex against every single character in the
+    # file).
+    c =~ /[[:space:]]/
+  end
+end

data/lib/hocon/impl/config_int.rb

@@ -0,0 +1,31 @@
+require 'hocon/impl'
+require 'hocon/impl/config_number'
+require 'hocon/config_value_type'
+
+class Hocon::Impl::ConfigInt < Hocon::Impl::ConfigNumber
+  def initialize(origin, value, original_text)
+    super(origin, original_text)
+    @value = value
+  end
+
+  def value_type
+    Hocon::ConfigValueType::NUMBER
+  end
+
+  def unwrapped
+    @value
+  end
+
+  def transform_to_string
+    s = super
+    if s.nil?
+      self.to_s
+    else
+      s
+    end
+  end
+
+  def new_copy(origin)
+    Hocon::Impl::ConfigInt.new(origin, @value, @original_text)
+  end
+end

data/lib/hocon/impl/config_number.rb

@@ -0,0 +1,27 @@
+require 'hocon/impl'
+require 'hocon/impl/abstract_config_value'
+
+class Hocon::Impl::ConfigNumber < Hocon::Impl::AbstractConfigValue
+  ## sigh... requiring these subclasses before this class
+  ## is declared would cause an error.  Thanks, ruby.
+  require 'hocon/impl/config_int'
+  require 'hocon/impl/config_float'
+
+  def self.new_number(origin, number, original_text)
+    as_int = number.to_i
+    if as_int == number
+      Hocon::Impl::ConfigInt.new(origin, as_int, original_text)
+    else
+      Hocon::Impl::ConfigFloat.new(origin, number, original_text)
+    end
+  end
+
+  def initialize(origin, original_text)
+    super(origin)
+    @original_text = original_text
+  end
+
+  def transform_to_string
+    @original_text
+  end
+end

data/lib/hocon/impl/config_string.rb

@@ -0,0 +1,37 @@
+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
+  ConfigImplUtil = Hocon::Impl::ConfigImplUtil
+
+  def initialize(origin, value)
+    super(origin)
+    @value = value
+  end
+
+  def value_type
+    Hocon::ConfigValueType::STRING
+  end
+
+  def unwrapped
+    @value
+  end
+
+  def transform_to_string
+    @value
+  end
+
+  def render_value_to_sb(sb, indent_size, at_root, options)
+    if options.json?
+      sb << ConfigImplUtil.render_json_string(@value)
+    else
+      sb << ConfigImplUtil.render_string_unquoted_if_possible(@value)
+    end
+  end
+
+  def new_copy(origin)
+    Hocon::Impl::ConfigString.new(origin, @value)
+  end
+end