hocon 0.0.7 → 0.1.0

data/lib/hocon/impl/resolve_status.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 
 class Hocon::Impl::ResolveStatus
@@ -15,4 +17,4 @@ class Hocon::Impl::ResolveStatus
   def self.from_boolean(resolved)
     resolved ? RESOLVED : UNRESOLVED
   end
-end
+end

data/lib/hocon/impl/simple_config.rb

@@ -1,10 +1,16 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 require 'hocon/config_value_type'
+require 'hocon/config_resolve_options'
 require 'hocon/impl/path'
 require 'hocon/impl/default_transformer'
 require 'hocon/impl/config_impl'
+require 'hocon/impl/resolve_context'
+require 'hocon/config_mergeable'
 
 class Hocon::Impl::SimpleConfig
+  include Hocon::ConfigMergeable
 
   ConfigMissingError = Hocon::ConfigError::ConfigMissingError
   ConfigNotResolvedError = Hocon::ConfigError::ConfigNotResolvedError
@@ -14,15 +20,35 @@ class Hocon::Impl::SimpleConfig
   Path = Hocon::Impl::Path
   DefaultTransformer = Hocon::Impl::DefaultTransformer
 
+  attr_reader :object
+
   def initialize(object)
     @object = object
   end
+  attr_reader :object
 
   def root
     @object
   end
 
-  def find_key(me, key, expected, original_path)
+  def origin
+    @object.origin
+  end
+
+  def resolve(options = Hocon::ConfigResolveOptions.defaults)
+    resolve_with(self, options)
+  end
+
+  def resolve_with(source, options)
+    resolved = Hocon::Impl::ResolveContext.resolve(@object, source.object, options)
+    if resolved.eql?(@object)
+      self
+    else
+      Hocon::Impl::SimpleConfig.new(resolved)
+    end
+  end
+
+  def self.find_key(me, key, expected, original_path)
     v = me.peek_assuming_resolved(key, original_path)
     if v.nil?
       raise ConfigMissingError.new(nil, "No configuration setting found for key '#{original_path.render}'", nil)
@@ -35,12 +61,12 @@ class Hocon::Impl::SimpleConfig
     if v.value_type == ConfigValueType::NULL
       raise ConfigNullError.new(v.origin,
                                 (ConfigNullError.make_message(original_path.render,
-                                                              (not expected.nil?) ? expected.name : nil)),
+                                                              (not expected.nil?) ? ConfigValueType.name(expected) : nil)),
                                 nil)
     elsif (not expected.nil?) && v.value_type != expected
       raise ConfigWrongTypeError.new(v.origin,
-                                     "#{original_path.render} has type #{v.value_type.name} " +
-                                         "rather than #{expected.name}",
+                                     "#{original_path.render} has type #{ConfigValueType.name(v.value_type)} " +
+                                         "rather than #{ConfigValueType.name(expected)}",
                                      nil)
     else
       return v
@@ -51,30 +77,250 @@ class Hocon::Impl::SimpleConfig
     key = path.first
     rest = path.remainder
     if rest.nil?
-      find_key(me, key, expected, original_path)
+      self.class.find_key(me, key, expected, original_path)
     else
