hocon 0.0.4 → 0.0.5

data/lib/hocon/impl/abstract_config_value.rb

@@ -127,4 +127,20 @@ class Hocon::Impl::AbstractConfigValue
     sb.string[0, sb.pos]
   end
 
+  def at_key(origin, key)
+    m = {key=>self}
+    Hocon::Impl::SimpleConfigObject.new(origin, m).to_config
+  end
+
+  def at_path(origin, path)
+    parent = path.parent
+    result = at_key(origin, path.last)
+    while not parent.nil? do
+      key = parent.last
+      result = result.at_key(origin, key)
+      parent = parent.parent
+    end
+    result
+  end
+
 end

data/lib/hocon/impl/config_boolean.rb

@@ -0,0 +1,25 @@
+require 'hocon/impl'
+require 'hocon/impl/abstract_config_value'
+
+class Hocon::Impl::ConfigBoolean < Hocon::Impl::AbstractConfigValue
+  def initialize(origin, value)
+    super(origin)
+    @value = value
+  end
+
+  def value_type
+    Hocon::ConfigValueType::BOOLEAN
+  end
+
+  def unwrapped
+    @value
+  end
+
+  def transform_to_string
+    @value.to_s
+  end
+
+  def new_copy(origin)
+    Hocon::Impl::ConfigBoolean.new(origin, @value)
+  end
+end

data/lib/hocon/impl/config_float.rb

@@ -6,4 +6,8 @@ class Hocon::Impl::ConfigFloat < Hocon::Impl::ConfigNumber
     super(origin, original_text)
     @value = value
   end
+
+  def unwrapped
+    @value
+  end
 end

data/lib/hocon/impl/config_impl.rb

@@ -1,10 +1,135 @@
 require 'hocon/impl'
 require 'hocon/impl/simple_includer'
+require 'hocon/config_error'
+require 'hocon/impl/from_map_mode'
+require 'hocon/impl/simple_config_origin'
+require 'hocon/impl/simple_config_list'
+require 'hocon/impl/config_boolean'
+require 'hocon/impl/config_null'
 
 class Hocon::Impl::ConfigImpl
   @default_includer = Hocon::Impl::SimpleIncluder.new
+  @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)
+
+  ConfigBugOrBrokenError = Hocon::ConfigError::ConfigBugOrBrokenError
+  ConfigNotResolvedError = Hocon::ConfigError::ConfigNotResolvedError
+  FromMapMode = Hocon::Impl::FromMapMode
 
   def self.default_includer
     @default_includer
   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
+      return original
+    else
+      return ConfigNotResolvedError.new(new_message, original)
+    end
+  end
+
+  def self.value_origin(origin_description)
+    if origin_description.nil?
+      return @default_value_origin
+    else
+      return Hocon::Impl::SimpleConfigOrigin.new_simple(origin_description)
+    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
+  end
+
+  def self.empty_list(origin)
+    if origin.nil? || origin == @default_value_origin
+      return @default_empty_list
+    else
+      return Hocon::Impl::SimpleConfigList.new(origin, Array.new)
+    end
+  end
+
+  def self.from_any_ref(object, origin_description)
+    origin = self.value_origin(origin_description)
+    from_any_ref_mode(object, origin, FromMapMode::KEYS_ARE_KEYS)
+  end
+
+  def self.from_any_ref_mode(object, origin, map_mode)
+    if origin.nil?
+      raise ConfigBugOrBrokenError.new("origin not supposed to be nil", nil)
+    end
+    if object.nil?
+      if origin != @default_value_origin
+        return Hocon::Impl::ConfigNull.new(origin)
+      else
+        return @default_null_value
+      end
+    elsif object.is_a?(TrueClass) || object.is_a?(FalseClass)
+      if origin != @default_value_origin
+        return Hocon::Impl::ConfigBoolean.new(origin, object)
+      elsif object
+        return @default_true_value
+      else
+        return @default_false_value
+      end
+    elsif object.is_a?(String)
+      return Hocon::Impl::ConfigString.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
+      # or a Double has no fractional part. i.e. deliberately
+      # 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)
+      elsif object.is_a?(Integer)
+        return Hocon::Impl::ConfigInt.new(origin, object, nil)
+      else
+        return Hocon::Impl::ConfigNumber.new_number(origin, Float(object), nil)
+      end
+    elsif object.is_a?(Hash)
+      if object.empty?
+        return self.empty_object(origin)
+      end
+
+      if map_mode == FromMapMode::KEYS_ARE_KEYS
+        values = Hash.new
+        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)
+          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)
+      end
+    elsif object.is_a?(Enumerable)
+      if object.count == 0
+        return self.empty_list(origin)
+      end
+
+      values = Array.new
+      object.each do |item|
+        v = from_any_ref_mode(item, origin, map_mode)
+        values.push(v)
+      end
+
+      return Hocon::Impl::SimpleConfigList.new(origin, values)
+    else
+      raise ConfigBugOrBrokenError.new("bug in method caller: not valid to create ConfigValue from: #{object}", nil)
+    end
+  end
 end

