hocon 0.0.7 → 0.1.0

data/lib/hocon/impl/path.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 require 'hocon/impl/path_builder'
 require 'hocon/config_error'
@@ -8,37 +10,85 @@ class Hocon::Impl::Path
   ConfigBugOrBrokenError = Hocon::ConfigError::ConfigBugOrBrokenError
   ConfigImplUtil = Hocon::Impl::ConfigImplUtil
 
-  # 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
+  def initialize(first, remainder)
+    # first: String, remainder: Path
 
-    # 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
+    @first = first
+    @remainder = remainder
+  end
+  attr_reader :first, :remainder
+
+  def self.from_string_list(elements)
+    # This method was translated from the Path constructor in the
+    # Java hocon library that has this signature:
+    #   Path(String... elements)
+    #
+    # It figures out what @first and @remainder should be, then
+    # pass those to the ruby constructor
+    if elements.length == 0
+      raise Hocon::ConfigError::ConfigBugOrBrokenError.new("empty path")
     end
 
-    s.chars.each do |c|
-      unless (c =~ /[[:alnum:]]/) || (c == '-') || (c == '_')
-        return true
+    new_first = elements.first
+
+    if elements.length > 1
+      pb = Hocon::Impl::PathBuilder.new
+
+      # Skip first element
+      elements.drop(1).each do |element|
+        pb.append_key(element)
       end
+
+      new_remainder = pb.result
+    else
+      new_remainder = nil
     end
 
-    false
+    self.new(new_first, new_remainder)
   end
 
-  def initialize(first, remainder)
-    @first = first
-    @remainder = remainder
+  def self.from_path_list(path_list)
+    # This method was translated from the Path constructors in the
+    # Java hocon library that take in a list of Paths
+    #
+    # It just passes an iterator to self.from_path_iterator, which
+    # will return a new Path object
+    from_path_iterator(path_list.each)
+  end
+
+  def self.from_path_iterator(path_iterator)
+    # This method was translated from the Path constructors in the
+    # Java hocon library that takes in an iterator of Paths
+    #
+    # It figures out what @first and @remainder should be, then
+    # pass those to the ruby constructor
+
+    # Try to get first path from iterator
+    # Ruby iterators have no .hasNext() method like java
+    # So we try to catch the StopIteration exception
+    begin
+      first_path = path_iterator.next
+    rescue StopIteration
+      raise Hocon::ConfigError::ConfigBugOrBrokenError("empty path")
+    end
+
+    new_first = first_path.first
+
+    pb = Hocon::Impl::PathBuilder.new
+
+    unless first_path.remainder.nil?
+      pb.append_path(first_path.remainder)
+    end
+
+    # Skip first path
+    path_iterator.drop(1).each do |path|
+      pb.append_path(path)
+    end
+
+    new_remainder = pb.result
+
+    self.new(new_first, new_remainder)
   end
-  attr_reader :first, :remainder
 
   def first
     @first
@@ -64,45 +114,50 @@ class Hocon::Impl::Path
 
   def last
     p = self
-    while not p.remainder.nil?
+    while p.remainder != nil
       p = p.remainder
     end
     p.first
   end
 
+  def prepend(to_prepend)
+    pb = Hocon::Impl::PathBuilder.new
+
+    pb.append_path(to_prepend)
+    pb.append_path(self)
+
+    pb.result
+  end
+
   def length
     count = 1
     p = remainder
-    while not p.nil? do
+    while p != nil do
       count += 1
       p = p.remainder
     end
-    return count
-  end
-
-  #
-  # 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
+    count
   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
+  def sub_path(first_index, last_index)
+    if last_index < first_index
+      raise ConfigBugOrBrokenError.new("bad call to sub_path")
     end
-
-    unless @remainder.nil?
-      sb << "."
-      @remainder.append_to_string_builder(sb)
+    from = sub_path_to_end(first_index)
+    pb = Hocon::Impl::PathBuilder.new
+    count = last_index - first_index
+    while count > 0 do
+      count -= 1
+      pb.append_key(from.first)
+      from = from.remainder
+      if from.nil?
+        raise ConfigBugOrBrokenError.new("sub_path last_index out of range #{last_index}")
+      end
     end
+    pb.result
   end
 
+  # translated from `subPath(int removeFromFront)` upstream
   def sub_path_to_end(remove_from_front)
     count = remove_from_front
     p = self
@@ -113,22 +168,88 @@ class Hocon::Impl::Path
     p
   end
 
