hocon 0.0.4 → 0.0.5

data/lib/hocon/impl/path.rb

@@ -1,7 +1,12 @@
 require 'hocon/impl'
+require 'hocon/impl/path_builder'
+require 'hocon/config_error'
 require 'stringio'
 
 class Hocon::Impl::Path
+
+  ConfigBugOrBrokenError = Hocon::ConfigError::ConfigBugOrBrokenError
+
   # 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)
@@ -34,6 +39,46 @@ class Hocon::Impl::Path
   end
   attr_reader :first, :remainder
 
+  def first
+    @first
+  end
+
+  def remainder
+    @remainder
+  end
+
+  def parent
+    if remainder.nil?
+      return nil
+    end
+
+    pb = Hocon::Impl::PathBuilder.new
+    p = self
+    while not p.remainder.nil?
+      pb.append_key(p.first)
+      p = p.remainder
+    end
+    pb.result
+  end
+
+  def last
+    p = self
+    while not p.remainder.nil?
+      p = p.remainder
+    end
+    p.first
+  end
+
+  def length
+    count = 1
+    p = remainder
+    while not 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.
@@ -56,4 +101,36 @@ class Hocon::Impl::Path
       @remainder.append_to_string_builder(sb)
     end
   end
+
+  def sub_path_to_end(remove_from_front)
+    count = remove_from_front
+    p = self
+    while (not p.nil?) && count > 0 do
+      count -= 1
+      p = p.remainder
+    end
+    p
+  end
+
+  def sub_path(first_index, last_index)
+    if last_index < first_index
+      raise ConfigBugOrBrokenError.new("bad call to sub_path", nil)
+    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)
+      end
+    end
+    pb.result
+  end
+
+  def self.new_path(path)
+    Hocon::Impl::Parser.parse_path(path)
+  end
 end

data/lib/hocon/impl/path_builder.rb

@@ -2,7 +2,6 @@ require 'hocon/impl'
 require 'hocon/impl/path'
 
 class Hocon::Impl::PathBuilder
-  Path = Hocon::Impl::Path
 
   def initialize
     @keys = []
@@ -27,7 +26,7 @@ class Hocon::Impl::PathBuilder
       remainder = nil
       while !@keys.empty?
         key = @keys.pop
-        remainder = Path.new(key, remainder)
+        remainder = Hocon::Impl::Path.new(key, remainder)
       end
       @result = remainder
     end

data/lib/hocon/impl/properties_parser.rb

@@ -0,0 +1,83 @@
+require 'hocon/impl'
+require 'hocon/config_error'
+require 'hocon/impl/config_impl'
+
+class Hocon::Impl::PropertiesParser
+  def from_path_map(origin, path_map, converted_from_properties)
+    # First, build a list of paths that will have values, either string or
+    # object values.
+    scope_paths = Set.new
+    value_paths = Set.new
+    path_map.each_key do |path|
+      value_paths.add(path)
+
+      next_path = path.parent
+      while not next_path.nil? do
+        scope_paths.add(next_path)
+        next_path = next_path.parent
+      end
+    end
+
+    if converted_from_properties
+      # If any string values are also objects containing other values,
+      # drop those string values - objects "win".
+      value_paths = value_paths - scope_paths
+    else
+      # If we didn't start out as properties, then this is an error.
+      value_paths.each do |path|
+        if scope_paths.include?(path)
+          raise ConfigBugOrBrokenError.new("In the map, path '#{path.render}' occurs as both" +
+                                           " the parent object of a value and as a value. Because Map " +
+                                           "has no defined ordering, this is a broken situation.", nil)
+        end
+      end
+    end
+
+    # Create maps for the object-valued values.
+    root = Hash.new
+    scopes = Hash.new
+
+    value_paths.each do |path|
+      parent_path = path.parent
+      parent = (not parent_path.nil?) ? scopes[parent_path] : root
+
+      last = path.last
+      raw_value = path_map.get(path)
+      if converted_from_properties
+        if raw_value.is_a?(String)
+          value = Hocon::Impl::ConfigString.new(origin, raw_value)
+        else
+          value = nil
+        end
+      else
+        value = Hocon::Impl::ConfigImpl.from_any_ref_impl(path_map[path], origin, Hocon::Impl::FromMapMode::KEYS_ARE_PATHS)
+      end
+      if not value.nil?
+        parent[last, value]
+      end
+    end
+
+    # Make a list of scope paths from longest to shortest, so children go
+    # before parents.
+    sorted_scope_paths = Array.new
+    sorted_scope_paths = sorted_scope_paths + scope_paths
+    sorted_scope_paths.sort! do |a,b|
+      b.length <=> a.length
+    end
+
+    # Create ConfigObject for each scope map, working from children to
+    # parents to avoid modifying any already-created ConfigObject. This is
+    # where we need the sorted list.
+    sorted_scope_paths.each do |scope_path|
+      scope = scopes[scope_path]
+
+      parent_path = scope_path.parent
+      parent = (not parent_path.nil?) ? scopes[parent_path] : root
+
+      o = Hocon::Impl::SimpleConfigObject.new(origin, scope, Hocon::Impl::ResolveStatus::RESOLVED, false)
+      parent[scope_path.last, o]
+    end
+
+    Hocon::Impl::SimpleConfigObject.new(origin, root, Hocon::Impl::ResolveStatus::RESOLVED, false)
+  end
+end

data/lib/hocon/impl/simple_config.rb

@@ -1,6 +1,19 @@
 require 'hocon/impl'
+require 'hocon/config_value_type'
+require 'hocon/impl/path'
+require 'hocon/impl/default_transformer'
+require 'hocon/impl/config_impl'
 
 class Hocon::Impl::SimpleConfig
+
+  ConfigMissingError = Hocon::ConfigError::ConfigMissingError
+  ConfigNotResolvedError = Hocon::ConfigError::ConfigNotResolvedError
+  ConfigNullError = Hocon::ConfigError::ConfigNullError
+  ConfigWrongTypeError = Hocon::ConfigError::ConfigWrongTypeError
+  ConfigValueType = Hocon::ConfigValueType
+  Path = Hocon::Impl::Path
+  DefaultTransformer = Hocon::Impl::DefaultTransformer
+
   def initialize(object)
     @object = object
   end
@@ -8,4 +21,67 @@ class Hocon::Impl::SimpleConfig
   def root
     @object
   end
+
+  def find_key(me, key, expected, original_path)
+    v = me.peek_assuming_resolved(key, original_path)
+    if v.nil?
+      raise ConfigMissingError.new(nil, "No configuration setting found for key '#{original_path.render}'", nil)
+    end
+
+    if not expected.nil?
+      v = DefaultTransformer.transform(v, expected)
+    end
+
+    if v.value_type == ConfigValueType::NULL
+      raise ConfigNullError.new(v.origin,
+                                (ConfigNullError.make_message(original_path.render,
+                                                              (not expected.nil?) ? expected.name : nil)),
+                                nil)
+    elsif (not expected.nil?) && v.value_type != expected
+      raise ConfigWrongTypeError.new(v.origin,
+                                     "#{original_path.render} has type #{v.value_type.name} " +
+                                         "rather than #{expected.name}",
+                                     nil)
+    else
+      return v
+    end
+  end
+
+  def find(me, path, expected, original_path)
+    key = path.first
+    rest = path.remainder
+    if rest.nil?
+      find_key(me, key, expected, original_path)
+    else
+      o = find_key(me, key, ConfigValueType::OBJECT,
+                   original_path.sub_path(0, original_path.length - rest.length))
+      raise "Error: object o is nil" unless not o.nil?
+      find(o, rest, expected, original_path)
+    end
+  end
+
+  def get_value(path)
+    parsed_path = Path.new_path(path)
+    find(@object, parsed_path, nil, parsed_path)
+  end
+
+  def has_path(path_expression)
+    path = Path.new_path(path_expression)
+    begin
+      peeked = @object.peek_path(path)
+    rescue ConfigNotResolvedError => e
+      raise Hocon::Impl::ConfigImpl.improve_not_resolved(path, e)
+    end
+    (not peeked.nil?) && peeked.value_type != ConfigValueType::NULL
+  end
+
+  def without_path(path_expression)
+    path = Path.new_path(path_expression)
+    self.class.new(root.without_path(path))
+  end
+
+  def with_value(path_expression, v)
+    path = Path.new_path(path_expression)
+    self.class.new(root.with_value(path, v))
+  end
 end

data/lib/hocon/impl/simple_config_list.rb