data/lib/hocon/impl/config_impl_util.rb

@@ -75,4 +75,12 @@ class Hocon::Impl::ConfigImplUtil
     # file).
     c =~ /[[:space:]]/
   end
+
+  def self.unicode_trim(s)
+    # this implementation is *not* a port of the java code. Ruby can strip
+    # unicode whitespace much easier than Java can, and relies on a lot of
+    # Java functions that don't really have straight equivalents in Ruby.
+    s.gsub(/[[:space]]/, ' ')
+    s.strip
+  end
 end

data/lib/hocon/impl/config_null.rb

@@ -0,0 +1,25 @@
+require 'hocon/impl'
+require 'hocon/config_value_type'
+
+class Hocon::Impl::ConfigNull < Hocon::Impl::AbstractConfigValue
+  def value_type
+    Hocon::Impl::ConfigValueType::NULL
+  end
+
+  def unwrapped
+    nil
+  end
+
+  def transform_to_string
+    "null"
+  end
+
+  def render(sb, indent, atRoot, options)
+    sb.append("null")
+  end
+
+  def newCopy(origin)
+    ConfigNull.new(origin)
+  end
+
+end

data/lib/hocon/impl/default_transformer.rb

@@ -0,0 +1,97 @@
+require 'hocon/impl'
+require 'hocon/config_value_type'
+
+class Hocon::Impl::DefaultTransformer
+
+  ConfigValueType = Hocon::ConfigValueType
+
+  def self.transform(value, requested)
+    if value.value == ConfigValueType::STRING
+      s = value.unwrapped
+      case requested
+        when NUMBER
+          begin
+            v = Integer(s)
+            return ConfigInt.new(value.origin, v, s)
+          rescue ArgumentError
+            # try Float
+          end
+          begin
+            v = Float(s)
+            return ConfigFloat.new(value.origin, v, s)
+          rescue ArgumentError
+            # oh well.
+          end
+        when NULL
+          if s == "null"
+            return ConfigNull.new(value.origin)
+          end
+        when BOOLEAN
+          if s == "true" || s == "yes" || s == "on"
+            return ConfigBoolean.new(value.origin, true)
+          elsif s == "false" || s == "no" || s == "off"
+            return ConfigBoolean.new(value.origin, false)
+          end
+        when LIST
+          # can't go STRING to LIST automatically
+        when OBJECT
+          # can't go STRING to OBJECT automatically
+        when STRING
+          # no-op STRING to STRING
+      end
+    elsif requested == ConfigValueType::STRING
+      # if we converted null to string here, then you wouldn't properly
+      # get a missing-value error if you tried to get a null value
+      # as a string.
+      case value.value_type
+        # NUMBER case removed since you can't fallthrough in a ruby case statement
+        when BOOLEAN
+          return ConfigString.new(value.origin, value.transform_to_string)
+        when NULL
+          # want to be sure this throws instead of returning "null" as a
+          # string
+        when OBJECT
+          # no OBJECT to STRING automatically
+        when LIST
+          # no LIST to STRING automatically
+        when STRING
+          # no-op STRING to STRING
+      end
+    elsif requested == ConfigValueType::LIST && value.value_type == ConfigValueType::OBJECT
+      # attempt to convert an array-like (numeric indices) object to a
+      # list. This would be used with .properties syntax for example:
+      # -Dfoo.0=bar -Dfoo.1=baz
+      # To ensure we still throw type errors for objects treated
+      # as lists in most cases, we'll refuse to convert if the object
+      # does not contain any numeric keys. This means we don't allow
+      # empty objects here though :-/
+      o = value
+      values = Hash.new
+      values
+      o.keys.each do |key|
+        begin
+          i = Integer(key, 10)
+          if i < 0
+            next
+          end
+          values[key] = i
+        rescue ArgumentError
+          next
+        end
+      end
+      if not values.empty?
+        entry_list = values.to_a
+        # sort by numeric index
+        entry_list.sort! {|a,b| b[0] <=> a[0]}
+        # drop the indices (we allow gaps in the indices, for better or
+        # worse)
+        list = Array.new
+        entry_list.each do |entry|
+          list.push(entry[1])
+        end
+        return SimpleConfigList.new(value.origin, list)
+      end
+    end
+    value
+  end
+end