-  def sub_path(first_index, last_index)
-    if last_index < first_index
-      raise ConfigBugOrBrokenError.new("bad call to sub_path", nil)
+  def starts_with(other)
+    my_remainder = self
+    other_remainder = other
+    if other_remainder.length <= my_remainder.length
+      while ! other_remainder.nil?
+        if ! (other_remainder.first == my_remainder.first)
+          return false
+        end
+        my_remainder = my_remainder.remainder
+        other_remainder = other_remainder.remainder
+      end
+      return true
     end
-    from = sub_path_to_end(first_index)
-    pb = Hocon::Impl::PathBuilder.new
-    count = last_index - first_index
-    while count > 0 do
-      count -= 1
-      pb.append_key(from.first)
-      from = from.remainder
-      if from.nil?
-        raise ConfigBugOrBrokenError.new("sub_path last_index out of range #{last_index}", nil)
+    false
+  end
+
+  def ==(other)
+    if other.is_a? Hocon::Impl::Path
+      that = other
+      first == that.first && ConfigImplUtil.equals_handling_nil?(remainder, that.remainder)
+    else
+      false
+    end
+  end
+
+  def hash
+    remainder_hash = remainder.nil? ? 0 : remainder.hash
+
+    41 * (41 + first.hash) + remainder_hash
+  end
+
+  # 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
+
+    s.chars.each do |c|
+      unless (c =~ /[[:alnum:]]/) || (c == '-') || (c == '_')
+        return true
       end
     end
-    pb.result
+
+    false
+  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
+
+  def to_s
+    sb = StringIO.new
+    sb << "Path("
+    append_to_string_builder(sb)
+    sb << ")"
+
+    sb.string
+  end
+
+  def inspect
+    to_s
+  end
+
+  #
+  # 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 self.new_key(key)
@@ -136,6 +257,7 @@ class Hocon::Impl::Path
   end
 
   def self.new_path(path)
-    Hocon::Impl::Parser.parse_path(path)
+    Hocon::Impl::PathParser.parse_path(path)
   end
-end
+
+end

data/lib/hocon/impl/path_builder.rb

@@ -1,5 +1,8 @@
+# encoding: utf-8
+
 require 'hocon/impl'
 require 'hocon/impl/path'
+require 'hocon/config_error'
 
 class Hocon::Impl::PathBuilder
 
@@ -10,7 +13,7 @@ class Hocon::Impl::PathBuilder
 
   def check_can_append
     if @result
-      raise ConfigBugError, "Adding to PathBuilder after getting result"
+      raise Hocon::ConfigError::ConfigBugOrBrokenError, "Adding to PathBuilder after getting result"
     end
   end
 
@@ -19,8 +22,26 @@ class Hocon::Impl::PathBuilder
     @keys.push(key)
   end
 
+  def append_path(path)
+    check_can_append
+
+    first = path.first
+    remainder = path.remainder
+
+    loop do
+      @keys.push(first)
+
+      if !remainder.nil?
+        first = remainder.first
+        remainder = remainder.remainder
+      else
+        break
+      end
+    end
+  end
+
   def result
-    # note: if keys is empty, we want to return null, which is a valid
+    # note: if keys is empty, we want to return nil, which is a valid
     # empty path
     if @result.nil?
       remainder = nil
@@ -32,4 +53,4 @@ class Hocon::Impl::PathBuilder
     end
     @result
   end
-end
+end

data/lib/hocon/impl/path_parser.rb

@@ -0,0 +1,280 @@
+# encoding: utf-8
+
+require 'stringio'
+require 'hocon/impl'
+require 'hocon/config_syntax'
+require 'hocon/impl/tokenizer'
+require 'hocon/impl/config_node_path'
+require 'hocon/impl/tokens'
+require 'hocon/config_value_type'
+require 'hocon/config_error'
+
+class Hocon::Impl::PathParser
+  ConfigSyntax = Hocon::ConfigSyntax
+  SimpleConfigOrigin = Hocon::Impl::SimpleConfigOrigin
+  Tokenizer = Hocon::Impl::Tokenizer
+  Tokens = Hocon::Impl::Tokens
+  ConfigNodePath = Hocon::Impl::ConfigNodePath
+  ConfigValueType = Hocon::ConfigValueType
+  ConfigBadPathError = Hocon::ConfigError::ConfigBadPathError
+
+
+
+  class Element
+    def initialize(initial, can_be_empty)
+      @can_be_empty = can_be_empty
+      @sb = StringIO.new(initial)
+    end
+
+    attr_accessor :can_be_empty, :sb
+
+    def to_string
+      "Element(#{@sb.string},#{@can_be_empty})"
+    end
+  end
+
+  def self.api_origin
+    SimpleConfigOrigin.new_simple("path parameter")
+  end
+
+  def self.parse_path_node(path, flavor = ConfigSyntax::CONF)
+    reader = StringIO.new(path)
+
+    begin
+      tokens = Tokenizer.tokenize(api_origin, reader,
+                                  flavor)
+      tokens.next # drop START
+      parse_path_node_expression(tokens, api_origin, path, flavor)
+    ensure
+      reader.close
+    end
+  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.parse_path_node_expression(expression, origin, original_text = nil,
+                                      flavor = ConfigSyntax::CONF)
+    path_tokens = []
+    path = parse_path_expression(expression, origin, original_text, path_tokens, flavor)
+    ConfigNodePath.new(path, path_tokens);
+  end
+
+  def self.parse_path_expression(expression, origin, original_text = nil,
+                                  path_tokens = nil, flavor = ConfigSyntax::CONF)
+    # each builder in "buf" is an element in the path
+    buf = []
+    buf.push(Element.new("", false))
+
+    if !expression.has_next?
+      raise ConfigBadPathError.new(
+                origin,
+                original_text,
+                "Expecting a field name or path here, but got nothing")
+    end
+
+    while expression.has_next?
+      t = expression.next
+
+      if ! path_tokens.nil?
+        path_tokens << t
+      end
+
+      # Ignore all IgnoredWhitespace tokens
+      next if Tokens.ignored_whitespace?(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)
+
+          # We need to split the tokens on a . so that we can get sub-paths but still preserve
+          # the original path text when doing an insertion
+          if ! path_tokens.nil?
+            path_tokens.delete_at(path_tokens.size - 1)
+            path_tokens.concat(split_token_on_period(t, flavor))
+          end
+          text = v.transform_to_string
+        elsif Tokens.unquoted_text?(t)
+          # We need to split the tokens on a . so that we can get sub-paths but still preserve
+          # the original path text when doing an insertion on ConfigNodeObjects
+          if ! path_tokens.nil?
+            path_tokens.delete_at(path_tokens.size - 1)
+            path_tokens.concat(split_token_on_period(t, flavor))
+          end
+          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 Hocon::ConfigError::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.split_token_on_period(t, flavor)
+    token_text = t.token_text
+    if token_text == "."
+      return [t]
+    end
+    split_token = token_text.split('.')
+    split_tokens = []
+    split_token.each do |s|
+      if flavor == ConfigSyntax::CONF
+        split_tokens << Tokens.new_unquoted_text(t.origin, s)
+      else
+        split_tokens << Tokens.new_string(t.origin, s, "\"#{s}\"")
+      end
+      split_tokens << Tokens.new_unquoted_text(t.origin, ".")
+    end
+    if token_text[-1] != "."
+      split_tokens.delete_at(split_tokens.size - 1)
+    end
+    split_tokens
+  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
+
+  # the idea is to see if the string has any chars or features
+  # that might require the full parser to deal with.
+  def self.looks_unsafe_for_fast_parser(s)
+    last_was_dot = true # // start of path is also a "dot"
+    len = s.length
+    if s.empty?
+      return true
+    end
+    if s[0] == "."
+      return true
+    end
+    if s[len - 1] == "."
+      return true
+    end
+
+    (0..len).each do |i|
+      c = s[i]
+      if c =~ /^\w$/
+        last_was_dot = false
+        next
+      elsif c == '.'
+        if last_was_dot
+          return true # ".." means we need to throw an error
+        end
+        last_was_dot = true
+      elsif c == '-'
+        if last_was_dot
+          return true
+        end
+        next
+      else
+        return true
+      end
+    end
+
+    if last_was_dot
+      return true
+    end
+
+    false
+  end
+
+  def self.fast_path_build(tail, s, path_end)
+    # rindex takes last index it should look at, end - 1 not end
+    split_at = s.rindex(".", path_end - 1)
+    tokens = []
+    tokens << Tokens.new_unquoted_text(nil, s)
+    # this works even if split_at is -1; then we start the substring at 0
+    with_one_more_element = Path.new(s[split_at + 1..path_end], tail)
+    if split_at < 0
+      with_one_more_element
+    else
+      fast_path_build(with_one_more_element, s, split_at)
+    end
+  end
+
+  # do something much faster than the full parser if
+  # we just have something like "foo" or "foo.bar"
+  def self.speculative_fast_parse_path(path)
+    s = Hocon::Impl::ConfigImplUtil.unicode_trim(path)
+    if looks_unsafe_for_fast_parser(s)
+      return nil
+    end
+
+    fast_path_build(nil, s, s.length)
+  end
+
+end