escape_java_properties 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cd225b2c845a7d716dc847b8e5b722d12d969477b972bfe8317e768cf64995b0
+  data.tar.gz: 35c294ad227d74d390240d1b50457e4fb4098de2c8a3aade4c7e8b83006c6360
+SHA512:
+  metadata.gz: e92043fffcae2711238c80894d982c37685a3adf9b6410a6c8cdacf7d4cc9c4db4b2883a3da01de8c741ac47819bca90c5dce766662cd626d2700a142a26b9f6
+  data.tar.gz: e88c210c224526b2fe86afabdcfef4f7a19ed61414b27ae8677a445bb6b21c36efae4a23f4384705f8645775d188e9098390a4bbb765c007a6b138bb20ff5564

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 escape_java_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/trace-devops/escape_java_propertie)
+
+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,106 @@
+[properties_documentation]: http://docs.oracle.com/javase/6/docs/api/java/util/Properties.html#load(java.io.Reader)
+
+# escape_java_properties
+
+[![RubyGems](http://img.shields.io/gem/v/EscapeJavaProperties.svg)](http://rubygems.org/gems/EscapeJavaProperties)
+
+A ruby library to read and write [Java properties files](http://en.wikipedia.org/wiki/.properties), which format is better described [in the Java documentation][properties_documentation].
+
+## Installation
+
+Install via Rubygems or Gemfile
+
+```zsh
+$ gem install EscapeJavaProperties
+```
+
+## Loading files
+
+You can load a valid Java properties file from the file system using a path:
+
+```ruby
+properties = EscapeJavaProperties.load("path/to/my.properties")
+properties[:foo] # => "bar"
+properties['foo'] # => "bar"
+```
+
+If have already the content of the properties file at hand than parse the content as:
+
+```ruby
+properties = EscapeJavaProperties.load("foo=bar")
+properties[:foo] # => "bar"
+properties['foo'] # => "bar"
+```
+
+## Writing files
+
+You can write any Hash-like structure (with symbol or string keys) as a properties file:
+
+```ruby
+hash = {:foo => "bar", "foobar" => "barfoo"}
+EscapeJavaProperties.write(hash, "path/to/my.properties")
+```
+
+Or if you want to omit the file you can receive the content directly:
+
+```ruby
+hash = {:foo => "bar"}
+EscapeJavaProperties.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
+EscapeJavaProperties.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/trace-devops/EscapeJavaProperties/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
+
+- Trace DevOps
+- Stuart Stephen (@mrswadge) : forked at [38b7f7b66b7a8d02c95c320f5921321a5f528b30](https://github.com/mrswadge/proper_properties/commit/38b7f7b66b7a8d02c95c320f5921321a5f528b30)
+- Tnarik Innael (@tnarik) : forked at [f08b23a1341569f576eb4cf859f59350f58bd1c3](https://github.com/tnarik/proper_properties/commit/f08b23a1341569f576eb4cf859f59350f58bd1c3)
+- Jonas Thiel (@jonasthiel) : [original project](https://github.com/jnbt/java-properties) upto [1f2c4b008d69d0eae1084b1adfdea814e2b29899](https://github.com/tnarik/proper_properties/commit/1f2c4b008d69d0eae1084b1adfdea814e2b29899)
+
+## References
+
+For a proper description about the properties file format have a look at the [Java Plattform documentation][properties_documentation].
+
+## 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/escape_java_properties.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+require 'escape_java_properties/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "escape_java_properties"
+  spec.version       = EscapeJavaProperties::VERSION
+  spec.authors       = ["trace-devops"]
+  spec.email         = ["isysdevops@tracegroup.com"]
+  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/trace-devops/escape_java_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"]
+
+  spec.required_ruby_version = '>= 1.9.3'
+
+  # development dependencies  
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'minitest'
+end

data/lib/escape_java_properties.rb

@@ -0,0 +1,46 @@
+require 'escape_java_properties/version'
+require 'escape_java_properties/properties'
+require 'escape_java_properties/encoding'
+require 'escape_java_properties/parsing'
+require 'escape_java_properties/generating'
+
+# A module to read and write Escape java properties files
+module EscapeJavaProperties
+
+  # Parses the content of a escape javaproperties file
+  # @see Parsing::Parser
+  # @param text [String]
+  # @return [Properties]
+  def self.parse(text)
+    Parsing::Parser.parse(text)
+  end
+
+  # Generates the content of a escape 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 escape java 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 escape 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/escape_java_properties/encoding.rb

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

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

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

@@ -0,0 +1,61 @@
+module EscapeJavaProperties
+  module Encoding
+    # Module to encode and decode unicode chars
+    # @see EscapeJavaProperties::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