data/lib/hocon/impl/from_map_mode.rb

@@ -0,0 +1,16 @@
+require 'hocon/impl'
+require 'hocon/config_error'
+
+module Hocon::Impl::FromMapMode
+  KEYS_ARE_PATHS = 0
+  KEYS_ARE_KEYS = 1
+  ConfigBugOrBrokenError = Hocon::ConfigError::ConfigBugOrBrokenError
+
+  def self.name(from_map_mode)
+    case from_map_mode
+      when KEYS_ARE_PATHS then "KEYS_ARE_PATHS"
+      when KEYS_ARE_KEYS then "KEYS_ARE_KEYS"
+      else raise ConfigBugOrBrokenError.new("Unrecognized FromMapMode #{from_map_mode}", nil)
+    end
+  end
+end

data/lib/hocon/impl/parser.rb

@@ -9,6 +9,9 @@ require 'hocon/impl/config_concatenation'
 require 'hocon/config_error'
 require 'hocon/impl/simple_config_list'
 require 'hocon/impl/simple_config_object'
+require 'hocon/impl/config_impl_util'
+require 'hocon/impl/tokenizer'
+require 'hocon/impl/simple_config_origin'
 
 class Hocon::Impl::Parser
   
@@ -19,6 +22,10 @@ class Hocon::Impl::Parser
   ConfigParseError = Hocon::ConfigError::ConfigParseError
   SimpleConfigObject = Hocon::Impl::SimpleConfigObject
   SimpleConfigList = Hocon::Impl::SimpleConfigList
+  SimpleConfigOrigin = Hocon::Impl::SimpleConfigOrigin
+  ConfigImplUtil = Hocon::Impl::ConfigImplUtil
+  PathBuilder = Hocon::Impl::PathBuilder
+  Tokenizer = Hocon::Impl::Tokenizer
   
   class TokenWithComments
     def initialize(token, comments = [])
@@ -49,6 +56,17 @@ class Hocon::Impl::Parser
       end
     end
 
+    def add(after)
+      if @comments.empty?
+        TokenWithComments.new(@token, [after])
+      else
+        merged = Array.new
+        merged += @comments
+        merged.push(after)
+        TokenWithComments.new(@token, merged)
+      end
+    end
+
     def prepend_comments(origin)
       if @comments.empty?
         origin
@@ -115,97 +133,6 @@ class Hocon::Impl::Parser
           (Tokens.unquoted_text(token) == "include")
     end
 
