hocon 0.0.7 → 0.1.0

data/lib/hocon/impl/simple_config_origin.rb

@@ -1,24 +1,200 @@
+# encoding: utf-8
+
 require 'uri'
 require 'hocon/impl'
+require 'hocon/impl/url'
 require 'hocon/impl/origin_type'
+require 'hocon/config_error'
 
 class Hocon::Impl::SimpleConfigOrigin
 
-  MERGE_OF_PREFIX = "merge of "
+  OriginType = Hocon::Impl::OriginType
+
+  def initialize(description, line_number, end_line_number,
+                 origin_type, url_or_nil, resource_or_nil, comments_or_nil)
+    if !description
+      raise ArgumentError, "description may not be nil"
+    end
+
+    # HACK: naming this variable with an underscore, because the upstream library
+    # has both a member var and a no-arg method by the name "description", and
+    # I don't think Ruby can handle that.
+    @_description = description
+    @line_number = line_number
+    @end_line_number = end_line_number
+    @origin_type = origin_type
+    @url_or_nil = url_or_nil
+    @resource_or_nil = resource_or_nil
+    @comments_or_nil = comments_or_nil
+  end
+
+  attr_reader :_description, :line_number, :end_line_number, :origin_type,
+              :url_or_nil, :resource_or_nil, :comments_or_nil
+
+
+  def self.new_simple(description)
+    self.new(description, -1, -1,
+             OriginType::GENERIC,
+             nil, nil, nil)
+  end
 
   def self.new_file(file_path)
     url = URI.join('file:///', file_path)
     self.new(file_path, -1, -1,
-             Hocon::Impl::OriginType::FILE,
-             url, nil)
+             OriginType::FILE,
+             url, nil, nil)
   end
 
-  def self.new_simple(description)
-    self.new(description, -1, -1,
-             Hocon::Impl::OriginType::GENERIC,
-             nil, nil)
+  # NOTE: not porting `new_url` because we're not going to support URLs for now
+
+  def self.new_resource(resource, url = nil)
+    desc = nil
+    if ! url.nil?
+      desc = resource + " @ " + url.to_external_form
+    else
+      desc = resource
+    end
+    Hocon::Impl::SimpleConfigOrigin.new(desc, -1, -1, OriginType::RESOURCE,
+                           url.nil? ? nil : url.to_external_form,
+                           resource, nil)
   end
 
