hocon 0.0.7 → 0.1.0

data/lib/hocon/impl/config_double.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'hocon/impl'
+require 'hocon/impl/config_number'
+
+class Hocon::Impl::ConfigDouble < Hocon::Impl::ConfigNumber
+  def initialize(origin, value, original_text)
+    super(origin, original_text)
+    @value = value
+  end
+
+  attr_reader :value
+
+  def value_type
+    Hocon::ConfigValueType::NUMBER
+  end
+
+  def unwrapped
+    @value
+  end
+
+  def transform_to_string
+    s = super
+    if s.nil?
+      @value.to_s
+    else
+      s
+    end
+  end
+
+  def long_value
+    @value.to_i
+  end
+
+  def double_value
+    @value
+  end
+
+  def new_copy(origin)
+    self.class.new(origin, @value, original_text)
+  end
+
+  # NOTE: skipping `writeReplace` from upstream, because it involves serialization
+end

data/lib/hocon/impl/config_impl.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 require 'hocon/impl/simple_includer'
 require 'hocon/config_error'
@@ -6,14 +8,17 @@ require 'hocon/impl/simple_config_origin'
 require 'hocon/impl/simple_config_list'
 require 'hocon/impl/config_boolean'
 require 'hocon/impl/config_null'
+require 'hocon/impl/parseable'
 
 class Hocon::Impl::ConfigImpl
-  @default_includer = Hocon::Impl::SimpleIncluder.new
+  @default_includer = Hocon::Impl::SimpleIncluder.new(nil)
   @default_value_origin = Hocon::Impl::SimpleConfigOrigin.new_simple("hardcoded value")
   @default_true_value = Hocon::Impl::ConfigBoolean.new(@default_value_origin, true)
   @default_false_value = Hocon::Impl::ConfigBoolean.new(@default_value_origin, false)
   @default_null_value = Hocon::Impl::ConfigNull.new(@default_value_origin)
   @default_empty_list = Hocon::Impl::SimpleConfigList.new(@default_value_origin, Array.new)
+  @default_empty_object = Hocon::Impl::SimpleConfigObject.empty(@default_value_origin)
+
 
   ConfigBugOrBrokenError = Hocon::ConfigError::ConfigBugOrBrokenError
   ConfigNotResolvedError = Hocon::ConfigError::ConfigNotResolvedError
@@ -23,9 +28,16 @@ class Hocon::Impl::ConfigImpl
     @default_includer
   end
 
+
+  class FileNameSource < Hocon::Impl::SimpleIncluder::NameSource
+    def name_to_parseable(name, parse_options)
+      Hocon::Impl::Parseable.new_file(name, parse_options)
+    end
+  end
+
   def self.improve_not_resolved(what, original)
     new_message = "#{what.render} has not been resolved, you need to call Config#resolve, see API docs for Config#resolve"
-    if new_message == original.get_message
+    if new_message == original.message
       return original
     else
       return ConfigNotResolvedError.new(new_message, original)
@@ -40,14 +52,11 @@ class Hocon::Impl::ConfigImpl
     end
   end
 
-  def self.empty_object(origin)
-    # we want null origin to go to SimpleConfigObject.empty() to get the
-    # origin "empty config" rather than "hardcoded value"
-    if origin == @default_value_origin
-      return default_empty_object
-    else
-      return Hocon::Impl::SimpleConfigObject.empty(origin)
-    end
+  def self.parse_file_any_syntax(basename, base_options)
+    source = FileNameSource.new()
+    Hocon::Impl::SimpleIncluder.from_basename(source,
+                                              File.expand_path(basename),
+                                              base_options)
   end
 
   def self.empty_list(origin)
@@ -65,7 +74,7 @@ class Hocon::Impl::ConfigImpl
 
   def self.from_any_ref_mode(object, origin, map_mode)
     if origin.nil?
-      raise ConfigBugOrBrokenError.new("origin not supposed to be nil", nil)
+      raise ConfigBugOrBrokenError.new("origin not supposed to be nil")
     end
     if object.nil?
       if origin != @default_value_origin
@@ -73,6 +82,8 @@ class Hocon::Impl::ConfigImpl
       else
         return @default_null_value
       end
+    elsif object.is_a?(Hocon::Impl::AbstractConfigValue)
+      return object
     elsif object.is_a?(TrueClass) || object.is_a?(FalseClass)
       if origin != @default_value_origin
         return Hocon::Impl::ConfigBoolean.new(origin, object)
@@ -82,7 +93,7 @@ class Hocon::Impl::ConfigImpl
         return @default_false_value
       end
     elsif object.is_a?(String)
-      return Hocon::Impl::ConfigString.new(origin, object)
+      return Hocon::Impl::ConfigString::Quoted.new(origin, object)
     elsif object.is_a?(Numeric)
       # here we always keep the same type that was passed to us,
       # rather than figuring out if a Long would fit in an Int
