proper_properties 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b0e73ae3fb455d335998b9ced5a388d03e923384
+  data.tar.gz: 174890d5265606617411593f037279ef2bbc9c81
+SHA512:
+  metadata.gz: b402ae7a76d56183cf457ce71e97ce8f5f68dae4fd64afecb130abdfcf7aa493214a2bc65d56138f48991bd8193643bd2826953c1a22cf7d11134a7b3cc9213e
+  data.tar.gz: 711cf90f60b7ee205cfe3f921155b3ae3b0fdfb8545b3e886d8a5e717ab2cb62d48a81105ec2afe6ad176ade4e9ce300f6de8b2bbc3b156cd05568b071e7c778

data/.gitignore

@@ -0,0 +1,5 @@
+.ruby-version
+.ruby-gemset
+Gemfile.lock
+coverage
+pkg

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.1.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in proper_properties.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright (c) 2014 Jonas Thiel (Applies to code available as https://github.com/jnbt/java-properties 1f2c4b008d69d0eae1084b1adfdea814e2b29899)
+Copyright (c) 2014 tnarik (Modifications in https://github.com/tnarik/proper_properties)
+
+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,104 @@
+# ProperProperties
+
+[![Build Status](http://img.shields.io/travis/tnarik/proper_properties.svg)](https://travis-ci.org/tnarik/proper_properties)
+[![Code Climate](http://img.shields.io/codeclimate/github/tnarik/proper_properties.svg)](https://codeclimate.com/github/tnarik/proper_properties)
+[![Coveralls](http://img.shields.io/coveralls/tnarik/proper_properties.svg)](https://coveralls.io/r/tnarik/proper_properties)
+[![RubyGems](http://img.shields.io/gem/v/proper_properties.svg)](http://rubygems.org/gems/proper_properties)
+[![Gemnasium](http://img.shields.io/gemnasium/tnarik/proper_properties.svg)](https://gemnasium.com/tnarik/proper_properties)
+
+A ruby library to read and write [Java properties files](http://en.wikipedia.org/wiki/.properties), which format is better describe [in the Java documentation](http://docs.oracle.com/javase/6/docs/api/java/util/Properties.html#load(java.io.Reader\)).
+
+## Installation
+
+Install via Rubygems or Gemfile
+
+```zsh
+$ gem install proper_properties
+```
+
+## Loading files
+
+You can load a valid Java properties file from the file system using a path:
+
+```ruby
+properties = ProperProperties.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 = ProperProperties.load("foo=bar")
+properties[:foo] # => "bar"
+```
+
+## Writing files
+
+You can write any Hash-like structure as a properties file:
+
+```ruby
+hash = {:foo => "bar"}
+ProperProperties.write(hash, "path/to/my.properties")
+```
+
+Or if you want to omit the file you can receive the content directly:
+
+```ruby
+hash = {:foo => "bar"}
+ProperProperties.generate(hash)  # => "foo=bar"
+```
+
+## Encodings and special chars
+
+Although ISO 8859-1 is assumed for Java properties files, they normally use UTF-8 encoding. This tool tries to convert them:
+
+```
+"ה" <=> "\u05d4"
+```
+
+The tool also escaped every '=', ' ' and ':' in the name part of a property line:
+
+```ruby
+ProperProperties.generate({"i : like=strange" => "bar"}) 
+# => "i\ \:\ like\=strange=bar"
+```
+
+## Multi line and line breaks
+
+In Java properties files there is distinction between natural lines and logical lines (than may span several lines by escaping the line terminator characters). 
+
+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/tnarik/proper_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
+
+- Tnarik Innael (@tnarik)
+- Jonas Thiel (@jonasthiel) : [original project](https://github.com/jnbt/java-properties) from commit [1f2c4b008d69d0eae1084b1adfdea814e2b29899]
+
+## References
+
+For a proper description about the properties file format have a look at the [Java Plattform documentation](http://docs.oracle.com/javase/6/docs/api/java/util/Properties.html#load(java.io.Reader\)).
+
+## License
+
+This gem is released under the MIT License. See the LICENSE.txt file for further details.

data/Rakefile

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

data/lib/proper_properties/encoding/separators.rb

@@ -0,0 +1,52 @@
+module ProperProperties
+  module Encoding
+    # Module to escape separators as : or =
+    # @see ProperProperties::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/proper_properties/encoding/special_chars.rb

@@ -0,0 +1,48 @@
+module ProperProperties
+  module Encoding
+    # Module to escape and unescape special chars
+    # @see ProperProperties::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/proper_properties/encoding/unicode.rb

@@ -0,0 +1,61 @@
+module ProperProperties
+  module Encoding
+    # Module to encode and decode unicode chars
+    # @see ProperProperties::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/proper_properties/encoding.rb

@@ -0,0 +1,56 @@
+require 'proper_properties/encoding/special_chars'
+require 'proper_properties/encoding/separators'
+require 'proper_properties/encoding/unicode'
+
+module ProperProperties
+  # 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/proper_properties/generating/generator.rb

@@ -0,0 +1,56 @@
+module ProperProperties
+  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 |key, value|
+          lines << build_line(key, value, options)
+        end
+        lines.join("\n")
+      end
+
+      private
+
+      def self.build_line(key, value, options)
+        encoded_key   = Encoding.encode!(key.to_s.dup,   *encoding_skips(false, options))
+        encoded_value = Encoding.encode!(value.to_s.dup, *encoding_skips(true,  options))
+
+        encoded_key + KEY_VALUE_SEPARATOR + encoded_value
+      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/proper_properties/generating.rb

@@ -0,0 +1 @@
+require 'proper_properties/generating/generator'

data/lib/proper_properties/parsing/normalizer.rb

@@ -0,0 +1,77 @@
+module ProperProperties
+  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 leading whitespace
+      RULES << Rule.new(/^\s+/)
+
+      # Strings ending with \ are concatenated (only if the number is odd)
+      RULES << Rule.new(/^(.*[^\\]((\\){2})*)\\$\s+/, '\1')
+
+      # Removes comments (after the application of the logic line concatenation)
+      RULES << Rule.new(/^\s*[!\#].*$/)
+
+      # Removes empty lines
+      RULES << Rule.new(/^$(\r\n?|\n)/)
+
+      # Unescape double backslashes
+      RULES << Rule.new(/\\\\/, '\\')
+
+      # 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/proper_properties/parsing/parser.rb

@@ -0,0 +1,64 @@
+# coding: utf-8
+module ProperProperties
+  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)
+        unless key.nil? && value.nil?
+          properties[Encoding.decode!(key).to_sym] = Encoding.decode!(value, Encoding::SKIP_SEPARATORS)
+        end
+      end
+
+    end
+  end
+end

data/lib/proper_properties/parsing.rb

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

data/lib/proper_properties/properties.rb

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

data/lib/proper_properties/version.rb

@@ -0,0 +1,3 @@
+module ProperProperties
+  VERSION = "0.0.1"
+end

data/lib/proper_properties.rb

@@ -0,0 +1,46 @@
+require 'proper_properties/version'
+require 'proper_properties/properties'
+require 'proper_properties/encoding'
+require 'proper_properties/parsing'
+require 'proper_properties/generating'
+
+# A module to read and write Proper properties files
+module ProperProperties
+
+  # Parses the content of a Proper properties file
+  # @see Parsing::Parser
+  # @param text [String]
+  # @return [Properties]
+  def self.parse(text)
+    Parsing::Parser.parse(text)
+  end
+
+  # Generates the content of a Proper 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 Proper properties file
+  # @see Parsing::Parser
+  # @param path [String]
+  # @param encoding [String]
+  # @param allow_invalid_byte_sequence [Boolean]
+  # @return [Properties]
+  def self.load(path, encoding = 'UTF-8', allow_invalid_byte_sequence = true)
+      parse(File.read(path).encode(encoding, 'binary', allow_invalid_byte_sequence ? {invalid: :replace, undef: :replace} : {} ))
+  end
+
+  # Generates a Proper 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/proper_properties.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'proper_properties/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "proper_properties"
+  spec.version       = ProperProperties::VERSION
+  spec.authors       = ["Tnarik Innael"]
+  spec.email         = ["tnarik@lecafeautomatique.co.uk"]
+  spec.summary       = %q{Loader and writer for Java properties files}
+  spec.description   = %q{Library for loading and writing of Java properties files that matches java.util.Properties behaviour}
+  spec.homepage      = "https://github.com/tnarik/proper_properties"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  # development dependencies  
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'minitest'
+end

data/spec/fixtures/test.properties

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

data/spec/fixtures/test_normalized.properties

@@ -0,0 +1,14 @@
+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 #Not a Comment line 2 line 3
+item9=line 1 line 2 line 3
+item10=test\n\ttest\u0050 test\n\ttest test\n\ttest = test
+item11=line 1 \line 2 \\line 3 line 4
+item12=line 1\
+item13=line 1

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

data/spec/helper.rb

@@ -0,0 +1,20 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  Coveralls::SimpleCov::Formatter,
+  SimpleCov::Formatter::HTMLFormatter
+]
+
+SimpleCov.start
+
+require 'minitest/autorun'
+require 'proper_properties'
+
+class Minitest::Spec
+
+  def fixture(*segments)
+    File.read(File.join(File.dirname(__FILE__), "fixtures", *segments))
+  end
+
+end

data/spec/proper_properties/encoding/separators_spec.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+describe ProperProperties::Encoding::Separators do
+  subject{ ProperProperties::Encoding::Separators }
+  let(:raw)    { 'this is some = text : with special \\=separators' }
+  let(:raw_normalizd) { 'this is some = text : with special =separators' }
+  let(:encoded){ 'this\\ is\\ some\\ \\=\\ text\\ \\:\\ with\\ special\\ \\=separators' }
+
+  it "encodes separators" do
+    processed = subject.encode!(raw.dup)
+    processed.must_equal encoded
+  end
+
+  it "decodes separators" do
+    processed = subject.decode!(encoded.dup)
+    processed.must_equal raw_normalizd
+  end
+
+end

data/spec/proper_properties/encoding/special_chars_spec.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+describe ProperProperties::Encoding::SpecialChars do
+  subject{ ProperProperties::Encoding::SpecialChars }
+  let(:raw)    { "this is some \n text \t with special\r chars\f" }
+  let(:encoded){ 'this is some \n text \t with special\r chars\f' }
+
+  it "encodes special chars" do
+    processed = subject.encode!(raw.dup)
+    processed.must_equal encoded
+  end
+
+  it "deencodes special chars" do
+    processed = subject.decode!(encoded.dup)
+    processed.must_equal raw
+  end
+
+  it "decodes and encodes to the same" do
+    encoded  = subject.encode!(raw.dup)
+    deconded = subject.decode!(encoded)
+    deconded.must_equal raw
+  end
+end

data/spec/proper_properties/encoding/unicode_spec.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+require 'helper'
+
+describe ProperProperties::Encoding::Unicode do
+  subject{ ProperProperties::Encoding::Unicode }
+
+  let(:encoded) { 'this is some \u0024 text \U05D4 with unicode' }
+  let(:encoded_normalized) { 'this is some $ text \u05d4 with unicode' }
+  let(:decoded) { 'this is some $ text ה with unicode' }
+
+  it "decodes unicode chars" do
+    subject.decode!(encoded.dup).must_equal decoded
+  end
+
+  it "encodes unicode chars" do
+    subject.encode!(decoded.dup).must_equal encoded_normalized
+  end
+
+  it "encodes unicode chars but has 2-based hex size" do
+    subject.encode!("ה").must_equal '\u05d4'
+    subject.encode!("ᘓ").must_equal '\u1613'
+  end
+
+  it "decodes and encodes" do
+    encoded  = subject.encode!(decoded.dup)
+    deconded = subject.decode!(encoded.dup)
+    deconded.must_equal decoded
+  end
+end

data/spec/proper_properties/encoding_spec.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+require 'helper'
+
+describe ProperProperties::Encoding do
+  subject{ ProperProperties::Encoding }
+
+  describe "full" do
+    let(:decoded){ "this is some \n text = with ה" }
+    let(:encoded){ 'this\ is\ some\ \n\ text\ \=\ with\ \u05d4' }
+    
+    it "encodes correctly" do
+      input     = decoded.dup
+      processed = subject.encode!(input)
+      processed.must_equal encoded
+    end
+
+    it "decodes correctly" do
+      input     = encoded.dup
+      processed = subject.decode!(input)
+      processed.must_equal decoded
+    end
+  end
+
+  describe "skip_separators" do
+    let(:decoded){ "this is some \n text = with ה" }
+    let(:encoded){ 'this is some \n text = with \u05d4' }
+
+     it "encodes correctly" do
+      input     = decoded.dup
+      processed = subject.encode!(input, subject::SKIP_SEPARATORS)
+      processed.must_equal encoded
+    end
+
+    it "decodes correctly" do
+      input     = encoded.dup
+      processed = subject.decode!(input, subject::SKIP_SEPARATORS)
+      processed.must_equal decoded
+    end
+  end
+
+  describe "skip_unicode" do
+    it "encodes correctly" do
+      input     = "this is some \n text = with ה"
+      processed = subject.encode!(input, subject::SKIP_UNICODE)
+      expected  = 'this\ is\ some\ \n\ text\ \=\ with\ ה'
+      processed.must_equal expected
+    end
+
+    it "decodes correctly" do
+      input     = 'this\ is\ some\ \n\ text\ \=\ with\ \u05d4'
+      processed = subject.decode!(input, subject::SKIP_UNICODE)
+      expected  = "this is some \n text = with " + '\u05d4'
+      processed.must_equal expected
+    end
+  end
+
+  describe "skip_special_chars" do
+    it "encodes correctly" do
+      input     = "this is some \n text = with ה"
+      processed = subject.encode!(input, subject::SKIP_SPECIAL_CHARS)
+      expected  = 'this\ is\ some\ ' + "\n" + '\ text\ \=\ with\ \u05d4'
+      processed.must_equal expected
+    end
+
+    it "decodes correctly" do
+      input     = 'this\ is\ some\ \n\ text\ \=\ with\ \u05d4'
+      processed = subject.decode!(input, subject::SKIP_SPECIAL_CHARS)
+      expected  = 'this is some \n text = with ה'
+      processed.must_equal expected
+    end
+  end
+end

data/spec/proper_properties/generating/generator_spec.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+require 'helper'
+
+describe ProperProperties::Generating::Generator do
+  subject { ProperProperties::Generating::Generator }
+
+  let(:as_hash) do
+    {
+      :item0 => "",
+      :item1 => "item1".freeze,
+      :item2 => "item2",
+      :item3 => "item3",
+      :"it em4".freeze => "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"
+    }
+  end
+
+  it "generates properties file content" do
+    expected = fixture("test_out.properties")
+    content  = subject.generate(as_hash)
+    content.must_equal expected
+  end
+
+  it "generates properties file content but skips unicode encoding" do
+    expected = fixture("test_out_skip_unicode.properties")
+    content  = subject.generate(as_hash, :skip_encode_unicode => true)
+    content.must_equal expected
+  end
+
+  it "generates properties file content but skips separators encoding" do
+    expected = fixture("test_out_skip_separators.properties")
+    content  = subject.generate(as_hash, :skip_encode_separators => true)
+    content.must_equal expected
+  end
+
+  it "generates properties file content but skips special chars encoding" do
+    expected = fixture("test_out_skip_special_chars.properties")
+    content  = subject.generate(as_hash, :skip_encode_special_chars => true)
+    content.must_equal expected
+  end
+
+end

data/spec/proper_properties/parsing/normalizer_spec.rb

@@ -0,0 +1,13 @@
+require 'helper'
+
+describe ProperProperties::Parsing::Normalizer do
+  subject { ProperProperties::Parsing::Normalizer }
+
+  it "normalizes by applying all rules" do
+    content    = fixture("test.properties")
+    normalized = fixture("test_normalized.properties")
+    subject.normalize! content
+    content.must_equal normalized
+  end
+
+end

data/spec/proper_properties/parsing/parser_spec.rb

@@ -0,0 +1,36 @@
+require 'helper'
+
+describe ProperProperties::Parsing::Parser do
+  subject { ProperProperties::Parsing::Parser }
+
+  let(:as_hash) do
+    {
+      :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 #Not a Comment line 2 line 3",
+      :item9 => "line 1 line 2 line 3",
+      :item10 => "test\n\ttestP test\n\ttest test\n\ttest = test",
+      :item11 => "line 1 \\line 2 \\\\line 3 line 4",
+      :item12 => "line 1\\",
+      :item13 => "line 1"
+    }
+  end
+
+  it "parses correctly a properties file content" do
+    content    = fixture("test.properties")
+    properties = subject.parse(content)
+
+    # don't compare the hashes directly, as this hard to debug
+    properties.keys.must_equal as_hash.keys
+    properties.each do |key, value|
+      value.must_equal as_hash[key]
+    end
+  end
+
+end

data/spec/proper_properties/version_spec.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+describe ProperProperties do
+  it "should have a version" do
+    ProperProperties::VERSION.wont_be_nil
+  end
+end

data/spec/proper_properties_spec.rb

@@ -0,0 +1,43 @@
+require 'helper'
+require 'tempfile'
+
+describe ProperProperties do
+  subject{ ProperProperties }
+
+  it "parses from string" do
+    subject.parse("item1=item1").must_equal({:item1 => "item1"})
+  end
+
+  it "generates from hash" do
+    subject.generate({:item1 => "item1"}).must_equal("item1=item1")
+  end
+
+  it "loads from file" do
+    with_temp_file do |file|
+      file << "item1=item1"
+      file.flush
+
+      subject.load(file.path).must_equal({:item1 => "item1"})
+    end
+  end
+
+  it "writes to file" do
+    with_temp_file do |file|      
+      subject.write({:item1 => "item1"}, file.path)
+
+      file.rewind
+      file.read.must_equal "item1=item1"
+    end
+  end
+
+  private
+
+  def with_temp_file(&block)
+    file = Tempfile.new("proper_properties")
+    block.call(file)
+  ensure
+    file.close
+    file.unlink
+  end
+
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: proper_properties
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tnarik Innael
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Library for loading and writing of Java properties files that matches
+  java.util.Properties behaviour
+email:
+- tnarik@lecafeautomatique.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/proper_properties.rb
+- lib/proper_properties/encoding.rb
+- lib/proper_properties/encoding/separators.rb
+- lib/proper_properties/encoding/special_chars.rb
+- lib/proper_properties/encoding/unicode.rb
+- lib/proper_properties/generating.rb
+- lib/proper_properties/generating/generator.rb
+- lib/proper_properties/parsing.rb
+- lib/proper_properties/parsing/normalizer.rb
+- lib/proper_properties/parsing/parser.rb
+- lib/proper_properties/properties.rb
+- lib/proper_properties/version.rb
+- proper_properties.gemspec
+- 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
+- spec/helper.rb
+- spec/proper_properties/encoding/separators_spec.rb
+- spec/proper_properties/encoding/special_chars_spec.rb
+- spec/proper_properties/encoding/unicode_spec.rb
+- spec/proper_properties/encoding_spec.rb
+- spec/proper_properties/generating/generator_spec.rb
+- spec/proper_properties/parsing/normalizer_spec.rb
+- spec/proper_properties/parsing/parser_spec.rb
+- spec/proper_properties/version_spec.rb
+- spec/proper_properties_spec.rb
+homepage: https://github.com/tnarik/proper_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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Loader and writer for Java 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
+- spec/helper.rb
+- spec/proper_properties/encoding/separators_spec.rb
+- spec/proper_properties/encoding/special_chars_spec.rb
+- spec/proper_properties/encoding/unicode_spec.rb
+- spec/proper_properties/encoding_spec.rb
+- spec/proper_properties/generating/generator_spec.rb
+- spec/proper_properties/parsing/normalizer_spec.rb
+- spec/proper_properties/parsing/parser_spec.rb
+- spec/proper_properties/version_spec.rb
+- spec/proper_properties_spec.rb