+  def with_line_number(line_number)
+    if (line_number == @line_number) and
+        (line_number == @end_line_number)
+      self
+    else
+      Hocon::Impl::SimpleConfigOrigin.new(
+          @_description, line_number, line_number,
+          @origin_type, @url_or_nil, @resource_or_nil, @comments_or_nil)
+    end
+  end
+
+  def add_url(url)
+    SimpleConfigOrigin.new(@_description, line_number, end_line_number, origin_type,
+                           url.nil? ? nil : url.to_s, resource_or_nil,
+                           comments_or_nil)
+  end
+
+  def with_comments(comments)
+    if Hocon::Impl::ConfigImplUtil.equals_handling_nil?(comments, @comments_or_nil)
+      self
+    else
+      Hocon::Impl::SimpleConfigOrigin.new(
+          @_description, @line_number, @end_line_number,
+          @origin_type, @url_or_nil, @resource_or_nil, comments)
+    end
+  end
+
+  def prepend_comments(comments)
+    if Hocon::Impl::ConfigImplUtil.equals_handling_nil?(comments, @comments_or_nil)
+      self
+    elsif @comments_or_nil.nil?
+      with_comments(comments)
+    else
+      merged = comments + @comments_or_nil
+      with_comments(merged)
+    end
+  end
+
+  def append_comments(comments)
+    if Hocon::Impl::ConfigImplUtil.equals_handling_nil?(comments, @comments_or_nil)
+      self
+    elsif comments_or_nil.nil?
+      with_comments(comments)
+    else
+      merged = comments_or_nil + comments
+      with_comments(merged)
+    end
+  end
+
+  def description
+    if @line_number < 0
+      _description
+    elsif end_line_number == line_number
+      "#{_description}: #{line_number}"
+    else
+      "#{_description}: #{line_number}-#{end_line_number}"
+    end
+  end
+
+  def ==(other)
+    if other.is_a? Hocon::Impl::SimpleConfigOrigin
+      @_description == other._description &&
+          @line_number == other.line_number &&
+          @end_line_number == other.end_line_number &&
+          @origin_type == other.origin_type &&
+          Hocon::Impl::ConfigImplUtil.equals_handling_nil?(@url_or_nil, other.url_or_nil) &&
+          Hocon::Impl::ConfigImplUtil.equals_handling_nil?(@resource_or_nil, other.resource_or_nil)
+    else
+      false
+    end
+  end
+
+  def hash
+    h = 41 * (41 + @_description.hash)
+    h = 41 * (h + @line_number)
+    h = 41 * (h + @end_line_number)
+    h = 41 * (h + @origin_type.hash)
+
+    unless @url_or_nil.nil?
+      h = 41 * (h + @url_or_nil.hash)
+    end
+
+    unless @resource_or_nil.nil?
+      h = 41 * (h + @resource_or_nil.hash)
+    end
+
+    h
+  end
+
+  def to_s
+    "ConfigOrigin(#{_description})"
+  end
+
+  def filename
+    if origin_type == OriginType::FILE
+      _description
+    elsif ! url_or_nil.nil?
+      url = nil
+      begin
+        url = Hocon::Impl::Url.new(url_or_nil)
+      rescue Hocon::Impl::Url::MalformedUrlError => e
+        return nil
+      end
+
+      if url.get_protocol == "file"
+        url.get_file
+      else
+        nil
+      end
+    else
+      nil
+    end
+  end
+
+  def url
+    if url_or_nil.nil?
+      nil
+    else
+      begin
+        Hocon::Impl::Url.new(url_or_nil)
+      rescue Hocon::Impl::Url::MalformedUrlError => e
+        nil
+      end
+    end
+  end
+
+  def resource
+    resource_or_nil
+  end
+
+  def comments
+    @comments_or_nil || []
+  end
+
+  MERGE_OF_PREFIX = "merge of "
+
   def self.remove_merge_of_prefix(desc)
     if desc.start_with?(MERGE_OF_PREFIX)
       desc = desc[MERGE_OF_PREFIX.length, desc.length - 1]
@@ -41,8 +217,8 @@ class Hocon::Impl::SimpleConfigOrigin
 
     # first use the "description" field which has no line numbers
     # cluttering it.
-    a_desc = remove_merge_of_prefix(a.description)
-    b_desc = remove_merge_of_prefix(b.description)
+    a_desc = remove_merge_of_prefix(a._description)
+    b_desc = remove_merge_of_prefix(b._description)
 
     if a_desc == b_desc
       merged_desc = a_desc
@@ -62,8 +238,8 @@ class Hocon::Impl::SimpleConfigOrigin
       #
       # description() method includes line numbers, so use it instead
       # of description field.
-      a_full = remove_merge_of_prefix(a.description)
-      b_full = remove_merge_of_prefix(b.description)
+      a_full = remove_merge_of_prefix(a._description)
+      b_full = remove_merge_of_prefix(b._description)
 
       merged_desc = "#{MERGE_OF_PREFIX}#{a_full},#{b_full}"
       merged_start_line = -1
@@ -77,6 +253,13 @@ class Hocon::Impl::SimpleConfigOrigin
           nil
         end
 
+    merged_resource =
+        if Hocon::Impl::ConfigImplUtil.equals_handling_nil?(a.resource_or_nil, b.resource_or_nil)
+          a.resource_or_nil
+        else
+          nil
+        end
+
     if Hocon::Impl::ConfigImplUtil.equals_handling_nil?(a.comments_or_nil, b.comments_or_nil)
       merged_comments = a.comments_or_nil
     else
@@ -91,84 +274,93 @@ class Hocon::Impl::SimpleConfigOrigin
 
     Hocon::Impl::SimpleConfigOrigin.new(
         merged_desc, merged_start_line, merged_end_line,
-        merged_type, merged_url, merged_comments)
+        merged_type, merged_url, merged_resource, merged_comments)
   end
 
-  def self.merge_origins(stack)
-    if stack.empty?
-      raise ConfigBugError, "can't merge empty list of origins"
-    elsif stack.length == 1
-      stack[0]
-    elsif stack.length == 2
-      merge_two(stack[0], stack[1])
-    else
-      remaining = stack.clone
-      while remaining.length > 2
-        merged = merge_three(remaining[0], remaining[1], remaining[2])
-        remaining.pop
-        remaining.pop
-        remaining.pop
+  def self.similarity(a, b)
+    count = 0
+    if a.origin_type == b.origin_type
+      count += 1
+    end
+
+    if a._description == b._description
+      count += 1
+
+      # only count these if the description field (which is the file
+      # or resource name) also matches.
+      if a.line_number == b.line_number
+        count += 1
       end
 
-      # should be down to either 1 or 2
-      merge_origins(remaining)
-    end
-  end
+      if a.end_line_number == b.end_line_number
+        count += 1
+      end
 
+      if Hocon::Impl::ConfigImplUtil.equals_handling_nil?(a.url_or_nil, b.url_or_nil)
+        count += 1
+      end
 
-  def initialize(description, line_number, end_line_number,
-                  origin_type, url, comments)
-    if !description
-      raise ArgumentError, "description may not be nil"
+      if Hocon::Impl::ConfigImplUtil.equals_handling_nil?(a.resource_or_nil, b.resource_or_nil)
+        count += 1
+      end
     end
 
-    @description = description
-    @line_number = line_number
-    @end_line_number = end_line_number
-    @origin_type = origin_type
-    @url_or_nil = url
-    @comments_or_nil = comments
+    count
   end
 
-  attr_reader :description, :line_number, :end_line_number, :origin_type,
-              :url_or_nil, :comments_or_nil
-
-  def set_line_number(line_number)
-    if (line_number == @line_number) and
-        (line_number == @end_line_number)
-      self
+  def self.merge_three(a, b, c)
+    if similarity(a, b) >= similarity(b, c)
+      merge_two(merge_two(a, b), c)
     else
-      Hocon::Impl::SimpleConfigOrigin.new(
-          @description, line_number, line_number,
-          @origin_type, @url_or_nil, @comments_or_nil)
+      merge_two(a, merge_two(b, c))
     end
   end
 
-  def set_comments(comments)
-    if Hocon::Impl::ConfigImplUtil.equals_handling_nil?(comments, @comments_or_nil)
-      self
-    else
-      Hocon::Impl::SimpleConfigOrigin.new(
-          @description, @line_number, @end_line_number,
-          @origin_type, @url_or_nil, comments)
-    end
+  def self.merge_two_origins(a, b)
+    # a, b are ConfigOrigins
+    merge_two(a, b)
   end
 
-  def prepend_comments(comments)
-    if Hocon::Impl::ConfigImplUtil.equals_handling_nil?(comments, @comments_or_nil)
-      self
-    elsif @comments_or_nil.nil?
-      set_comments(comments)
+  def self.merge_value_origins(stack)
+    # stack is an array of AbstractConfigValue
+    origins = stack.map { |v| v.origin}
+    merge_origins(origins)
+  end
+
+  # see also 'merge_two_origins' and 'merge_three_origins'
+  def self.merge_origins(stack)
+    # stack is an array of ConfigOrigin
+    if stack.empty?
+      raise Hocon::ConfigError::ConfigBugOrBrokenError, "can't merge empty list of origins"
+    elsif stack.length == 1
+      stack[0]
+    elsif stack.length == 2
+      merge_two(stack[0], stack[1])
     else
-      merged = []
-      merged.concat(comments)
-      merged.concat(@comments_or_nil)
-      set_comments(merged)
+      remaining = []
+      stack.each do |o|
+        remaining << o
+      end
+      while remaining.size > 2
+        c = remaining.last
+        remaining.delete_at(remaining.size - 1)
+        b = remaining.last
+        remaining.delete_at(remaining.size - 1)
+        a = remaining.last
+        remaining.delete_at(remaining.size - 1)
+
+        merged = merge_three(a, b, c)
+
+        remaining << merged
+      end
+
+      # should be down to either 1 or 2
+      self.merge_origins(remaining)
     end
   end
 
-  def comments
-    @comments_or_nil || []
-  end
+  # NOTE: skipping 'toFields', 'toFieldsDelta', 'fieldsDelta', 'fromFields',
+  # 'applyFieldsDelta', and 'fromBase' from upstream for now, because they appear
+  # to be about serialization and we probably won't be supporting that.
 
-end
+end

data/lib/hocon/impl/simple_include_context.rb

@@ -1,7 +1,37 @@
+# encoding: utf-8
+
 require 'hocon/impl'
+require 'hocon/impl/simple_includer'
+require 'hocon/config_include_context'
+require 'hocon/impl/config_impl'
 
 class Hocon::Impl::SimpleIncludeContext
+  include Hocon::ConfigIncludeContext
+
   def initialize(parseable)
     @parseable = parseable
   end
-end
+
+  def with_parseable(parseable)
+    if parseable.equal?(@parseable)
+      self
+    else
+      self.class.new(parseable)
+    end
+  end
+
+  def relative_to(filename)
+    if Hocon::Impl::ConfigImpl.trace_loads_enabled
+      Hocon::Impl::ConfigImpl.trace("Looking for '#{filename}' relative to #{@parseable}")
+    end
+    if ! @parseable.nil?
+      @parseable.relative_to(filename)
+    else
+      nil
+    end
+  end
+
+  def parse_options
+    Hocon::Impl::SimpleIncluder.clear_for_include(@parseable.options)
+  end
+end

data/lib/hocon/impl/simple_includer.rb

@@ -1,7 +1,202 @@
+# encoding: utf-8
+
+require 'stringio'
 require 'hocon/impl'
 require 'hocon/impl/full_includer'
+require 'hocon/impl/url'
+require 'hocon/impl/config_impl'
+require 'hocon/config_error'
+require 'hocon/config_syntax'
+require 'hocon/impl/simple_config_object'
+require 'hocon/impl/simple_config_origin'
+require 'hocon/config_includer_file'
+require 'hocon/config_factory'
+require 'hocon/impl/parseable'
 
 class Hocon::Impl::SimpleIncluder < Hocon::Impl::FullIncluder