@@ -90,7 +101,7 @@ class Hocon::Impl::ConfigImpl
       # not using ConfigNumber.newNumber() when we have a
       # Double, Integer, or Long.
       if object.is_a?(Float)
-        return Hocon::Impl::ConfigFloat.new(origin, object, nil)
+        return Hocon::Impl::ConfigDouble.new(origin, object, nil)
       elsif object.is_a?(Integer)
         return Hocon::Impl::ConfigInt.new(origin, object, nil)
       else
@@ -98,7 +109,7 @@ class Hocon::Impl::ConfigImpl
       end
     elsif object.is_a?(Hash)
       if object.empty?
-        return self.empty_object(origin)
+        return self.empty_object_from_origin(origin)
       end
 
       if map_mode == FromMapMode::KEYS_ARE_KEYS
@@ -106,15 +117,14 @@ class Hocon::Impl::ConfigImpl
         object.each do |key, entry|
           if not key.is_a?(String)
             raise ConfigBugOrBrokenError.new(
-                      "bug in method caller: not valid to create ConfigObject from map with non-String key: #{key}",
-                      nil)
+                      "bug in method caller: not valid to create ConfigObject from map with non-String key: #{key}")
           end
           value = self.from_any_ref_mode(entry, origin, map_mode)
           values[key] = value
         end
         return Hocon::Impl::SimpleConfigObject.new(origin, values)
       else
-        return Hocon::Impl::PropertiesParser.from_path_map(origin, object)
+        raise ConfigBugOrBrokenError, "java properties format not supported"
       end
     elsif object.is_a?(Enumerable)
       if object.count == 0
@@ -129,7 +139,121 @@ class Hocon::Impl::ConfigImpl
 
       return Hocon::Impl::SimpleConfigList.new(origin, values)
     else
-      raise ConfigBugOrBrokenError.new("bug in method caller: not valid to create ConfigValue from: #{object}", nil)
+      raise ConfigBugOrBrokenError.new("bug in method caller: not valid to create ConfigValue from: #{object}")
+    end
+  end
+
+
+
+  def self.env_variables_as_config_object
+    EnvVariablesHolder.get_env_variables
+  end
+
+  # This class is a lot simpler than the Java version ...
+  # The Java version uses system properties to toggle these settings.
+  # We don't have system properties in MRI so it's not clear what to do here.
+  # Initially, I ported this as more of a direct translation from the Java code,
+  # but I ran into issues around how to translate stupid Java static
+  # initialization crap to Ruby, so what we have here is a much simpler version
+  # that is # equivalent.
+  #
+  # There's no way to toggle this logging without changing code, but it's
+  # actually proved to be useful for debugging purposes while porting code
+  # down from Java.
+  class DebugHolder
+    class << self
+
+      def trace_loads_enabled
+        TRACE_LOADS_ENABLED
+      end
+
+      def trace_substitutions_enabled
+        TRACE_SUBSTITUTIONS_ENABLED
+      end
+
+      private
+
+      TRACE_LOADS_ENABLED = false
+      TRACE_SUBSTITUTIONS_ENABLED = false
+    end
+  end
+
+  def self.trace_loads_enabled
+    # Ignoring 'catch ExceptionInInitializerError' from that java version,
+    # that is just terrible java code anyway.
+    DebugHolder.trace_loads_enabled
+  end
+
+  def self.trace_substitution_enabled
+    # Ignoring 'catch ExceptionInInitializerError' from that java version,
+    # that is just terrible java code anyway.
+    DebugHolder.trace_substitutions_enabled
+  end
+
+  def self.trace(message, indent_level = 0)
+    while indent_level > 0
+      $stderr.putc(" ")
+      indent_level -= 1
+    end
+    $stderr.puts(message)
+  end
+
+  def self.empty_object_from_origin(origin)
+    # we want null origin to go to SimpleConfigObject.empty() to get the
+    # origin "empty config" rather than "hardcoded value"
+    if origin == @default_value_origin
+      @default_empty_object
+    else
+      Hocon::Impl::SimpleConfigObject.empty(origin)
+    end
+  end
+
+  def self.empty_object(origin_description)
+    if !origin_description.nil?
+      origin = Hocon::Impl::SimpleConfigOrigin.new_simple(origin_description)
+    else
+      origin = nil
+    end
+
+    empty_object_from_origin(origin)
+  end
+
+  def self.empty_config(origin_description)
+    empty_object(origin_description).to_config
+  end
+
+  def empty(origin)
+    self.class.empty_object_from_origin(origin)
+  end
+
+  def self.default_reference
+    resource = Hocon::Impl::Parseable.new_resources("reference.conf",
+                                                    Hocon::ConfigParseOptions.defaults)
+    resource.parse.to_config
+  end
+
+  private
+
+  def self.load_env_variables
+    env = ENV
+    m = {}
+    env.each do |key, value|
+      m[key] = Hocon::Impl::ConfigString::Quoted.new(
+          Hocon::Impl::SimpleConfigOrigin.new_simple("env var #{key}"), value)
+    end
+
+    Hocon::Impl::SimpleConfigObject.new(
+        Hocon::Impl::SimpleConfigOrigin.new_simple("env variables"),
+        m,
+        Hocon::Impl::ResolveStatus::RESOLVED,
+        false)
+  end
+
+  class EnvVariablesHolder
+    ENV_VARIABLES = Hocon::Impl::ConfigImpl.load_env_variables
+
+    def self.get_env_variables
+      ENV_VARIABLES
     end
   end