@@ -1,6 +1,7 @@
 require 'hocon/impl'
 require 'hocon/impl/resolve_status'
 require 'hocon/config_value_type'
+require 'hocon/impl/abstract_config_object'
 
 class Hocon::Impl::SimpleConfigList < Hocon::Impl::AbstractConfigValue
   ResolveStatus = Hocon::Impl::ResolveStatus

data/lib/hocon/impl/simple_config_object.rb

@@ -2,9 +2,15 @@ require 'hocon/impl'
 require 'hocon/impl/simple_config_origin'
 require 'hocon/impl/abstract_config_object'
 require 'hocon/impl/resolve_status'
+require 'hocon/config_error'
 require 'set'
 
 class Hocon::Impl::SimpleConfigObject < Hocon::Impl::AbstractConfigObject
+
+  ConfigBugOrBrokenError = Hocon::ConfigError::ConfigBugOrBrokenError
+  ResolveStatus = Hocon::Impl::ResolveStatus
+  SimpleConfigOrigin = Hocon::Impl::SimpleConfigOrigin
+
   def self.empty_missing(base_origin)
     self.new(
         Hocon::Impl::SimpleConfigOrigin.new_simple("#{base_origin.description} (not found)"),
@@ -175,4 +181,65 @@ class Hocon::Impl::SimpleConfigObject < Hocon::Impl::AbstractConfigObject
     @value.empty?
   end
 
+  def attempt_peek_with_partial_resolve(key)
+    @value[key]
+  end
+
+  def without_path(path)
+    key = path.first
+    remainder = path.remainder
+    v = @value[key]
+
+    if (not v.nil?) && (not remainder.nil?) && v.is_a?(Hocon::Impl::AbstractConfigObject)
+      v = v.without_path(remainder)
+      updated = @value.clone
+      updated[key] = v
+      return Hocon::Impl::SimpleConfigObject.new(origin, updated,
+                                                 ResolveStatus.from_values(updated.values), @ignores_fallbacks)
+    elsif (not remainder.nil?) || v.nil?
+      return self
+    else
+      smaller = Hash.new
+      @value.each do |old_key, old_value|
+        if not old_key == key
+          smaller[old_key] = old_value
+        end
+      end
+      return Hocon::Impl::SimpleConfigObject.new(origin, smaller,
+                                                 ResolveStatus.from_values(smaller.values), @ignores_fallbacks)
+    end
+  end
+
+  def with_value(path, v)
+    key = path.first
+    remainder = path.remainder
+
+    if remainder.nil?
+      return with_value_impl(key, v)
+    else
+      child = @value[key]
+      if (not child.nil?) && child.is_a?(Hocon::Impl::AbstractConfigObject)
+        return with_value_impl(key, child.with_value(remainder, v))
+      else
+        subtree = v.at_path(
+            SimpleConfigOrigin.new_simple("with_value(#{remainder.render})"), remainder)
+        with_value_impl(key, subtree.root)
+      end
+    end
+  end
+
+  def with_value_impl(key, v)
+    if v.nil?
+      raise ConfigBugOrBrokenError.new("Trying to store null ConfigValue in a ConfigObject", nil)
+    end
+
+    new_map = Hash.new
+    if @value.empty?
+      new_map[key] = v
+    else
+      new_map = @value.clone
+      new_map[key] = v
+    end
+    self.class.new(origin, new_map, ResolveStatus.from_values(new_map.values), @ignores_fallbacks)
+  end
 end

data/lib/hocon/impl/tokenizer.rb

@@ -2,6 +2,7 @@ require 'hocon/impl'
 require 'hocon/impl/config_impl_util'
 require 'hocon/impl/tokens'
 require 'stringio'
+require 'forwardable'
 
 class Hocon::Impl::Tokenizer
   Tokens = Hocon::Impl::Tokens
@@ -10,6 +11,7 @@ class Hocon::Impl::Tokenizer
   end
 
   class TokenIterator
+    extend Forwardable
     class WhitespaceSaver
       def initialize
         @whitespace = StringIO.new
@@ -79,6 +81,8 @@ class Hocon::Impl::Tokenizer
       (c != "\n") and (Hocon::Impl::ConfigImplUtil.whitespace?(c))
     end
 
+    def_delegator :@tokens, :each
+
     def initialize(origin, input, allow_comments)
       @origin = origin
       @input = input
@@ -361,6 +365,10 @@ class Hocon::Impl::Tokenizer
       end
       t
     end
+
+    def empty?
+      @tokens.empty?
+    end
   end
 
 

data/lib/hocon/impl/tokens.rb

@@ -3,6 +3,7 @@ require 'hocon/impl/token'
 require 'hocon/impl/token_type'
 require 'hocon/impl/config_number'
 require 'hocon/impl/config_string'
+require 'hocon/impl/config_boolean'
 
 # FIXME the way the subclasses of Token are private with static isFoo and accessors is kind of ridiculous.
 class Hocon::Impl::Tokens
@@ -10,6 +11,7 @@ class Hocon::Impl::Tokens
   TokenType = Hocon::Impl::TokenType
   ConfigNumber = Hocon::Impl::ConfigNumber
   ConfigString = Hocon::Impl::ConfigString
+  ConfigBoolean = Hocon::Impl::ConfigBoolean
 
   START = Token.new_without_origin(TokenType::START, "start of file")
   EOF = Token.new_without_origin(TokenType::EOF, "end of file")
@@ -103,6 +105,10 @@ class Hocon::Impl::Tokens
     new_value(ConfigNumber.new_number(origin, value, original_text))
   end
 
+  def self.new_boolean(origin, value)
+    new_value(ConfigBoolean.new(origin, value))
+  end
+
   def self.comment?(t)
     t.is_a?(Comment)
   end
@@ -154,4 +160,4 @@ class Hocon::Impl::Tokens
   def self.problem?(t)
     t.is_a?(Problem)
   end
-end
+end

metadata

@@ -1,63 +1,102 @@
 --- !ruby/object:Gem::Specification
 name: hocon
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
+  prerelease: 
 platform: ruby
 authors:
 - Chris Price
 - Wayne Warren
+- Dai Akatsuka
+- Preben Ingvaldsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-23 00:00:00.000000000 Z
+date: 2014-10-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.14'
-description: "== A port of the Java {Typesafe Config}[https://github.com/typesafehub/config]
-  library to Ruby"
+description: == A port of the Java {Typesafe Config}[https://github.com/typesafehub/config]
+  library to Ruby
 email: chris@puppetlabs.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE
-- README.md
-- lib/hocon.rb
 - lib/hocon/config_error.rb
 - lib/hocon/config_factory.rb
 - lib/hocon/config_object.rb
 - lib/hocon/config_parse_options.rb
 - lib/hocon/config_render_options.rb
 - lib/hocon/config_syntax.rb
+- lib/hocon/config_value_factory.rb
 - lib/hocon/config_value_type.rb
-- lib/hocon/impl.rb
 - lib/hocon/impl/abstract_config_object.rb
 - lib/hocon/impl/abstract_config_value.rb
+- lib/hocon/impl/config_boolean.rb
 - lib/hocon/impl/config_concatenation.rb
 - lib/hocon/impl/config_float.rb
 - lib/hocon/impl/config_impl.rb
 - lib/hocon/impl/config_impl_util.rb
 - lib/hocon/impl/config_int.rb
+- lib/hocon/impl/config_null.rb
 - lib/hocon/impl/config_number.rb
 - lib/hocon/impl/config_string.rb
+- lib/hocon/impl/default_transformer.rb
+- lib/hocon/impl/from_map_mode.rb
 - lib/hocon/impl/full_includer.rb
 - lib/hocon/impl/origin_type.rb
 - lib/hocon/impl/parseable.rb
 - lib/hocon/impl/parser.rb
 - lib/hocon/impl/path.rb
 - lib/hocon/impl/path_builder.rb
+- lib/hocon/impl/properties_parser.rb
 - lib/hocon/impl/resolve_status.rb
 - lib/hocon/impl/simple_config.rb
 - lib/hocon/impl/simple_config_list.rb
@@ -70,28 +109,33 @@ files:
 - lib/hocon/impl/tokenizer.rb
 - lib/hocon/impl/tokens.rb
 - lib/hocon/impl/unmergeable.rb
+- lib/hocon/impl.rb
+- lib/hocon.rb
+- LICENSE
+- README.md
 homepage: https://github.com/cprice404/ruby-hocon
 licenses:
 - Apache License, v2
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 1.8.23.2
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: HOCON Config Library
 test_files: []