escape_java_properties 0.0.3

data/lib/escape_java_properties/generating.rb

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

data/lib/escape_java_properties/generating/generator.rb

@@ -0,0 +1,56 @@
+module EscapeJavaProperties
+  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/escape_java_properties/parsing.rb

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

data/lib/escape_java_properties/parsing/normalizer.rb

@@ -0,0 +1,77 @@
+module EscapeJavaProperties
+  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/escape_java_properties/parsing/parser.rb

@@ -0,0 +1,64 @@
+# coding: utf-8
+module EscapeJavaProperties
+  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/escape_java_properties/properties.rb

@@ -0,0 +1,64 @@
+module EscapeJavaProperties
+  # Simple representation of a properties file content
+  # by an extension of a Hash object a la ActiveSupport::HashWithIndifferentAccess, with underlying symbol keys
+  class Properties < Hash
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = EscapeJavaProperties::Properties.new
+    #   hash[:key] = 'value'
+    #
+    # This value can be later fetched using either +:key+ or +'key'+.
+    def []=(key, value)
+      super(convert_key(key), value)
+    end
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = EscapeJavaProperties::Properties.new
+    #   hash['key'] = 'value'
+    #   hash.key?(:key)  # => true
+    #   hash.key?('key') # => true
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
+    # either a string or a symbol:
+    #
+    #   counters = EscapeJavaProperties::Properties.new
+    #   counters[:foo] = 1
+    #
+    #   counters.fetch('foo')          # => 1
+    #   counters.fetch(:bar, 0)        # => 0
+    #   counters.fetch(:bar) {|key| 0} # => 0
+    #   counters.fetch(:zoo)           # => KeyError: key not found: "zoo"
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = EscapeJavaProperties::Properties.new
+    #   hash[:a] = 'x'
+    #   hash[:b] = 'y'
+    #   hash.values_at('a', 'b') # => ["x", "y"]
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # Removes the specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def [](key)
+      self.fetch(key)
+    end
+
+  	protected
+      def convert_key(key)
+        key.kind_of?(String) ? key.to_sym : key
+    end
+  end
+end

data/lib/escape_java_properties/version.rb

@@ -0,0 +1,3 @@
+module EscapeJavaProperties
+  VERSION = "0.0.3"
+end

data/spec/escape_java_properties/encoding/separators_spec.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+describe EscapeJavaProperties::Encoding::Separators do
+  subject{ EscapeJavaProperties::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/escape_java_properties/encoding/special_chars_spec.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+describe EscapeJavaProperties::Encoding::SpecialChars do
+  subject{ EscapeJavaProperties::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/escape_java_properties/encoding/unicode_spec.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+require 'helper'
+
+describe EscapeJavaProperties::Encoding::Unicode do
+  subject{ EscapeJavaProperties::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/escape_java_properties/encoding_spec.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+require 'helper'
+
+describe EscapeJavaProperties::Encoding do
+  subject{ EscapeJavaProperties::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/escape_java_properties/generating/generator_spec.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+require 'helper'
+
+describe EscapeJavaProperties::Generating::Generator do
+  subject { EscapeJavaProperties::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