typesafe_config 0.0.1

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

@@ -0,0 +1,136 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,78 @@
+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

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

@@ -0,0 +1,31 @@
+require 'typesafe/config/impl'
+require 'typesafe/config/impl/config_number'
+require 'typesafe/config/config_value_type'
+
+class Typesafe::Config::Impl::ConfigInt < Typesafe::Config::Impl::ConfigNumber
+  def initialize(origin, value, original_text)
+    super(origin, original_text)
+    @value = value
+  end
+
+  def value_type
+    Typesafe::Config::ConfigValueType::NUMBER
+  end
+
+  def unwrapped
+    @value
+  end
+
+  def transform_to_string
+    s = super
+    if s.nil?
+      self.to_s
+    else
+      s
+    end
+  end
+
+  def new_copy(origin)
+    Typesafe::Config::Impl::ConfigInt.new(origin, @value, @original_text)
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'typesafe/config/impl'
+require 'typesafe/config/impl/abstract_config_value'
+
+class Typesafe::Config::Impl::ConfigNumber < Typesafe::Config::Impl::AbstractConfigValue
+  ## sigh... requiring these subclasses before this class
+  ## is declared would cause an error.  Thanks, ruby.
+  require 'typesafe/config/impl/config_int'
+  require 'typesafe/config/impl/config_float'
+
+  def self.new_number(origin, number, original_text)
+    as_int = number.to_i
+    if as_int == number
+      Typesafe::Config::Impl::ConfigInt.new(origin, as_int, original_text)
+    else
+      Typesafe::Config::Impl::ConfigFloat.new(origin, number, original_text)
+    end
+  end
+
+  def initialize(origin, original_text)
+    super(origin)
+    @original_text = original_text
+  end
+
+  def transform_to_string
+    @original_text
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'typesafe/config/impl'
+require 'typesafe/config/impl/abstract_config_value'
+require 'typesafe/config/config_value_type'
+require 'typesafe/config/impl/config_impl_util'
+
+class Typesafe::Config::Impl::ConfigString < Typesafe::Config::Impl::AbstractConfigValue
+  ConfigImplUtil = Typesafe::Config::Impl::ConfigImplUtil
+
+  def initialize(origin, value)
+    super(origin)
+    @value = value
+  end
+
+  def value_type
+    Typesafe::Config::ConfigValueType::STRING
+  end
+
+  def unwrapped
+    @value
+  end
+
+  def transform_to_string
+    @value
+  end
+
+  def render_value_to_sb(sb, indent_size, at_root, options)
+    if options.json?
+      sb << ConfigImplUtil.render_json_string(@value)
+    else
+      sb << ConfigImplUtil.render_string_unquoted_if_possible(@value)
+    end
+  end
+
+  def new_copy(origin)
+    Typesafe::Config::Impl::ConfigString.new(origin, @value)
+  end
+end

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

@@ -0,0 +1,4 @@
+require 'typesafe/config/impl'
+
+class Typesafe::Config::Impl::FullIncluder
+end

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

@@ -0,0 +1,9 @@
+require 'typesafe/config/impl'
+
+module Typesafe::Config::Impl::OriginType
+  ## for now, we only support a subset of these
+  GENERIC = 0
+  FILE = 1
+  #URL = 2
+  #RESOURCE = 3
+end

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

@@ -0,0 +1,151 @@
+require 'typesafe/config/impl'
+require 'typesafe/config/config_syntax'
+require 'typesafe/config/impl/config_impl'
+require 'typesafe/config/impl/simple_include_context'
+require 'typesafe/config/impl/simple_config_object'
+require 'typesafe/config/impl/simple_config_origin'
+require 'typesafe/config/impl/tokenizer'
+require 'typesafe/config/impl/parser'
+
+class Typesafe::Config::Impl::Parseable
+  class ParseableFile < Typesafe::Config::Impl::Parseable
+    def initialize(file_path, options)
+      @input = file_path
+      post_construct(options)
+    end
+
+    def guess_syntax
+      Typesafe::Config::Impl::Parseable.syntax_from_extension(File.basename(@input))
+    end
+
+    def create_origin
+      Typesafe::Config::Impl::SimpleConfigOrigin.new_file(@input)
+    end
+
+    def reader
+      self
+    end
+
+    def open
+      if block_given?
+        File.open(@input) do |f|
+          yield f
+        end
+      else
+        File.open(@input)
+      end
+    end
+  end
+
+  def self.new_file(file_path, options)
+    ParseableFile.new(file_path, options)
+  end
+
+  def options
+    @initial_options
+  end
+
+  def include_context
+    @include_context
+  end
+
+  def self.force_parsed_to_object(value)
+    if value.is_a? Typesafe::Config::Impl::AbstractConfigObject
+      value
+    else
+      raise ConfigWrongTypeError.new(value.origin, "", "object at file root",
+                                     value.value_type.name)
+    end
+  end
+
+  def parse
+    self.class.force_parsed_to_object(parse_value(options))
+  end
+
+  def parse_value(base_options)
+    # note that we are NOT using our "initialOptions",
+    # but using the ones from the passed-in options. The idea is that
+    # callers can get our original options and then parse with different
+    # ones if they want.
+    options = fixup_options(base_options)
+
+    # passed-in options can override origin
+    origin =
+        if options.origin_description
+          Typesafe::Config::Impl::SimpleConfigOrigin.new_simple(options.origin_description)
+        else
+          @initial_origin
+        end
+    parse_value_from_origin(origin, options)
+  end
+
+
+  private
+
+  def self.syntax_from_extension(filename)
+    case File.extname(filename)
+      when ".json"
+        Typesafe::Config::ConfigSyntax::JSON
+      when ".conf"
+        Typesafe::Config::ConfigSyntax::CONF
+      when ".properties"
+        Typesafe::Config::ConfigSyntax::PROPERTIES
+      else
+        nil
+    end
+  end
+
+  def post_construct(base_options)
+    @initial_options = fixup_options(base_options)
+    @include_context = Typesafe::Config::Impl::SimpleIncludeContext.new(self)
+    if @initial_options.origin_description
+      @initial_origin = SimpleConfigOrigin.new_simple(@initial_options.origin_description)
+    else
+      @initial_origin = create_origin
+    end
+  end
+
+  def fixup_options(base_options)
+    syntax = base_options.syntax
+    if !syntax
+      syntax = guess_syntax
+    end
+    if !syntax
+      syntax = Typesafe::Config::ConfigSyntax.CONF
+    end
+
+    modified = base_options.with_syntax(syntax)
+    modified = modified.append_includer(Typesafe::Config::Impl::ConfigImpl.default_includer)
+    modified = modified.with_includer(Typesafe::Config::Impl::SimpleIncluder.make_full(modified.includer))
+
+    modified
+  end
+
+  def parse_value_from_origin(origin, final_options)
+    begin
+      raw_parse_value(origin, final_options)
+    rescue IOError => e
+      if final_options.allow_missing?
+        Typesafe::Config::Impl::SimpleConfigObject.empty_missing(origin)
+      else
+        raise ConfigIOError.new(origin, "#{e.class.name}: #{e.message}", e)
+      end
+    end
+  end
+
+  # this is parseValue without post-processing the IOException or handling
+  # options.getAllowMissing()
+  def raw_parse_value(origin, final_options)
+    ## TODO: if we were going to support loading from URLs, this
+    ##  method would need to deal with the content-type.
+
+    reader.open { |io|
+      raw_parse_value_from_io(io, origin, final_options)
+    }
+  end
+
+  def raw_parse_value_from_io(io, origin, final_options)
+    tokens = Typesafe::Config::Impl::Tokenizer.tokenize(origin, io, final_options.syntax)
+    Typesafe::Config::Impl::Parser.parse(tokens, origin, final_options, include_context)
+  end
+end