ruby-properties-file 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 19eeaa7bc5d7261ae5df49f7a40e7391333bde0e
+  data.tar.gz: 3f0552aebef1fbd745bd4c41d5b4615abec4caf0
+SHA512:
+  metadata.gz: 2480fec357b58d648117d547a51f443a5ae7145604da6ad02d1c7b5491204cc051f18c6fc01beed1db0d0c38d6c749b56bddda2ac1154e9432d4712fe8a1c370
+  data.tar.gz: 1176ce2e219c2c8fbc14282738fb4a10d85e9ce4cf0a865dcbc1088eb5f2a5ea08aab1d25cb7ce610c0bdcbb59380d478e6c650a5b648d2dbe58a5a31b8d9e55

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Jonas Thiel
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,110 @@
+# JavaProperties
+
+[![Build Status](http://img.shields.io/travis/jnbt/java-properties.png)](https://travis-ci.org/jnbt/jnbt/java-properties)
+[![Code Climate](http://img.shields.io/codeclimate/github/jnbt/java-properties.png)](https://codeclimate.com/github/jnbt/java-properties)
+[![Coveralls](http://img.shields.io/coveralls/jnbt/java-properties.png)](https://coveralls.io/r/jnbt/java-properties)
+[![RubyGems](http://img.shields.io/gem/v/java-properties.png)](http://rubygems.org/gems/java-properties)
+[![Gemnasium](http://img.shields.io/gemnasium/jnbt/java-properties.png)](https://gemnasium.com/jnbt/java-properties)
+[![Inline docs](http://inch-ci.org/github/jnbt/java-properties.png)](http://inch-ci.org/github/jnbt/java-properties)
+
+A ruby library to read and write [Java properties files](http://en.wikipedia.org/wiki/.properties).
+
+## Installation
+
+Install via Rubygems
+
+```bash
+$ gem install java-properties
+```
+
+... or add to your Gemfile
+
+```ruby
+gem "java-properties"
+```
+
+## Loading files
+
+You can load a valid Java properties file from the file system using a path:
+
+```ruby
+properties = JavaProperties.load("path/to/my.properties")
+properties[:foo] # => "bar"
+```
+
+If have already the content of the properties file at hand than parse the content as:
+
+```ruby
+properties = JavaProperties.load("foo=bar")
+properties[:foo] # => "bar"
+```
+
+## Writing files
+
+You can write any Hash-like structure as a properties file:
+
+```ruby
+hash = {:foo => "bar"}
+JavaProperties.write(hash, "path/to/my.properties")
+```
+
+Or if you want to omit the file you can receive the content directly:
+
+```ruby
+hash = {:foo => "bar"}
+JavaProperties.generate(hash)  # => "foo=bar"
+```
+
+## Encodings and special chars
+
+As Java properties files normally hold UTF-8 chars in their escaped representation this tool tries to convert them:
+
+```
+"ה" <=> "\u05d4"
+```
+
+The tool also escaped every '=', ' ' and ':' in the name part of a property line:
+
+```ruby
+JavaProperties.generate({"i : like=strange" => "bar"}) 
+# => "i\ \:\ like\=strange=bar"
+```
+
+## Multi line and line breaks
+
+In Java properties files a string can be multi line but line breaks have to be escaped. 
+
+Assume the following input:
+
+```ini
+my=This is a multi \
+   line content with only \n one line break
+```
+
+The parses would read:
+
+```ruby
+{:my => "This is a multi line content which only \n one line break"}
+```
+
+In the opposite direction line breaks will be correctly escaped but the generator will never use multi line values.
+
+## Contributing
+
+1. [Fork it!](https://github.com/jnbt/java-properties/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Author
+
+Jonas Thiel (@jonasthiel)
+
+## References
+
+For more information about the properties file format have a look at the [Java Plattform documenation](http://docs.oracle.com/javase/6/docs/api/java/util/Properties.html).
+
+## License
+
+This gem is released under the MIT License. See the LICENSE file for further details.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+desc 'Run tests'
+task :default => :spec
+
+Rake::TestTask.new(:spec) do |test|
+  test.test_files = FileList['spec/**/*_spec.rb']
+  test.libs << 'spec'
+  test.verbose = true
+end

data/java-properties.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'java-properties/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby-properties-file"
+  spec.version       = JavaProperties::VERSION.dup
+  spec.authors       = ["Jonas Thiel", "Joe Mifsud"]
+  spec.email         = ["jonas@thiel.io"]
+  spec.summary       = %q{Loader and writer for *.properties files}
+  spec.description   = %q{Tool for loading and writing Java properties files}
+  spec.homepage      = "https://github.com/jnbt/java-properties"
+  spec.license       = "MIT"
+
+  spec.files = %w(LICENSE README.md Rakefile java-properties.gemspec)
+  spec.files += Dir.glob("lib/**/*.rb")
+  spec.test_files = Dir.glob("spec/**/*.rb")
+  spec.test_files = Dir.glob("spec/fixtures/**/*.properties")
+
+  spec.required_rubygems_version = '>= 1.3.5'
+end

data/lib/java-properties.rb

@@ -0,0 +1,45 @@
+require 'stringio'
+require 'java-properties/version'
+require 'java-properties/properties'
+require 'java-properties/encoding'
+require 'java-properties/parsing'
+require 'java-properties/generating'
+
+# A module to read and write Java properties files
+module JavaProperties
+
+  # Parses the content of a Java properties file
+  # @see Parsing::Parser
+  # @param text [String]
+  # @return [Properties]
+  def self.parse(text)
+    Parsing::Parser.parse(text)
+  end
+
+  # Generates the content of a Java properties file
+  # @see Generating::Generator
+  # @param hash [Hash] 
+  # @param options [Hash] options for the generator
+  # @return [String]
+  def self.generate(hash, options = {})
+    Generating::Generator.generate(hash, options)
+  end
+
+  # Loads and parses a Java properties file
+  # @see Parsing::Parser
+  # @param path [String]
+  # @return [Properties]
+  def self.load(path)
+    parse(File.read(path))
+  end
+
+  # Generates a Java properties file
+  # @see Generating::Generator
+  # @param hash [Hash]
+  # @param path [String]
+  # @param options [Hash] options for the generator
+  def self.write(hash, path, options = {})
+    File.write(path, generate(hash, options))
+  end
+
+end

data/lib/java-properties/encoding.rb

@@ -0,0 +1,56 @@
+require 'java-properties/encoding/special_chars'
+require 'java-properties/encoding/separators'
+require 'java-properties/encoding/unicode'
+
+module JavaProperties
+  # Module to encode and decode
+  #
+  # Usage:
+  #    encoded = Encoding.encode!("Some text to be encoded")
+  #    decoded = Encoding.decode!("Some text to be decoded")
+  #
+  # You can disable separate encoding (and decoding) steps,
+  # by passing in additional flags:
+  #
+  # * SKIP_SEPARATORS: Do not code the separators (space,:,=)
+  # * SKIP_UNICODE: Do not code unicode chars
+  # * SKIP_SPECIAL_CHARS: Do not code newlines, tab stops, ...
+  #
+  module Encoding
+
+    # Flag for skipping separators encodings / decoding
+    # @return [Symbol]
+    SKIP_SEPARATORS=:skip_separators
+
+    # Flag for skipping separators encodings / decoding
+    # @return [Symbol]
+    SKIP_UNICODE=:skip_unicode
+
+    # Flag for skipping separators encodings / decoding
+    # @return [Symbol]
+    SKIP_SPECIAL_CHARS=:skip_special_chars
+
+    # Encode a given text in place
+    # @param text [String]
+    # @param *flags [Array] Optional flags to skip encoding steps
+    # @return [String] The encoded text for chaining
+    def self.encode!(text, *flags)
+      SpecialChars.encode!(text)  unless flags.include?(SKIP_SPECIAL_CHARS)
+      Separators.encode!(text)    unless flags.include?(SKIP_SEPARATORS)
+      Unicode.encode!(text)       unless flags.include?(SKIP_UNICODE)
+      text
+    end
+    
+    # Decodes a given text in place
+    # @param text [String]
+    # @param *flags [Array] Optional flags to skip decoding steps
+    # @return [String] The decoded text for chaining
+    def self.decode!(text, *flags)
+      Unicode.decode!(text)       unless flags.include?(SKIP_UNICODE)
+      Separators.decode!(text)    unless flags.include?(SKIP_SEPARATORS)
+      SpecialChars.decode!(text)  unless flags.include?(SKIP_SPECIAL_CHARS)
+      text
+    end
+
+  end
+end

data/lib/java-properties/encoding/separators.rb

@@ -0,0 +1,52 @@
+module JavaProperties
+  module Encoding
+    # Module to escape separators as : or =
+    # @see JavaProperties::Encoding
+    module Separators
+
+      # Marker for all separators
+      # @return [Regexp]
+      ENCODE_SEPARATOR_MARKER = /[ :=]/
+
+      # Marker for already escaped separators
+      # @return [Regexp]
+      ESCAPING_MARKER  = /\\/
+
+      # Char to use for escaping
+      # @return [String]
+      ESCAPE           = "\\"
+
+      # Marker for all escaped separators
+      # @return [Regexp]
+      DECODE_SEPARATOR_MARKER = /\\([ :=])/
+
+      # Escapes all not already escaped separators
+      # @param text [text]
+      # @return [String] The escaped text for chaining
+      def self.encode!(text)
+        buffer = StringIO.new
+        last_token = ''
+        text.each_char do |char|
+          if char =~ ENCODE_SEPARATOR_MARKER && last_token !~ ESCAPING_MARKER
+            buffer << ESCAPE
+          end
+          buffer << char
+          last_token = char
+        end
+        text.replace buffer.string
+        text
+      end
+
+      # Removes escapes from escaped separators
+      # @param text [text]
+      # @return [String] The unescaped text for chaining
+      def self.decode!(text)
+        text.gsub!(DECODE_SEPARATOR_MARKER) do
+          $1
+        end
+        text
+      end
+
+    end
+  end
+end

data/lib/java-properties/encoding/special_chars.rb

@@ -0,0 +1,48 @@
+module JavaProperties
+  module Encoding
+    # Module to escape and unescape special chars
+    # @see JavaProperties::Encoding
+    module SpecialChars
+
+      # Lookup table for escaping special chars
+      # @return [Hash]
+      ESCAPING = {
+        "\t" => '\\t',
+        "\r" => '\\r',
+        "\n" => '\\n',
+        "\f" => '\\f'
+      }.freeze
+
+      # Lookup table to remove escaping from special chars
+      # @return [Hash]
+      DESCAPING = ESCAPING.invert.freeze
+
+      # Marks a segment which has is an encoding special char
+      # @return [Regexp]
+      DESCAPING_MARKER = /\\./
+
+      # Encodes the content a text by escaping all special chars
+      # @param text [String]
+      # @return [String] The escaped text for chaining
+      def self.encode!(text)
+        buffer = StringIO.new
+        text.each_char do |char|
+          buffer << ESCAPING.fetch(char, char)
+        end
+        text.replace buffer.string
+        text
+      end
+
+      # Decodes the content a text by removing all escaping from special chars
+      # @param text [String]
+      # @return [String] The unescaped text for chaining
+      def self.decode!(text)
+        text.gsub!(DESCAPING_MARKER) do |match|
+          DESCAPING.fetch(match, match)
+        end
+        text
+      end
+
+    end
+  end
+end

data/lib/java-properties/encoding/unicode.rb

@@ -0,0 +1,61 @@
+module JavaProperties
+  module Encoding
+    # Module to encode and decode unicode chars
+    # @see JavaProperties::Encoding
+    module Unicode
+      
+      # Marker for encoded unicode chars
+      # @return [Regexp]
+      UNICODE_MARKER  = /\\[uU]([0-9a-fA-F]{4,5}|10[0-9a-fA-F]{4})/
+
+      # Escape char for unicode chars
+      # @return [String]
+      UNICODE_ESCAPE = "\\u"
+
+      # Decodes all unicode chars from escape sequences in place
+      # @param text [String]
+      # @return [String] The encoded text for chaining
+      def self.decode!(text)
+        text.gsub!(UNICODE_MARKER) do
+          unicode($1.hex)
+        end
+        text
+      end
+
+      # Decodes all unicode chars into escape sequences in place
+      # @param text [String]
+      # @return [String] The decoded text for chaining
+      def self.encode!(text)
+        buffer = StringIO.new
+        text.each_char do |char|
+          if char.ascii_only?
+            buffer << char
+          else
+            buffer << UNICODE_ESCAPE
+            buffer << hex(char.codepoints.first)
+          end
+        end
+        text.replace buffer.string
+        text
+      end
+
+      private
+
+      def self.unicode(code)
+        [code].pack("U")
+      end
+
+      def self.hex(codepoint)
+        hex  = codepoint.to_s(16)
+        size = hex.size
+        # padding the hex value for uneven digest
+        if (size % 2) == 1
+          "0#{hex}"
+        else
+          hex
+        end
+      end
+
+    end
+  end
+end

data/lib/java-properties/generating.rb

@@ -0,0 +1 @@
+require 'java-properties/generating/generator'

data/lib/java-properties/generating/generator.rb

@@ -0,0 +1,62 @@
+module JavaProperties
+  module Generating
+    # This module allows generating the content of a properties file
+    # base on a {Properties} object (or any other hash like structure)
+    # 
+    # @example
+    #    Generator.generate({:item => "something ה"}) => "item=something \u05d4"
+    #
+    module Generator
+      # Character used for key-value separation
+      # @return [String]
+      KEY_VALUE_SEPARATOR = '='
+
+      # Default options
+      # @return [Hash]
+      DEFAULT_OPTIONS = {
+        :skip_encode_unicode       => false,
+        :skip_encode_separators    => false,
+        :skip_encode_special_chars => false
+      }.freeze
+
+      # Generates a properties file content based on a hash
+      # @param properties [Properties] or simple hash
+      # @param options    [Hash]
+      # @option options skip_encode_unicode [Boolean] Skip unicode encoding
+      # @option options skip_encode_separators [Boolean] Skip seperators encoding
+      # @option options skip_encode_special_chars [Boolean] Skip special char encoding
+      # @return [String]
+      def self.generate(properties, options = {})
+        options = DEFAULT_OPTIONS.merge(options)
+        lines = []
+        properties.each do |k, v|
+          build_group(k, v, lines, options)
+        end
+        lines.join("\n")
+      end
+
+      private
+
+      def self.build_group(key, current_nest, lines, options)
+        if current_nest.class == Hash
+          current_nest.each do |k, v|
+            build_group(key + "." + k, v, lines, options)
+          end
+        else
+          encoded_key   = Encoding.encode!(key.to_s.dup,   *encoding_skips(false, options))
+          encoded_value = Encoding.encode!(current_nest.to_s.dup, *encoding_skips(true,  options))
+
+          lines << encoded_key + KEY_VALUE_SEPARATOR + encoded_value
+        end
+      end
+
+      def self.encoding_skips(is_value, options)
+        skips = []
+        skips << Encoding::SKIP_SEPARATORS    if is_value || options[:skip_encode_separators]
+        skips << Encoding::SKIP_UNICODE       if options[:skip_encode_unicode]
+        skips << Encoding::SKIP_SPECIAL_CHARS if options[:skip_encode_special_chars]
+        skips
+      end
+    end
+  end
+end

data/lib/java-properties/parsing.rb

@@ -0,0 +1,2 @@
+require 'java-properties/parsing/normalizer'
+require 'java-properties/parsing/parser'

data/lib/java-properties/parsing/normalizer.rb

@@ -0,0 +1,74 @@
+module JavaProperties
+  module Parsing
+    # Module to normalize the content of a properties file
+    # 
+    # @example Normalizes:
+    #   # Comment 1
+    #   ! Comment 2
+    #   item0
+    #   item1 = item1 
+    #   item2 : item2 
+    #   item3=line 1 \
+    #         line 2
+    #
+    # @example Into:
+    #
+    #   item0
+    #   item1=item1 
+    #   item2=item2 
+    #   item3=line 1 line 2
+    #
+    module Normalizer
+
+      # Describes a single normalization rule by replacing content
+      class Rule
+        # Initializes a new rules base on a matching regexp
+        # and a replacement as substitution
+        # @param matcher [Regexp]
+        # @param replacement [String]
+        def initialize(matcher, replacement = '')
+          @matcher     = matcher
+          @replacement = replacement
+        end
+
+        # Apply the substitution to the text in place
+        # @param text [string]
+        # @return [String]
+        def apply!(text)
+          text.gsub!(@matcher, @replacement)
+        end
+      end
+
+      # Collection of ordered rules
+      RULES = []
+
+      # Removes comments
+      RULES << Rule.new(/^\s*[!\#].*$/)
+      
+      # Removes leading whitepsace
+      RULES << Rule.new(/^\s+/)
+      
+      # Removes tailing whitepsace
+      RULES << Rule.new(/\s+$/)
+
+      # Strings ending with \ are concatenated
+      RULES << Rule.new(/\\\s*$[\n\r]+/)
+
+      # Remove whitespace around delimiters and replace with =
+      RULES << Rule.new(/^((?:(?:\\[=: \t])|[^=: \t])+)[ \t]*[=: \t][ \t]*/, '\1=')
+
+      RULES.freeze
+
+      # Normalizes the content of a properties file content by applying the RULES
+      # @param text [String]
+      # @return [String] 
+      def self.normalize!(text)
+        RULES.each do |rule|
+          rule.apply!(text)
+        end
+        text
+      end
+
+    end
+  end
+end

data/lib/java-properties/parsing/parser.rb

@@ -0,0 +1,75 @@
+# coding: utf-8
+module JavaProperties
+  module Parsing
+    # This module allows parsing of a properties file content string
+    # into a {Properties} object
+    #
+    # @example
+    #   Parser.parse("item=something \u05d4") => {:item => "something ה"}
+    #
+    module Parser
+
+      # Symbol which separates key from value after normalization
+      # @return [String]
+      KEY_VALUE_MARKER = '='
+      
+      # Symbol which escapes a KEY_VALUE_MARKER in the key name
+      # @return [String]
+      KEY_ESCAPE = '\\'
+
+      # Marker for a line which only consists of an key w/o value
+      # @return [Regexp]
+      KEY_ONLY_MARKER  = /^(\S+)$/
+
+      # Parses a string into a {Properties} object
+      # @param text [String]
+      # @return [Properties]
+      def self.parse(text)
+        properties = Properties.new
+        Normalizer.normalize!(text)
+        text.each_line do |line|
+          key, value = extract_key_and_value(line.chomp)
+          append_to_properties(properties, key, value)
+        end
+        properties
+      end
+
+      private 
+
+      def self.extract_key_and_value(line)
+        # A line must be handled char by char to handled escaped '=' chars in the key name
+        key          = StringIO.new
+        value        = StringIO.new
+        key_complete = false
+        last_token   = ''
+        line.each_char do |char|
+          if !key_complete && char == KEY_VALUE_MARKER && last_token != KEY_ESCAPE
+            key_complete = true
+          else
+            (key_complete ? value : key) << char
+          end
+          last_token = char
+        end
+        [key.string, value.string]
+      end
+
+      def self.append_to_properties(properties, key, value)
+        return if key.nil? || value.nil?
+
+        keys = key.split(".").map { |k| Encoding.decode!(k) }
+        current_nest = properties
+        while k = keys.shift
+          if keys.size == 0
+            current_nest[k] = Encoding.decode!(value, Encoding::SKIP_SEPARATORS)
+          else
+            if !current_nest.has_key? k
+              current_nest[k] = {}
+            end
+          end
+
+          current_nest = current_nest[k]
+        end
+      end
+    end
+  end
+end

data/lib/java-properties/properties.rb

@@ -0,0 +1,6 @@
+module JavaProperties
+  # Simple representation of a properties file content
+  # by a simple ruby hash object
+  class Properties < Hash
+  end
+end

data/lib/java-properties/version.rb

@@ -0,0 +1,7 @@
+module JavaProperties
+
+  # Current version
+  # @return [String]
+  VERSION = "0.0.2".freeze
+
+end

data/spec/fixtures/test.properties

@@ -0,0 +1,33 @@
+# Comment 1
+! Comment 2
+item0
+item1 = item1 
+item2 : item2 
+item3   item3
+
+ #Comment 3
+ ! Comment 4
+ 
+ it\ em4=item4
+ it\=em5:item5 
+ item6 item6 
+
+!Comment 4
+# Comment 5
+
+item7 = line 1 \
+        line 2 \
+        line 3
+
+item8 : line 1 \
+line 2 \
+line 3
+
+item9 line 1 \
+      line 2 \
+line 3
+
+item10=test\n\ttest\u0050 \
+       test\n\ttest \
+       test\n\ttest = test
+

data/spec/fixtures/test_normalized.properties

@@ -0,0 +1,11 @@
+item0
+item1=item1
+item2=item2
+item3=item3
+it\ em4=item4
+it\=em5=item5
+item6=item6
+item7=line 1 line 2 line 3
+item8=line 1 line 2 line 3
+item9=line 1 line 2 line 3
+item10=test\n\ttest\u0050 test\n\ttest test\n\ttest = test

data/spec/fixtures/test_out.properties

@@ -0,0 +1,11 @@
+item0=
+item1=item1
+item2=item2
+item3=item3
+it\ em4=item4
+it\=em5=item5
+it\:em6=item6
+item7=line 1 line 2 line 3
+item8=line 1 line 2 line 3
+item9=line 1 line 2 line 3
+item10=test\n\ttest\u05d4 test\n\ttest test\n\ttest = test

data/spec/fixtures/test_out_skip_separators.properties

@@ -0,0 +1,11 @@
+item0=
+item1=item1
+item2=item2
+item3=item3
+it em4=item4
+it=em5=item5
+it:em6=item6
+item7=line 1 line 2 line 3
+item8=line 1 line 2 line 3
+item9=line 1 line 2 line 3
+item10=test\n\ttest\u05d4 test\n\ttest test\n\ttest = test

data/spec/fixtures/test_out_skip_special_chars.properties

@@ -0,0 +1,14 @@
+item0=
+item1=item1
+item2=item2
+item3=item3
+it\ em4=item4
+it\=em5=item5
+it\:em6=item6
+item7=line 1 line 2 line 3
+item8=line 1 line 2 line 3
+item9=line 1 line 2 line 3
+item10=test
+	test\u05d4 test
+	test test
+	test = test

data/spec/fixtures/test_out_skip_unicode.properties

@@ -0,0 +1,11 @@
+item0=
+item1=item1
+item2=item2
+item3=item3
+it\ em4=item4
+it\=em5=item5
+it\:em6=item6
+item7=line 1 line 2 line 3
+item8=line 1 line 2 line 3
+item9=line 1 line 2 line 3
+item10=test\n\ttestה test\n\ttest test\n\ttest = test

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: ruby-properties-file
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Jonas Thiel
+- Joe Mifsud
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-16 00:00:00.000000000 Z
+dependencies: []
+description: Tool for loading and writing Java properties files
+email:
+- jonas@thiel.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- java-properties.gemspec
+- lib/java-properties.rb
+- lib/java-properties/encoding.rb
+- lib/java-properties/encoding/separators.rb
+- lib/java-properties/encoding/special_chars.rb
+- lib/java-properties/encoding/unicode.rb
+- lib/java-properties/generating.rb
+- lib/java-properties/generating/generator.rb
+- lib/java-properties/parsing.rb
+- lib/java-properties/parsing/normalizer.rb
+- lib/java-properties/parsing/parser.rb
+- lib/java-properties/properties.rb
+- lib/java-properties/version.rb
+- spec/fixtures/test.properties
+- spec/fixtures/test_normalized.properties
+- spec/fixtures/test_out.properties
+- spec/fixtures/test_out_skip_separators.properties
+- spec/fixtures/test_out_skip_special_chars.properties
+- spec/fixtures/test_out_skip_unicode.properties
+homepage: https://github.com/jnbt/java-properties
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.5
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Loader and writer for *.properties files
+test_files:
+- spec/fixtures/test.properties
+- spec/fixtures/test_normalized.properties
+- spec/fixtures/test_out.properties
+- spec/fixtures/test_out_skip_separators.properties
+- spec/fixtures/test_out_skip_special_chars.properties
+- spec/fixtures/test_out_skip_unicode.properties
+has_rdoc: