typesafe_config 0.0.3 → 0.0.4

data/README.md

@@ -1,2 +1,17 @@
 ruby-typesafe-config
 ==========
+
+This is a port of the [Typesafe Config](https://github.com/typesafehub/config) library to Ruby.
+
+At present, the only features it supports are explicit parsing of config files (.conf/HOCON, .json, .properties) via `ConfigFactory.parse_file`, and rendering a parsed config object back to a String.  Testing is minimal and not all data types are supported yet.  It also does not yet support `include` or interpolated settings.
+
+The implementation is intended to be as close to a line-for-line port as the two languages allow, in hopes of making it fairly easy to port over new changesets from the Java code base over time.
+
+Basic Usage
+===========
+
+```rb
+require 'typesafe/config/config_factory'
+
+conf = Typesafe::Config::ConfigFactory.parse_file("myapp.conf")
+conf_map = conf.root.unwrapped

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typesafe_config
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -11,50 +11,13 @@ bindir: bin
 cert_chain: []
 date: 2014-03-14 00:00:00.000000000 Z
 dependencies: []
-description: == A port of the Java {Typesafe Config}[https://github.com/typesafehub/config]
-  library to Ruby
+description: == This gem has been replaced by the {HOCON}[https://rubygems.org/gems/ruby_hocon]
+  gem
 email: chris@puppetlabs.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/typesafe/config.rb
-- lib/typesafe/config/config_object.rb
-- lib/typesafe/config/config_error.rb
-- lib/typesafe/config/impl/simple_includer.rb
-- lib/typesafe/config/impl/config_number.rb
-- lib/typesafe/config/impl/simple_config.rb
-- lib/typesafe/config/impl/config_int.rb
-- lib/typesafe/config/impl/resolve_status.rb
-- lib/typesafe/config/impl/simple_config_origin.rb
-- lib/typesafe/config/impl/token.rb
-- lib/typesafe/config/impl/config_string.rb
-- lib/typesafe/config/impl/config_float.rb
-- lib/typesafe/config/impl/full_includer.rb
-- lib/typesafe/config/impl/parser.rb
-- lib/typesafe/config/impl/tokens.rb
-- lib/typesafe/config/impl/tokenizer.rb
-- lib/typesafe/config/impl/abstract_config_object.rb
-- lib/typesafe/config/impl/simple_include_context.rb
-- lib/typesafe/config/impl/token_type.rb
-- lib/typesafe/config/impl/path_builder.rb
-- lib/typesafe/config/impl/parseable.rb
-- lib/typesafe/config/impl/path.rb
-- lib/typesafe/config/impl/unmergeable.rb
-- lib/typesafe/config/impl/config_impl_util.rb
-- lib/typesafe/config/impl/simple_config_object.rb
-- lib/typesafe/config/impl/simple_config_list.rb
-- lib/typesafe/config/impl/config_impl.rb
-- lib/typesafe/config/impl/config_concatenation.rb
-- lib/typesafe/config/impl/abstract_config_value.rb
-- lib/typesafe/config/impl/origin_type.rb
-- lib/typesafe/config/config_factory.rb
-- lib/typesafe/config/impl.rb
-- lib/typesafe/config/config_parse_options.rb
-- lib/typesafe/config/config_render_options.rb
-- lib/typesafe/config/config_value_type.rb
-- lib/typesafe/config/config_syntax.rb
-- lib/typesafe.rb
 - LICENSE
 - README.md
 homepage: https://github.com/cprice404/ruby-typesafe-config

data/lib/typesafe/config/config_error.rb

@@ -1,12 +0,0 @@
-require 'typesafe/config'
-
-class Typesafe::Config::ConfigError < StandardError
-  def initialize(origin, message, cause)
-    super(message)
-    @origin = origin
-    @cause = cause
-  end
-
-  class ConfigParseError < Typesafe::Config::ConfigError
-  end
-end

data/lib/typesafe/config/config_factory.rb

@@ -1,9 +0,0 @@
-require 'typesafe/config'
-require 'typesafe/config/config_parse_options'
-require 'typesafe/config/impl/parseable'
-
-class Typesafe::Config::ConfigFactory
-  def self.parse_file(file_path, options = Typesafe::Config::ConfigParseOptions.defaults)
-    Typesafe::Config::Impl::Parseable.new_file(file_path, options).parse.to_config
-  end
-end

data/lib/typesafe/config/config_object.rb

@@ -1,4 +0,0 @@
-require 'typesafe/config'
-
-module Typesafe::Config::ConfigObject
-end

data/lib/typesafe/config/config_parse_options.rb

@@ -1,53 +0,0 @@
-require 'typesafe/config'
-
-class Typesafe::Config::ConfigParseOptions
-  attr_accessor :syntax, :origin_description, :allow_missing, :includer
-
-  def self.defaults
-    self.new(nil, nil, true, nil)
-  end
-
-  def initialize(syntax, origin_description, allow_missing, includer)
-    @syntax = syntax
-    @origin_description = origin_description
-    @allow_missing = allow_missing
-    @includer = includer
-  end
-
-  def allow_missing?
-    @allow_missing
-  end
-
-  def with_syntax(syntax)
-    if @syntax == syntax
-      self
-    else
-      Typesafe::Config::ConfigParseOptions.new(syntax,
-                                    @origin_description,
-                                    @allow_missing,
-                                    @includer)
-    end
-  end
-
-  def with_includer(includer)
-    if @includer == includer
-      self
-    else
-      Typesafe::Config::ConfigParseOptions.new(@syntax,
-                                    @origin_description,
-                                    @allow_missing,
-                                    includer)
-    end
-  end
-
-  def append_includer(includer)
-    if @includer == includer
-      self
-    elsif @includer
-      with_includer(@includer.with_fallback(includer))
-    else
-      with_includer(includer)
-    end
-  end
-
-end

data/lib/typesafe/config/config_render_options.rb

@@ -1,46 +0,0 @@
-require 'typesafe/config'
-
-class Typesafe::Config::ConfigRenderOptions
-  def initialize(origin_comments, comments, formatted, json)
-    @origin_comments = origin_comments
-    @comments = comments
-    @formatted = formatted
-    @json = json
-  end
-
-  attr_writer :origin_comments, :comments, :formatted, :json
-
-  def origin_comments?
-    @origin_comments
-  end
-  def comments?
-    @comments
-  end
-  def formatted?
-    @formatted
-  end
-  def json?
-    @json
-  end
-
-  #
-  # Returns the default render options which are verbose (commented and
-  # formatted). See {@link ConfigRenderOptions#concise} for stripped-down
-  # options. This rendering will not be valid JSON since it has comments.
-  #
-  # @return the default render options
-  #
-  def self.defaults
-    Typesafe::Config::ConfigRenderOptions.new(true, true, true, true)
-  end
-
-  #
-  # Returns concise render options (no whitespace or comments). For a
-  # resolved {@link Config}, the concise rendering will be valid JSON.
-  #
-  # @return the concise render options
-  #
-  def self.concise
-    Typesafe::Config::ConfigRenderOptions.new(false, false, false, true)
-  end
-end

data/lib/typesafe/config/config_syntax.rb

@@ -1,7 +0,0 @@
-require 'typesafe/config'
-
-module Typesafe::Config::ConfigSyntax
-  JSON = 0
-  CONF = 1
-  PROPERTIES = 2
-end

data/lib/typesafe/config/config_value_type.rb

@@ -1,26 +0,0 @@
-require 'typesafe/config'
-
-#
-# The type of a configuration value (following the <a
-# href="http://json.org">JSON</a> type schema).
-#
-module Typesafe::Config::ConfigValueType
-  OBJECT = 0
-  LIST = 1
-  NUMBER = 2
-  BOOLEAN = 3
-  NULL = 4
-  STRING = 5
-
-  def self.name(config_value_type)
-    case config_value_type
-      when OBJECT then "OBJECT"
-      when LIST then "LIST"
-      when NUMBER then "NUMBER"
-      when BOOLEAN then "BOOLEAN"
-      when NULL then "NULL"
-      when STRING then "STRING"
-      else raise ConfigBugError, "Unrecognized value type '#{config_value_type}'"
-    end
-  end
-end

data/lib/typesafe/config/impl/abstract_config_object.rb

@@ -1,64 +0,0 @@
-require 'typesafe/config/impl'
-require 'typesafe/config/impl/abstract_config_value'
-require 'typesafe/config/impl/simple_config'
-require 'typesafe/config/config_object'
-require 'typesafe/config/config_value_type'
-require 'typesafe/config/impl/resolve_status'
-require 'typesafe/config/impl/simple_config_origin'
-
-class Typesafe::Config::Impl::AbstractConfigObject < Typesafe::Config::Impl::AbstractConfigValue
-  include Typesafe::Config::ConfigObject
-
-  def initialize(origin)
-    super(origin)
-    @config = Typesafe::Config::Impl::SimpleConfig.new(self)
-  end
-
-  def to_config
-    @config
-  end
-
-  def to_fallback_value
-    self
-  end
-
-  def value_type
-    Typesafe::Config::ConfigValueType::OBJECT
-  end
-
-  def new_copy(origin)
-    new_copy_with_status(resolve_status, origin)
-  end
-
-  def merge_origins(stack)
-    if stack.empty?
-      raise ConfigBugError, "can't merge origins on empty list"
-    end
-    origins = []
-    first_origin = nil
-    num_merged = 0
-    stack.each do |v|
-      if first_origin.nil?
-        first_origin = v.origin
-      end
-
-      if (v.is_a?(Typesafe::Config::Impl::AbstractConfigObject)) &&
-          (v.resolve_status == Typesafe::Config::Impl::ResolveStatus::RESOLVED) &&
-          v.empty?
-        # don't include empty files or the .empty()
-        # config in the description, since they are
-        # likely to be "implementation details"
-      else
-        origins.push(v.origin)
-        num_merged += 1
-      end
-    end
-
-    if num_merged == 0
-      # the configs were all empty, so just use the first one
-      origins.push(first_origin)
-    end
-
-    Typesafe::Config::Impl::SimpleConfigOrigin.merge_origins(origins)
-  end
-end

data/lib/typesafe/config/impl/abstract_config_value.rb

@@ -1,130 +0,0 @@
-require 'typesafe/config/impl'
-require 'stringio'
-require 'typesafe/config/config_render_options'
-require 'typesafe/config/config_object'
-require 'typesafe/config/impl/resolve_status'
-require 'typesafe/config/impl/unmergeable'
-require 'typesafe/config/impl/abstract_config_object'
-require 'typesafe/config/impl/config_impl_util'
-
-##
-## Trying very hard to avoid a parent reference in config values; when you have
-## a tree like this, the availability of parent() tends to result in a lot of
-## improperly-factored and non-modular code. Please don't add parent().
-##
-class Typesafe::Config::Impl::AbstractConfigValue
-  ConfigImplUtil = Typesafe::Config::Impl::ConfigImplUtil
-
-  def initialize(origin)
-    @origin = origin
-  end
-
-  attr_reader :origin
-
-  def resolve_status
-    Typesafe::Config::Impl::ResolveStatus::RESOLVED
-  end
-
-  # this is virtualized rather than a field because only some subclasses
-  # really need to store the boolean, and they may be able to pack it
-  # with another boolean to save space.
-  def ignores_fallbacks?
-    # if we are not resolved, then somewhere in this value there's
-    # a substitution that may need to look at the fallbacks.
-    resolve_status == Typesafe::Config::Impl::ResolveStatus::RESOLVED
-  end
-
-  # the withFallback() implementation is supposed to avoid calling
-  # mergedWith* if we're ignoring fallbacks.
-  def require_not_ignoring_fallbacks
-    if ignores_fallbacks?
-      raise ConfigBugError, "method should not have been called with ignoresFallbacks=true #{self.class.name}"
-    end
-  end
-
-  def with_origin(origin)
-    if @origin == origin
-      self
-    else
-      new_copy(origin)
-    end
-  end
-
-  def with_fallback(mergeable)
-    if ignores_fallbacks?
-      self
-    else
-      other = mergeable.to_fallback_value
-      if other.is_a?(Typesafe::Config::Impl::Unmergeable)
-        merged_with_the_unmergeable(other)
-      elsif other.is_a?(Typesafe::Config::Impl::AbstractConfigObject)
-        merged_with_object(other)
-      else
-        merged_with_non_object(other)
-      end
-    end
-  end
-
-  def to_s
-    sb = StringIO.new
-    render_to_sb(sb, 0, true, nil, Typesafe::Config::ConfigRenderOptions.concise)
-    "#{self.class.name}(#{sb.string})"
-  end
-
-  def indent(sb, indent_size, options)
-    if options.formatted?
-      remaining = indent_size
-      while remaining > 0
-        sb << "    "
-        remaining -= 1
-      end
-    end
-  end
-
-  def render_to_sb(sb, indent, at_root, at_key, options)
-    if !at_key.nil?
-      rendered_key =
-          if options.json?
-            ConfigImplUtil.render_json_string(at_key)
-          else
-            ConfigImplUtil.render_string_unquoted_if_possible(at_key)
-          end
-
-      sb << rendered_key
-
-      if options.json?
-        if options.formatted?
-          sb << " : "
-        else
-          sb << ":"
-        end
-      else
-        # in non-JSON we can omit the colon or equals before an object
-        if self.is_a?(Typesafe::Config::ConfigObject)
-          if options.formatted?
-            sb << ' '
-          end
-        else
-          sb << "="
-        end
-      end
-    end
-    render_value_to_sb(sb, indent, at_root, options)
-  end
-
-  # to be overridden by subclasses
-  def render_value_to_sb(sb, indent, at_root, options)
-    u = unwrapped
-    sb << u.to_s
-  end
-
-  def render(options = Typesafe::Config::ConfigRenderOptions.defaults)
-    sb = StringIO.new
-    render_to_sb(sb, 0, true, nil, options)
-    # We take a substring that ends at sb.pos, because we've been decrementing
-    # sb.pos at various points in the code as a means to remove characters from
-    # the end of the StringIO
-    sb.string[0, sb.pos]
-  end
-
-end

data/lib/typesafe/config/impl/config_concatenation.rb

@@ -1,136 +0,0 @@
-require 'typesafe/config/impl'
-require 'typesafe/config/impl/abstract_config_value'
-require 'typesafe/config/impl/abstract_config_object'
-require 'typesafe/config/impl/simple_config_list'
-require 'typesafe/config/config_object'
-require 'typesafe/config/impl/unmergeable'
-require 'typesafe/config/impl/simple_config_origin'
-require 'typesafe/config/impl/config_string'
-
-class Typesafe::Config::Impl::ConfigConcatenation < Typesafe::Config::Impl::AbstractConfigValue
-  include Typesafe::Config::Impl::Unmergeable
-
-  SimpleConfigList = Typesafe::Config::Impl::SimpleConfigList
-  ConfigObject = Typesafe::Config::ConfigObject
-  Unmergeable = Typesafe::Config::Impl::Unmergeable
-  SimpleConfigOrigin = Typesafe::Config::Impl::SimpleConfigOrigin
-
-  #
-  # Add left and right, or their merger, to builder
-  #
-  def self.join(builder, orig_right)
-    left = builder[builder.size - 1]
-    right = orig_right
-
-    # check for an object which can be converted to a list
-    # (this will be an object with numeric keys, like foo.0, foo.1)
-    if (left.is_a?(ConfigObject)) && (right.is_a?(SimpleConfigList))
-      left = DefaultTransformer.transform(left, ConfigValueType::LIST)
-    elsif (left.is_a?(SimpleConfigList)) && (right.is_a?(ConfigObject))
-      right = DefaultTransformer.transform(right, ConfigValueType::LIST)
-    end
-
-    # Since this depends on the type of two instances, I couldn't think
-    # of much alternative to an instanceof chain. Visitors are sometimes
-    # used for multiple dispatch but seems like overkill.
-    joined = nil
-    if (left.is_a?(ConfigObject)) && (right.is_a?(ConfigObject))
-      joined = right.with_fallback(left)
-    elsif (left.is_a?(SimpleConfigList)) && (right.is_a?(SimpleConfigList))
-      joined = left.concatenate(right)
-    elsif (left.is_a?(Typesafe::Config::Impl::ConfigConcatenation)) ||
-        (right.is_a?(Typesafe::Config::Impl::ConfigConcatenation))
-      raise ConfigBugError, "unflattened ConfigConcatenation"
-    elsif (left.is_a?(Unmergeable)) || (right.is_a?(Unmergeable))
-      # leave joined=null, cannot join
-    else
-      # handle primitive type or primitive type mixed with object or list
-      s1 = left.transform_to_string
-      s2 = right.transform_to_string
-      if s1.nil? || s2.nil?
-        raise ConfigWrongTypeError.new(left.origin,
-                "Cannot concatenate object or list with a non-object-or-list, #{left} " +
-                    "and #{right} are not compatible")
-      else
-        joined_origin = SimpleConfigOrigin.merge_origins([left.origin, right.origin])
-        joined = Typesafe::Config::Impl::ConfigString.new(joined_origin, s1 + s2)
-      end
-    end
-
-    if joined.nil?
-      builder.push(right)
-    else
-      builder.pop
-      builder.push(joined)
-    end
-  end
-
-  def self.consolidate(pieces)
-    if pieces.length < 2
-      pieces
-    else
-      flattened = []
-      pieces.each do |v|
-        if v.is_a?(Typesafe::Config::Impl::ConfigConcatenation)
-          flattened.concat(v.pieces)
-        else
-          flattened.push(v)
-        end
-      end
-
-      consolidated = []
-      flattened.each do |v|
-        if consolidated.empty?
-          consolidated.push(v)
-        else
-          join(consolidated, v)
-        end
-      end
-
-      consolidated
-    end
-  end
-
-  def self.concatenate(pieces)
-    consolidated = consolidate(pieces)
-    if consolidated.empty?
-      nil
-    elsif consolidated.length == 1
-      consolidated[0]
-    else
-      merged_origin = SimpleConfigOrigin.merge_origins(consolidated)
-      Typesafe::Config::Impl::ConfigConcatenation.new(merged_origin, consolidated)
-    end
-  end
-
-
-  def initialize(origin, pieces)
-    super(origin)
-    @pieces = pieces
-
-    if pieces.size < 2
-      raise ConfigBugError, "Created concatenation with less than 2 items: #{self}"
-    end
-
-    had_unmergeable = false
-    pieces.each do |p|
-      if p.is_a?(Typesafe::Config::Impl::ConfigConcatenation)
-        raise ConfigBugError, "ConfigConcatenation should never be nested: #{self}"
-      end
-      if p.is_a?(Unmergeable)
-        had_unmergeable = true
-      end
-    end
-
-    unless had_unmergeable
-      raise ConfigBugError, "Created concatenation without an unmergeable in it: #{self}"
-    end
-  end
-
-  def ignores_fallbacks?
-    # we can never ignore fallbacks because if a child ConfigReference
-    # is self-referential we have to look lower in the merge stack
-    # for its value.
-    false
-  end
-end

data/lib/typesafe/config/impl/config_float.rb

@@ -1,9 +0,0 @@
-require 'typesafe/config/impl'
-require 'typesafe/config/impl/config_number'
-
-class Typesafe::Config::Impl::ConfigFloat < Typesafe::Config::Impl::ConfigNumber
-  def initialize(origin, value, original_text)
-    super(origin, original_text)
-    @value = value
-  end
-end

data/lib/typesafe/config/impl/config_impl.rb

@@ -1,10 +0,0 @@
-require 'typesafe/config/impl'
-require 'typesafe/config/impl/simple_includer'
-
-class Typesafe::Config::Impl::ConfigImpl
-  @default_includer = Typesafe::Config::Impl::SimpleIncluder.new
-
-  def self.default_includer
-    @default_includer
-  end
-end

data/lib/typesafe/config/impl/config_impl_util.rb

@@ -1,78 +0,0 @@
-require 'typesafe/config/impl'
-require 'stringio'
-
-class Typesafe::Config::Impl::ConfigImplUtil
-  def self.equals_handling_nil?(a, b)
-    # This method probably doesn't make any sense in ruby... not sure
-    if a.nil? && !b.nil?
-      false
-    elsif !a.nil? && b.nil?
-      false
-    # in ruby, the == and .equal? are the opposite of what they are in Java
-    elsif a.equal?(b)
-      true
-    else
-      a == b
-    end
-  end
-
-  #
-  # This is public ONLY for use by the "config" package, DO NOT USE this ABI
-  # may change.
-  #
-  def self.render_json_string(s)
-    sb = StringIO.new
-    sb << '"'
-    s.chars.each do |c|
-      case c
-        when '"' then sb << "\\\""
-        when "\\" then sb << "\\\\"
-        when "\n" then sb << "\\n"
-        when "\b" then sb << "\\b"
-        when "\f" then sb << "\\f"
-        when "\r" then sb << "\\r"
-        when "\t" then sb << "\\t"
-        else
-          if c =~ /[[:cntrl:]]/
-            sb << ("\\u%04x" % c)
-          else
-            sb << c
-          end
-      end
-    end
-    sb << '"'
-    sb.string
-  end
-
-  def self.render_string_unquoted_if_possible(s)
-    # this can quote unnecessarily as long as it never fails to quote when
-    # necessary
-    if s.length == 0
-      return render_json_string(s)
-    end
-
-    # if it starts with a hyphen or number, we have to quote
-    # to ensure we end up with a string and not a number
-    first = s.chars.first
-    if (first =~ /[[:digit:]]/) || (first == '-')
-      return render_json_string(s)
-    end
-
-    # only unquote if it's pure alphanumeric
-    s.chars.each do |c|
-      unless (c =~ /[[:alnum:]]/) || (c == '-')
-        return render_json_string(s)
-      end
-    end
-
-    s
-  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
-    # insanely slow (running a regex against every single character in the
-    # file).
-    c =~ /[[:space:]]/
-  end
-end