-    def self.add_path_text(buf, was_quoted, new_text)
-      i = if was_quoted
-            -1
-          else
-            new_text.index('.') || -1
-          end
-      current = buf.last
-      if i < 0
-        # add to current path element
-        current.sb << new_text
-        # any empty quoted string means this element can
-        # now be empty.
-        if was_quoted && (current.sb.length == 0)
-          current.can_be_empty = true
-        end
-      else
-        # "buf" plus up to the period is an element
-        current.sb << new_text[0, i]
-        # then start a new element
-        buf.push(Element.new("", false))
-        # recurse to consume remainder of new_text
-        add_path_text(buf, false, new_text[i + 1, new_text.length - 1])
-      end
-    end
-
-    def self.parse_path_expression(expression, origin, original_text = nil)
-      buf = []
-      buf.push(Element.new("", false))
-
-      if expression.empty?
-        raise ConfigBadPathError.new(
-            origin,
-            original_text,
-            "Expecting a field name or path here, but got nothing")
-      end
-
-      expression.each do |t|
-        if Tokens.value_with_type?(t, ConfigValueType::STRING)
-          v = Tokens.value(t)
-          # this is a quoted string; so any periods
-          # in here don't count as path separators
-          s = v.transform_to_string
-          add_path_text(buf, true, s)
-        elsif t == Tokens::EOF
-          # ignore this; when parsing a file, it should not happen
-          # since we're parsing a token list rather than the main
-          # token iterator, and when parsing a path expression from the
-          # API, it's expected to have an EOF.
-        else
-          # any periods outside of a quoted string count as
-          # separators
-          text = nil
-          if Tokens.value?(t)
-            # appending a number here may add
-            # a period, but we _do_ count those as path
-            # separators, because we basically want
-            # "foo 3.0bar" to parse as a string even
-            # though there's a number in it. The fact that
-            # we tokenize non-string values is largely an
-            # implementation detail.
-            v = Tokens.value(t)
-            text = v.transform_to_string
-          elsif Tokens.unquoted_text?(t)
-            text = Tokens.unquoted_text(t)
-          else
-            raise ConfigBadPathError.new(
-                origin,
-                original_text,
-                "Token not allowed in path expression: #{t}" +
-                    " (you can double-quote this token if you really want it here)")
-          end
-
-          add_path_text(buf, false, text)
-        end
-      end
-
-      pb = Hocon::Impl::PathBuilder.new
-      buf.each do |e|
-        if (e.sb.length == 0) && !e.can_be_empty?
-          raise ConfigBadPathError.new(
-              origin,
-              original_text,
-              "path has a leading, trailing, or two adjacent period '.' (use quoted \"\" empty string if you want an empty element)")
-        else
-          pb.append_key(e.sb.string)
-        end
-      end
-
-      pb.result
-    end
-
     def initialize(flavor, origin, tokens, includer, include_context)
       @line_number = 1
       @flavor = flavor
@@ -410,7 +337,7 @@ class Hocon::Impl::Parser
         end
 
         put_back(t)
-        self.class.parse_path_expression(expression, line_origin)
+        Hocon::Impl::Parser.parse_path_expression(expression, line_origin)
       end
     end
     
@@ -872,6 +799,172 @@ class Hocon::Impl::Parser
 
   end
 