-end
+end

data/lib/hocon/impl/config_impl_util.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 require 'stringio'
 
@@ -68,6 +70,22 @@ class Hocon::Impl::ConfigImplUtil
     s
   end
 
+  def self.join_path(*elements)
+    Hocon::Impl::Path.from_string_list(elements).render
+  end
+
+  def self.split_path(path)
+    p = Hocon::Impl::Path.new_path(path)
+    elements = []
+
+    until p.nil?
+      elements << p.first
+      p = p.remainder
+    end
+
+    elements
+  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

data/lib/hocon/impl/config_include_kind.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require 'hocon/impl'
+
+module Hocon::Impl::ConfigIncludeKind
+  URL = 0
+  FILE = 1
+  CLASSPATH = 2
+  HEURISTIC = 3
+end

data/lib/hocon/impl/config_int.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 require 'hocon/impl/config_number'
 require 'hocon/config_value_type'
@@ -8,6 +10,8 @@ class Hocon::Impl::ConfigInt < Hocon::Impl::ConfigNumber
     @value = value
   end
 
+  attr_reader :value
+
   def value_type
     Hocon::ConfigValueType::NUMBER
   end
@@ -25,7 +29,15 @@ class Hocon::Impl::ConfigInt < Hocon::Impl::ConfigNumber
     end
   end
 
+  def long_value
+    @value
+  end
+
+  def double_value
+    @value
+  end
+
   def new_copy(origin)
     Hocon::Impl::ConfigInt.new(origin, @value, @original_text)
   end
-end
+end

data/lib/hocon/impl/config_node_array.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'hocon/impl'
+require 'hocon/impl/config_node_complex_value'
+
+class Hocon::Impl::ConfigNodeArray
+  include Hocon::Impl::ConfigNodeComplexValue
+  def new_node(nodes)
+    self.class.new(nodes)
+  end
+end

data/lib/hocon/impl/config_node_comment.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'hocon/impl'
+require 'hocon/config_error'
+require 'hocon/impl/config_node_single_token'
+require 'hocon/impl/tokens'
+
+class Hocon::Impl::ConfigNodeComment < Hocon::Impl::ConfigNodeSingleToken
+  def initialize(comment)
+    super(comment)
+    unless Hocon::Impl::Tokens.comment?(@token)
+      raise Hocon::ConfigError::ConfigBugOrBrokenError, 'Tried to create a ConfigNodeComment from a non-comment token'
+    end
+  end
+
+  def comment_text
+    Hocon::Impl::Tokens.comment_text(@token)
+  end
+end

data/lib/hocon/impl/config_node_complex_value.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'hocon/impl'
+require 'hocon/impl/abstract_config_node_value'
+require 'hocon/impl/config_node_field'
+require 'hocon/impl/config_node_include'
+require 'hocon/impl/config_node_single_token'
+require 'hocon/impl/tokens'
+require 'hocon/config_error'
+
+module Hocon::Impl::ConfigNodeComplexValue
+  include Hocon::Impl::AbstractConfigNodeValue
+  def initialize(children)
+    @children = children
+  end
+
+  attr_reader :children
+
+  def tokens
+    tokens = []
+    @children.each do |child|
+      tokens += child.tokens
+    end
+    tokens
+  end
+
+  def indent_text(indentation)
+    children_copy = @children.clone
+    i = 0
+    while i < children_copy.size
+      child = children_copy[i]
+      if child.is_a?(Hocon::Impl::ConfigNodeSingleToken) && Hocon::Impl::Tokens.newline?(child.token)
+        children_copy.insert(i + 1, indentation)
+        i += 1
+      elsif child.is_a?(Hocon::Impl::ConfigNodeField)
+        value = child.value
+        if value.is_a?(Hocon::Impl::ConfigNodeComplexValue)
+          children_copy[i] = child.replace_value(value.indent_text(indentation))
+        end
+      elsif child.is_a?(Hocon::Impl::ConfigNodeComplexValue)
+        children_copy[i] = child.indent_text(indentation)
+      end
+      i += 1
+    end
+    new_node(children_copy)
+  end
+
+  # This method will just call into the object's constructor, but it's needed
+  # for use in the indentText() method so we can avoid a gross if/else statement
+  # checking the type of this
+  def new_node(nodes)
+    raise Hocon::ConfigError::ConfigBugOrBrokenError, "subclasses of ConfigNodeComplexValue should override `new_node` (#{self.class})"
+  end
+end