+
+  ConfigBugorBrokenError = Hocon::ConfigError::ConfigBugOrBrokenError
+  ConfigIOError = Hocon::ConfigError::ConfigIOError
+  SimpleConfigObject = Hocon::Impl::SimpleConfigObject
+  SimpleConfigOrigin = Hocon::Impl::SimpleConfigOrigin
+
+
+  def initialize(fallback)
+    @fallback = fallback
+  end
+
+  # ConfigIncludeContext does this for us on its options
+  def self.clear_for_include(options)
+    # the class loader and includer are inherited, but not this other stuff
+    options.set_syntax(nil).set_origin_description(nil).set_allow_missing(true)
+  end
+
+
+  # this is the heuristic includer
+  def include(context, name)
+    obj = self.class.include_without_fallback(context, name)
+
+    # now use the fallback includer if any and merge its result
+    if ! (@fallback.nil?)
+      obj.with_fallback(@fallback.include(context, name))
+    else
+      obj
+    end
+  end
+
+  # the heuristic includer in static form
+  def self.include_without_fallback(context, name)
+    # the heuristic is valid URL then URL, else relative to including file;
+    # relativeTo in a file falls back to classpath inside relativeTo().
+
+    url = nil
+    begin
+      url = Hocon::Impl::Url.new(name)
+    rescue Hocon::Impl::Url::MalformedUrlError => e
+      url = nil
+    end
+
+    if !(url.nil?)
+      include_url_without_fallback(context, url)
+    else
+      source = RelativeNameSource.new(context)
+      from_basename(source, name, context.parse_options)
+    end
+  end
+
+  # NOTE: not porting `include_url` or `include_url_without_fallback` from upstream,
+  #  because we probably won't support URL includes for now.
+
+  def include_file(context, file)
+    obj = self.class.include_file_without_fallback(context, file)
+
+    # now use the fallback includer if any and merge its result
+    if (!@fallback.nil?) && @fallback.is_a?(Hocon::ConfigIncluderFile)
+      obj.with_fallback(@fallback).include_file(context, file)
+    else
+      obj
+    end
+  end
+
+  def self.include_file_without_fallback(context, file)
+    Hocon::ConfigFactory.parse_file_any_syntax(file, context.parse_options).root
+  end
+
+  # NOTE: not porting `include_resources` or `include_resources_without_fallback`
+  # for now because we're not going to support looking for things on the ruby
+  # load path for now.
+
+  def with_fallback(fallback)
+    if self.equal?(fallback)
+      raise ConfigBugOrBrokenError, "trying to create includer cycle"
+    elsif @fallback.equal?(fallback)
+      self
+    elsif @fallback.nil?
+      self.class.new(@fallback.with_fallback(fallback))
+    else
+      self.class.new(fallback)
+    end
+  end
+
+
+  class NameSource
+    def name_to_parseable(name, parse_options)
+      raise Hocon::ConfigError::ConfigBugOrBrokenError,
+            "name_to_parseable must be implemented by subclass (#{self.class})"
+    end
+  end
+
+  class RelativeNameSource < NameSource
+    def initialize(context)
+      @context = context
+    end
+
+    def name_to_parseable(name, options)
+      p = @context.relative_to(name)
+      if p.nil?
+        # avoid returning nil
+        Hocon::Impl::Parseable.new_not_found(name, "include was not found: '#{name}'", options)
+      else
+        p
+      end
+    end
+  end
+
+  # this function is a little tricky because there are three places we're
+  # trying to use it; for 'include "basename"' in a .conf file, for
+  # loading app.{conf,json,properties} from classpath, and for
+  # loading app.{conf,json,properties} from the filesystem.
+  def self.from_basename(source, name, options)
+    obj = nil
+    if name.end_with?(".conf") || name.end_with?(".json") || name.end_with?(".properties")
+      p = source.name_to_parseable(name, options)
+
+      obj = p.parse(p.options.set_allow_missing(options.allow_missing?))
+    else
+      conf_handle = source.name_to_parseable(name + ".conf", options)
+      json_handle = source.name_to_parseable(name + ".json", options)
+      got_something = false
+      fails = []
+
+      syntax = options.syntax
+
+      obj = SimpleConfigObject.empty(SimpleConfigOrigin.new_simple(name))
+      if syntax.nil? || (syntax == Hocon::ConfigSyntax::CONF)
+        begin
+          obj = conf_handle.parse(conf_handle.options.set_allow_missing(false).
+                  set_syntax(Hocon::ConfigSyntax::CONF))
+          got_something = true
+        rescue ConfigIOError => e
+          fails << e
+        end
+      end
+
+      if syntax.nil? || (syntax == Hocon::ConfigSyntax::JSON)
+        begin
+          parsed = json_handle.parse(json_handle.options.set_allow_missing(false).
+                                         set_syntax(Hocon::ConfigSyntax::JSON))
+          obj = obj.with_fallback(parsed)
+          got_something = true
+        rescue ConfigIOError => e
+          fails << e
+        end
+      end
+
+      # NOTE: skipping the upstream block here that would attempt to parse
+      # a java properties file.
+
+      if (! options.allow_missing?) && (! got_something)
+        if Hocon::Impl::ConfigImpl.trace_loads_enabled
+          # the individual exceptions should have been logged already
+          # with tracing enabled
+          Hocon::Impl::ConfigImpl.trace("Did not find '#{name}'" +
+            " with any extension (.conf, .json, .properties); " +
+            "exceptions should have been logged above.")
+        end
+
+        if fails.empty?
+          # this should not happen
+          raise ConfigBugOrBrokenError, "should not be reached: nothing found but no exceptions thrown"
+        else
+          sb = StringIO.new
+          fails.each do |t|
+            sb << t
+            sb << ", "
+          end
+          raise ConfigIOError.new(SimpleConfigOrigin.new_simple(name), sb.string, fails[0])
+        end
+      elsif !got_something
+        if Hocon::Impl::ConfigImpl.trace_loads_enabled
+          Hocon::Impl::ConfigImpl.trace("Did not find '#{name}'" +
+            " with any extension (.conf, .json, .properties); but '#{name}'" +
+            " is allowed to be missing. Exceptions from load attempts should have been logged above.")
+        end
+      end
+    end
+
+    obj
+  end
+
   class Proxy < Hocon::Impl::FullIncluder
     def initialize(delegate)
       @delegate = delegate
@@ -16,4 +211,4 @@ class Hocon::Impl::SimpleIncluder < Hocon::Impl::FullIncluder
       Proxy.new(includer)
     end
   end
-end
+end