+  class Element
+    def initialize(initial, can_be_empty)
+      @can_be_empty = can_be_empty
+      @sb = StringIO.new(initial)
+    end
+
+    def to_string
+      "Element(#{@sb.string},#{@can_be_empty})"
+    end
+
+    def sb
+      @sb
+    end
+  end
+
+  def self.has_unsafe_chars(s)
+    for i in 0...s.length
+      c = s[i]
+      if (c =~ /[[:alpha:]]/) || c == '.'
+        next
+      else
+        return true
+      end
+    end
+    false
+  end
+
+  def self.append_path_string(pb, s)
+    split_at = s.index('.')
+    if split_at.nil?
+      pb.append_key(s)
+    else
+      pb.append_key(s[0...split_at])
+      append_path_string(pb, s[(split_at + 1)...s.length])
+    end
+  end
+
+  def self.speculative_fast_parse_path(path)
+    s = ConfigImplUtil.unicode_trim(path)
+    if s.empty?
+      return nil
+    end
+    if has_unsafe_chars(s)
+      return nil
+    end
+    if s.start_with?(".") || s.end_with?(".") || s.include?("..")
+      return nil
+    end
+
+    pb = PathBuilder.new
+    append_path_string(pb, s)
+    pb.result
+  end
+
+  def self.api_origin
+    SimpleConfigOrigin.new_simple("path parameter")
+  end
+
+  def self.parse_path(path)
+    speculated = speculative_fast_parse_path(path)
+    if not speculated.nil?
+      return speculated
+    end
+
+    reader = StringIO.new(path)
+
+    begin
+      tokens = Tokenizer.tokenize(api_origin, reader, ConfigSyntax::CONF)
+      tokens.next # drop START
+      return parse_path_expression(tokens, api_origin, path)
+    ensure
+      reader.close
+    end
+  end
+
+  def self.add_path_text(buf, was_quoted, new_text)
+    i = if was_quoted
+          -1
+        else
+          new_text.index('.') || -1
+        end
+    current = buf.last
+    if i < 0
+      # add to current path element
+      current.sb << new_text
+      # any empty quoted string means this element can
+      # now be empty.
+      if was_quoted && (current.sb.length == 0)
+        current.can_be_empty = true
+      end
+    else
+      # "buf" plus up to the period is an element
+      current.sb << new_text[0, i]
+      # then start a new element
+      buf.push(Element.new("", false))
+      # recurse to consume remainder of new_text
+      add_path_text(buf, false, new_text[i + 1, new_text.length - 1])
+    end
+  end
+
+  def self.parse_path_expression(expression, origin, original_text = nil)
+    buf = []
+    buf.push(Element.new("", false))
+
+    if expression.empty?
+      raise ConfigBadPathError.new(
+                origin,
+                original_text,
+                "Expecting a field name or path here, but got nothing")
+    end
+
+    expression.each do |t|
+      if Tokens.value_with_type?(t, ConfigValueType::STRING)
+        v = Tokens.value(t)
+        # this is a quoted string; so any periods
+        # in here don't count as path separators
+        s = v.transform_to_string
+        add_path_text(buf, true, s)
+      elsif t == Tokens::EOF
+        # ignore this; when parsing a file, it should not happen
+        # since we're parsing a token list rather than the main
+        # token iterator, and when parsing a path expression from the
+        # API, it's expected to have an EOF.
+      else
+        # any periods outside of a quoted string count as
+        # separators
+        text = nil
+        if Tokens.value?(t)
+          # appending a number here may add
+          # a period, but we _do_ count those as path
+          # separators, because we basically want
+          # "foo 3.0bar" to parse as a string even
+          # though there's a number in it. The fact that
+          # we tokenize non-string values is largely an
+          # implementation detail.
+          v = Tokens.value(t)
+          text = v.transform_to_string
+        elsif Tokens.unquoted_text?(t)
+          text = Tokens.unquoted_text(t)
+        else
+          raise ConfigBadPathError.new(
+                    origin,
+                    original_text,
+                    "Token not allowed in path expression: #{t}" +
+                        " (you can double-quote this token if you really want it here)")
+        end
+
+        add_path_text(buf, false, text)
+      end
+    end
+
+    pb = Hocon::Impl::PathBuilder.new
+    buf.each do |e|
+      if (e.sb.length == 0) && !e.can_be_empty?
+        raise ConfigBadPathError.new(
+                  origin,
+                  original_text,
+                  "path has a leading, trailing, or two adjacent period '.' (use quoted \"\" empty string if you want an empty element)")
+      else
+        pb.append_key(e.sb.string)
+      end
+    end
+
+    pb.result
+  end
+
   def self.parse(tokens, origin, options, include_context)
     context = Hocon::Impl::Parser::ParseContext.new(
         options.syntax, origin, tokens,