-      o = find_key(me, key, ConfigValueType::OBJECT,
+      o = self.class.find_key(me, key, ConfigValueType::OBJECT,
                    original_path.sub_path(0, original_path.length - rest.length))
       raise "Error: object o is nil" unless not o.nil?
       find(o, rest, expected, original_path)
     end
   end
 
+  def find3(path_expression, expected, original_path)
+    find(@object, path_expression, expected, original_path)
+  end
+
+  def find2(path_expression, expected)
+    path = Path.new_path(path_expression)
+    find3(path, expected, path)
+  end
+
+  def ==(other)
+    if other.is_a? Hocon::Impl::SimpleConfig
+      @object == other.object
+    else
+      false
+    end
+  end
+
+  def hash
+    41 * @object.hash
+  end
+
+  def self.find_key_or_null(me, key, expected, original_path)
+    v = me.peek_assuming_resolved(key, original_path)
+
+    if v.nil?
+      raise Hocon::ConfigError::ConfigMissingError.new(nil, original_path.render, nil)
+    end
+
+    if not expected.nil?
+      v = Hocon::Impl::DefaultTransformer.transform(v, expected)
+    end
+
+    if (not expected.nil?) && (v.value_type != expected && v.value_type != Hocon::ConfigValueType::NULL)
+      raise Hocon::ConfigError::ConfigWrongTypeError.with_expected_actual(v.origin,
+                                                                          original_path.render,
+                                                                          expected.name,
+                                                                          Hocon::ConfigValueType.name(v.value_type))
+    else
+      return v
+    end
+  end
+
+  def self.find_or_null(me, path, expected, original_path)
+    begin
+      key = path.first
+      remainder = path.remainder
+
+      if remainder.nil?
+        return self.find_key_or_null(me, key, expected, original_path)
+      else
+        o = find_key(me,
+                     key,
+                     Hocon::ConfigValueType::OBJECT,
+                     original_path.sub_path(0, original_path.length - remainder.length))
+
+        if o.nil?
+          raise "Missing key: #{key} on path: #{path}"
+        end
+
+        find_or_null(o, remainder, expected, original_path)
+      end
+    rescue Hocon::ConfigError::ConfigNotResolvedError
+      raise Hocon::Impl::ConfigImpl::improved_not_resolved(path, e)
+    end
+  end
+
+  def is_null?(path_expression)
+    path = Path.new_path(path_expression)
+    v = self.class.find_or_null(@object, path, nil, path)
+    v.value_type == Hocon::ConfigValueType::NULL
+  end
+
   def get_value(path)
     parsed_path = Path.new_path(path)
     find(@object, parsed_path, nil, parsed_path)
   end
 
-  def has_path(path_expression)
+  def get_boolean(path)
+    v = find2(path, ConfigValueType::BOOLEAN)
+    v.unwrapped
+  end
+
+  def get_config_number(path_expression)
     path = Path.new_path(path_expression)
+    v = find(@object, path, ConfigValueType::NUMBER, path)
+    v.unwrapped
+  end
+
+  def get_int(path)
+    get_config_number(path)
+  end
+
+  def get_string(path)                                                                                                                                                                                                                                                                 
+    v = find2(path, ConfigValueType::STRING)
+    v.unwrapped
+  end
+
+  def get_list(path)
+    find2(path, ConfigValueType::LIST)
+  end
+
+  def get_object(path)
+    find2(path, ConfigValueType::OBJECT)
+  end
+
+  def get_config(path)
+    get_object(path).to_config
+  end
+
+  def get_any_ref(path)
+    v = find2(path, nil)
+    v.unwrapped
+  end
+
+  def get_bytes(path)
+    size = null
+    begin
+      size = get_long(path)
+    rescue ConfigWrongTypeError => e
+      v = find2(path, ConfigValueType::STRING)
+      size = self.class.parse_bytes(v.unwrapped, v.origin, path)
+    end
+    size
+  end
+
+  def get_homogeneous_unwrapped_list(path, expected)
+    l = []
+    list = get_list(path)
+    list.each do |cv|
+      if !expected.nil?
+        v = DefaultTransformer.transform(cv, expected)
+      end
+      if v.value_type != expected
+        raise ConfigWrongTypeError.with_expected_actual(origin, path,
+              "list of #{expected.name}",
+              "list of #{v.value_type.name}")
+      end
+      l << v.unwrapped
+    end
+    l
+  end
+
+  def get_boolean_list(path)
+    get_homogeneous_unwrapped_list(path, ConfigValueType::BOOLEAN)
+  end
+
+  def get_number_list(path)
+    get_homogeneous_unwrapped_list(path, ConfigValueType::NUMBER)
+  end
+
+  def get_int_list(path)
+    l = []
+    numbers = get_homogeneous_wrapped_list(path, ConfigValueType::NUMBER)
+    numbers.each do |v|
+      l << v.int_value_range_checked(path)
+    end
+    l
+  end
+
+  def get_double_list(path)
+    l = []
+    numbers = get_number_list(path)
+    numbers.each do |n|
+      l << n.double_value
+    end
+    l
+  end
+
+  def get_string_list(path)
+    get_homogeneous_unwrapped_list(path, ConfigValueType::STRING)
+  end
+
+  def get_object_list(path)
+    get_homogeneous_wrapped_list(path, ConfigValueType::OBJECT)
+  end
+
+  def get_homogeneous_wrapped_list(path, expected)
+    l = []
+    list = get_list(path)
+    list.each do |cv|
+      if !expected.nil?
+        v = DefaultTransformer.transform(cv, expected)
+      end
+      if v.value_type != expected
+        raise ConfigWrongTypeError.with_expected_actual(origin, path,
+                                                        "list of #{expected.name}",
+                                                        "list of #{v.value_type.name}")
+      end
+      l << v
+    end
+    l
+  end
+
+  def has_path_peek(path_expression)
+    path = Path.new_path(path_expression)
+
     begin
       peeked = @object.peek_path(path)
-    rescue ConfigNotResolvedError => e
-      raise Hocon::Impl::ConfigImpl.improve_not_resolved(path, e)
+    rescue Hocon::ConfigError::ConfigNotResolvedError
+      raise Hocon::Impl::ConfigImpl.improved_not_resolved(path, e)
     end
+
+    peeked
+  end
+
+  def has_path?(path_expression)
+    peeked = has_path_peek(path_expression)
+
     (not peeked.nil?) && peeked.value_type != ConfigValueType::NULL
   end
 
+  def has_path_or_null?(path)
+    peeked = has_path_peek(path)
+
+    not peeked.nil?
+  end
+
+  def empty?
+    @object.empty?
+  end
+
+  def at_key(key)
+    root.at_key(key)
+  end
+
+  # In java this is an overloaded version of atKey
+  def at_key_with_origin(origin, key)
+    root.at_key_with_origin(origin, key)
+  end
+
+  def with_only_path(path_expression)
+    path = Path.new_path(path_expression)
+    self.class.new(root.with_only_path(path))
+  end
+
   def without_path(path_expression)
     path = Path.new_path(path_expression)
     self.class.new(root.without_path(path))
@@ -84,4 +330,12 @@ class Hocon::Impl::SimpleConfig
     path = Path.new_path(path_expression)
     self.class.new(root.with_value(path, v))
   end
-end
+
+  def to_fallback_value
+    @object
+  end
+
+  def with_fallback(other)
+    @object.with_fallback(other).to_config
+  end
+end

data/lib/hocon/impl/simple_config_document.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'hocon/impl'
+require 'hocon/parser/config_document'
+require 'hocon/impl/config_document_parser'
+
+class Hocon::Impl::SimpleConfigDocument
+  include Hocon::Parser::ConfigDocument
+
+  def initialize(parsed_node, parse_options)
+    @config_node_tree = parsed_node
+    @parse_options = parse_options
+  end
+
+  def set_value(path, new_value)
+    origin = Hocon::Impl::SimpleConfigOrigin.new_simple("single value parsing")
+    reader = StringIO.new(new_value)
+    tokens = Hocon::Impl::Tokenizer.tokenize(origin, reader, @parse_options.syntax)
+    parsed_value = Hocon::Impl::ConfigDocumentParser.parse_value(tokens, origin, @parse_options)
+    reader.close
+
+    self.class.new(@config_node_tree.set_value(path, parsed_value, @parse_options.syntax), @parse_options)
+  end
+
+  def set_config_value(path, new_value)
+    set_value(path, new_value.render)
+  end
+
+  def remove_value(path)
+    self.class.new(@config_node_tree.set_value(path, nil, @parse_options.syntax), @parse_options)
+  end
+
+  def has_value?(path)
+    @config_node_tree.has_value(path)
+  end
+
+  def render
+    @config_node_tree.render
+  end
+
+  def ==(other)
+    other.class.ancestors.include?(Hocon::Parser::ConfigDocument) && render == other.render
+  end
+
+  def hash
+    render.hash
+  end
+end

data/lib/hocon/impl/simple_config_list.rb

@@ -1,10 +1,25 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 require 'hocon/impl/resolve_status'
 require 'hocon/config_value_type'
+require 'hocon/config_error'
 require 'hocon/impl/abstract_config_object'
+require 'forwardable'
+require 'hocon/impl/unsupported_operation_error'
+require 'hocon/impl/resolve_result'
+require 'hocon/impl/container'
+require 'hocon/config_list'
+
+class Hocon::Impl::SimpleConfigList
+  include Hocon::Impl::Container
+  include Hocon::ConfigList
+  include Hocon::Impl::AbstractConfigValue
+  extend Forwardable
 
-class Hocon::Impl::SimpleConfigList < Hocon::Impl::AbstractConfigValue
   ResolveStatus = Hocon::Impl::ResolveStatus
+  ResolveResult = Hocon::Impl::ResolveResult
+  ConfigBugOrBrokenError = Hocon::ConfigError::ConfigBugOrBrokenError
 
   def initialize(origin, value, status = ResolveStatus.from_values(value))
     super(origin)
@@ -13,10 +28,14 @@ class Hocon::Impl::SimpleConfigList < Hocon::Impl::AbstractConfigValue
 
     # 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}"
+      raise ConfigBugOrBrokenError, "SimpleConfigList created with wrong resolve status: #{self}"
     end
   end
 
+  attr_reader :value
+
+  def_delegators :@value, :[], :include?, :empty?, :size, :index, :rindex, :each, :map
+
   def value_type
     Hocon::ConfigValueType::LIST
   end
@@ -25,6 +44,143 @@ class Hocon::Impl::SimpleConfigList < Hocon::Impl::AbstractConfigValue
     @value.map { |v| v.unwrapped }
   end
 
+  def resolve_status
+    ResolveStatus.from_boolean(@resolved)
+  end
+
+  def replace_child(child, replacement)
+    new_list = replace_child_in_list(@value, child, replacement)
+    if new_list.nil?
+      nil
+    else
+      # we use the constructor flavor that will recompute the resolve status
+      SimpleConfigList.new(origin, new_list)
+    end
+  end
+
+  def has_descendant?(descendant)
+    Hocon::Impl::AbstractConfigValue.has_descendant_in_list?(@value, descendant)
+  end
+
+  def modify(modifier, new_resolve_status)
+    begin
+      modify_may_throw(modifier, new_resolve_status)
+    rescue Hocon::ConfigError => e
+      raise e
+    end
+  end
+
+  def modify_may_throw(modifier, new_resolve_status)
+    # lazy-create for optimization
+    changed = nil
+    i = 0
+    @value.each { |v|
+      modified = modifier.modify_child_may_throw(nil, v)
+
+      # lazy-create the new list if required
+      if changed == nil && !modified.equal?(v)
+        changed = []
+        j = 0
+        while j < i
+          changed << @value[j]
+          j += 1
+        end
+      end
+
+      # once the new list is created, all elements
+      # have to go in it.if modifyChild returned
+      # null, we drop that element.
+      if changed != nil && modified != nil
+        changed << modified
+      end
+
+      i += 1
+    }
+
+    if changed != nil
+      if new_resolve_status != nil
+        self.class.new(origin, changed, new_resolve_status)
+      else
+        self.class.new(origin, changed)
+      end
+    else
+      self
+    end
+  end
+
+  class ResolveModifier
+    attr_reader :context, :source
+    def initialize(context, source)
+      @context = context
+      @source = source
+    end
+
+    def modify_child_may_throw(key, v)
+      result = @context.resolve(v, source)
+      @context = result.context
+      result.value
+    end
+  end
+
+  def resolve_substitutions(context, source)
+    if @resolved
+      return Hocon::Impl::ResolveResult.make(context, self)
+    end
+
+    if context.is_restricted_to_child
+      # if a list restricts to a child path, then it has no child paths,
+      # so nothing to do.
+      Hocon::Impl::ResolveResult.make(context, self)
+    else
+      begin
+        modifier = ResolveModifier.new(context, source.push_parent(self))
+        value = modify_may_throw(modifier, context.options.allow_unresolved ? nil : ResolveStatus::RESOLVED)
+        Hocon::Impl::ResolveResult.make(modifier.context, value)
+      rescue NotPossibleToResolve => e
+        raise e
+      rescue RuntimeError => e
+        raise e
+      rescue Exception => e
+        raise ConfigBugOrBrokenError.new("unexpected exception", e)
+      end
+    end
+  end
+
+  def relativized(prefix)
+    modifier = Class.new do
+      include Hocon::Impl::AbstractConfigValue::NoExceptionsModifier
+
+      # prefix isn't in scope inside of a def, but it is in scope inside of Class.new
+      # so manually define a method that has access to prefix
+      # I feel dirty
+      define_method(:modify_child) do |key, v|
+        v.relativized(prefix)
+      end
+    end
+
+    modify(modifier.new, resolve_status)
+  end
+
+  def can_equal(other)
+    other.is_a?(self.class)
+  end
+
+  def ==(other)
+    # note that "origin" is deliberately NOT part of equality
+    if other.is_a?(self.class)
+      # optimization to avoid unwrapped() for two ConfigList
+      can_equal(other) &&
+          (value.equal?(other.value) || (value == other.value))
+    else
+      false
+    end
+  end
+
+  def hash
+    # note that "origin" is deliberately NOT part of equality
+    value.hash
+  end
+
   def render_value_to_sb(sb, indent_size, at_root, options)
     if @value.empty?
       sb << "[]"
@@ -35,10 +191,13 @@ class Hocon::Impl::SimpleConfigList < Hocon::Impl::AbstractConfigValue
       end
       @value.each do |v|
         if options.origin_comments?
-          indent(sb, indent_size + 1, options)
-          sb << "# "
-          sb << v.origin.description
-          sb << "\n"
+          lines = v.origin.description.split("\n")
+          lines.each do |l|
+            Hocon::Impl::AbstractConfigValue.indent(sb, indent_size + 1, options)
+            sb << "# "
+            sb << l
+            sb << "\n"
+          end
         end
         if options.comments?
           v.origin.comments.each do |comment|
@@ -47,7 +206,7 @@ class Hocon::Impl::SimpleConfigList < Hocon::Impl::AbstractConfigValue
             sb << "\n"
           end
         end
-        indent(sb, indent_size + 1, options)
+        Hocon::Impl::AbstractConfigValue.indent(sb, indent_size + 1, options)
 
         v.render_value_to_sb(sb, indent_size + 1, at_root, options)
         sb << ","
@@ -63,13 +222,128 @@ class Hocon::Impl::SimpleConfigList < Hocon::Impl::AbstractConfigValue
       if options.formatted?
         sb.pos = sb.pos - 1 # also chop comma
         sb << "\n"
-        indent(sb, indent_size, options)
+        Hocon::Impl::AbstractConfigValue.indent(sb, indent_size, options)
       end
       sb << "]"
     end
   end
 
+  def contains?(o)
+    value.include?(o)
+  end
+
+  def include_all?(value_list)
+    value_list.all? { |v| @value.include?(v)}
+  end
+
+  def contains_all?(c)
+    include_all?(c)
+  end
+
+  def get(index)
+    value[index]
+  end
+
+  def index_of(o)
+    value.index(o)
+  end
+
+  def is_empty
+    empty?
+  end
+
+  # Skipping upstream definition of "iterator", because that's not really a thing
+  # in Ruby.
+
+  def last_index_of(o)
+    value.rindex(o)
+  end
+
+  # skipping upstream definitions of "wrapListIterator", "listIterator", and
+  # "listIterator(int)", because those don't really apply in Ruby.
+
+  def sub_list(from_index, to_index)
+    value[from_index..to_index]
+  end
+
+  def to_array
+    value
+  end
+
+  def we_are_immutable(method)
+    Hocon::Impl::UnsupportedOperationError.new("ConfigList is immutable, you can't call List. '#{method}'")
+  end
+
+  def add(e)
+    raise we_are_immutable("add")
+  end
+
+  def add_at(index, element)
+    raise we_are_immutable("add_at")
+  end
+
+  def add_all(c)
+    raise we_are_immutable("add_all")
+  end
+
+  def add_all_at(index, c)
+    raise we_are_immutable("add_all_at")
+  end
+
+  def clear
+    raise we_are_immutable("clear")
+  end
+
+  def remove(o)
+    raise we_are_immutable("remove")
+  end
+
+  def remove_at(i)
+    raise we_are_immutable("remove_at")
+  end
+
+  def delete(o)
+    raise we_are_immutable("delete")
+  end
+
+  def remove_all(c)
+    raise we_are_immutable("remove_all")
+  end
+
+  def retain_all(c)
+    raise we_are_immutable("retain_all")
+  end
+
+  def set(index, element)
+    raise we_are_immutable("set")
+  end
+
+  def []=(index, element)
+    raise we_are_immutable("[]=")
+  end
+
+  def push(e)
+    raise we_are_immutable("push")
+  end
+
+  def <<(e)
+    raise we_are_immutable("<<")
+  end
+
   def new_copy(origin)
     Hocon::Impl::SimpleConfigList.new(origin, @value)
   end
+
+  def concatenate(other)
+    combined_origin = Hocon::Impl::SimpleConfigOrigin.merge_two_origins(origin, other.origin)
+    combined = value + other.value
+    Hocon::Impl::SimpleConfigList.new(combined_origin, combined)
+  end
+
+  # Skipping upstream "writeReplace" until we see that we need it for something
+
+  def with_origin(origin)
+    super(origin)
+  end
+
 end