java_properties 0.0.4

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-03-27
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,24 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+lib/java_properties.rb
+lib/java_properties/version.rb
+log/debug.log
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+test/test_helper.rb
+test/test_java_properties.rb
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.rhtml

data/README.txt

@@ -0,0 +1,36 @@
+= Java Properties Files in Ruby
+
+I don't know if there's a real need for this, and if there is the jruby
+people probably have it covered a lot better than I do. These classes
+were mainly whipped up as an exercise in creating a ruby gem.
+
+= JavaProperties::Properties
+
+A class that can read and write to Java properties files that behaves
+otherwise as a standard ruby Enumerable. The keys to this object can
+be provided as Strings or Symbols, but internally they are Symbols.
+
+  require 'rubygems'
+  require 'java_properties'
+  
+  # Create a new object from a file
+  props = JavaProperties::Properties.new("/path/to/file.properties")
+  
+  # Merge in another file
+  props.load("/path/to/other/file.properties")
+  
+  # Behaves as an Enumerable
+  props.each{ |key,value| puts "#{key} = #{value}" }
+
+= properties2yaml
+
+An executable script to convert an existing properties file to a YAML
+file. There is no script to go the other way because not all YAML
+files can be saved into a properties file. (That and I was feeling lazy.)
+ 
+  Usage: properties2yaml [options] [INPUT] [OUTPUT]
+  
+  Options are:
+  
+      -s, --stdin  Read input from standard input instead of an input file
+      -h, --help   Show this help message.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/bin/properties2yaml

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+#
+#  Created on 2008-6-12.
+#  Copyright (c) 2008. All rights reserved.
+
+# NOTE: Adding gem lib dir to includes path
+# This probably isn't the right way to do this, but until I know how
+# this works.
+$:.unshift "#{File.dirname(__FILE__)}/../lib/"
+
+begin
+  require 'rubygems'
+rescue LoadError
+  # no rubygems to load, so we fail silently
+end
+
+require 'optparse'
+require 'java_properties'
+require 'yaml'
+
+OPTIONS = {
+  :stdin     => false
+}
+MANDATORY_OPTIONS = %w(  )
+
+parser = OptionParser.new do |opts|
+  opts.banner = <<BANNER
+Converts a Java properties file to YAML.
+
+Usage: #{File.basename($0)} [options] [INPUT] [OUTPUT]
+
+Options are:
+BANNER
+  opts.separator ""
+  opts.on("-s", "--stdin",
+          "Read input from standard input instead of an input file") { |OPTIONS[:path]| }
+  opts.on("-h", "--help",
+          "Show this help message.") { puts opts; exit }
+  opts.parse!(ARGV)
+
+  if MANDATORY_OPTIONS && MANDATORY_OPTIONS.find { |option| OPTIONS[option.to_sym].nil? }
+    puts opts; exit
+  end
+  if ARGV.empty? && !OPTIONS[:stdin] 
+    puts opts; exit
+  end
+end
+
+infile = $stdin
+outfile = $stdout
+
+stdin = OPTIONS[:stdin] ? $stdin : false
+
+begin
+  infilepath  = ARGV.shift unless(ARGV.empty? || stdin)
+  infile  = File.open(infilepath,'r') if infilepath
+  outfilepath = ARGV.shift unless(ARGV.empty?)
+  outfile = File.open(outfilepath,'w') if outfilepath
+rescue
+  $stderr.puts "Error opening input properties file '#{infilepath}' for reading." unless infile.is_a? File
+  $stderr.puts "Error opening output YAML file '#{outfilepath}' for writing." if  infile.is_a? File
+  exit 1
+end
+
+props = {}
+JavaProperties::Parser.parse( infile.read ).each do |key,value|
+  # Convert all of the keys in the properties file to strings
+  # so that they don't output as symbols in the to_yaml results
+  props[key.to_s] = value
+end
+outfile.puts props.to_yaml

data/java_properties.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |s|
+  s.name = "java_properties"
+  s.version = "0.0.4"
+  s.date = "2008-06-14"
+  s.summary = "Simple gem for reading/writing Java properties files from Ruby."
+  s.email = "flergl@flergl.net"
+  s.homepage = "http://github.com/flergl/java-properties-for-ruby"
+  s.description = "A class that can read and write to Java properties files that behaves
+otherwise as a standard ruby Enumerable. The keys to this object can
+be provided as Strings or Symbols, but internally they are Symbols."
+  s.has_rdoc = true
+  s.authors = ["Dwayne Kristjanson"]
+  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile","java_properties.gemspec",
+             "lib/java_properties.rb","lib/java_properties/delimiters.rb",
+             "lib/java_properties/encoding.rb","lib/java_properties/parser.rb",
+             "lib/java_properties/properties-files.rb","lib/java_properties/specialchars.rb",
+             "lib/java_properties/utf8.rb","lib/java_properties/version.rb","bin/properties2yaml",
+             "test/test_data.rb","test/test_helper.rb","test/test_java_properties.rb"]
+  s.test_files = ["test/test_data.rb","test/test_helper.rb","test/test_java_properties.rb"]
+  s.rdoc_options = ["--main", "README.txt"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+  s.executables = ["properties2yaml"]
+end

data/lib/java_properties.rb

@@ -0,0 +1,100 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'java_properties/encoding'
+require 'java_properties/properties-files'
+require 'java_properties/parser'
+
+# The JavaProperties::Properties class provides a wrapper around
+# a Hash of key/value pairs that provides the ability to load
+# from and save to Java properties files.
+
+module JavaProperties
+
+  # A class that can read and write to Java properties files that behaves
+  # otherwise as a standard ruby Enumerable. The keys to this object can
+  # be provided as Strings or Symbols, but internally they are Symbols.
+  # 
+  #   require 'rubygems'
+  #   require 'java_properties'
+  #   
+  #   # Create a new object from a file
+  #   props = JavaProperties::Properties.new("/path/to/file.properties")
+  #   
+  #   # Merge in another file
+  #   props.load("/path/to/other/file.properties")
+  #   
+  #   # Behaves as an Enumerable
+  #   props.each{ |key,value| puts "#{key} = #{value}" }  
+  
+  class Properties
+  
+    include Enumerable
+  
+    # Creates a new Properties object based on the contents
+    # of a Java properties file.
+  
+    def self.load file
+      Properties.new file
+    end
+    
+    # Merges the contents of a Java properties file with
+    # the properties already contained in this object.
+    
+    def load file
+      @props.merge! Parser.parse( PropFile.read( file ) )
+    end
+    
+    def initialize file
+      @props = {}
+      load(file)
+    end
+  
+    # Stores the current properties into a properties file.
+    # Optionally, a header comment can be provided.
+  
+    def store file, header = nil
+      PropFile.write(file, self, header)
+    end
+    
+    # Appends the current properties to the end of another
+    # properties file. Optionally, a seperator comment
+    # can be provided.
+  
+    def append file, seperator = nil
+      PropFile.append(file, self, seperator)
+    end
+  
+    def[](key)
+      @props[key.to_sym]
+    end
+    
+    def[]=(key,value)
+      @props[key.to_sym] = value
+    end
+    
+    def each &block
+      @props.each &block
+    end
+    
+    def keys
+      @props.keys
+    end
+    
+    # Converts the properties contained in this object into a
+    # string that can be saved directly as a Java properties
+    # file.
+    
+    def to_s
+      string = ""
+      # Sort to make testing easier -> output will consistent
+      @props.sort_by do |key,val|
+        key.to_s
+      end.each do |key,val|
+	string << Encoding.encode(key.to_s) << "=" << Encoding.encode(val) << "\n"
+      end
+      string
+    end
+  
+  end
+
+end

data/lib/java_properties/delimiters.rb

@@ -0,0 +1,40 @@
+module JavaProperties
+  
+  module Encoding
+        
+  # Modules for encoding and decoding delimiters characters
+  # for Java properties files when those delimiters are
+  # found in the property keys.
+  
+    module Delimiters
+      
+      # Encodes any delimiter characters found in the
+      # property keys by prepending a \
+      
+      def self.encode string
+	s = ''
+	prev = ''
+	chars = string.split( // )
+	while(chars.size > 0) do
+	  char = chars.shift
+	  if char =~ /[ :=]/ && prev !~ /\\/ then
+	    s << "\\" << char
+	  else
+	    s << char
+	  end
+	  prev = char
+	end
+	s
+      end
+      
+      # No decoding is necessary, but this method has
+      # been provided for consistency with other
+      # encoding modules.
+      
+      def self.decode string
+	string
+      end
+    end
+
+  end
+end

data/lib/java_properties/encoding.rb

@@ -0,0 +1,38 @@
+require "java_properties/utf8"
+require "java_properties/specialchars"
+require "java_properties/delimiters"
+
+module JavaProperties
+  
+  # Classes for encoding and decoding strings for Java properties files.
+
+  module Encoding
+    
+    # Encodes a string by escaping special characters (\n, \t, etc.),
+    # delimiters ( =, :) and UTF-8 characters.
+    
+    def self.encode string
+      # Replace special chars with proper \n escaped characters
+      string = SpecialChars.encode(string)
+      
+      # Replace unescaped delimiters with proper \n escaped characters
+      string = Delimiters.encode(string)
+      
+      # Replace UTF-8 bytes with \uXXXX encoding
+      string = Utf8.encode(string)
+  
+      string
+    end
+    
+    # Decodes a string by unescaping UTF-8 and special characters
+    
+    def self.decode string
+      # Replace \uXXXX escaped chars with proper UTF-8 bytes
+      string = Utf8.decode(string)
+      
+      # Replace \n escaped chars with proper characters
+      string = SpecialChars.decode(string)
+    end
+     
+  end
+end

data/lib/java_properties/parser.rb

@@ -0,0 +1,52 @@
+require "java_properties/encoding"
+
+module JavaProperties
+  
+  # Module for parsing Java properties text into a Hash.
+  #
+  #    props_hash = JavaProperties::Parser.parse( string_of_propfile_contents )
+  
+  module Parser
+    
+    # Parses a string containing the contents of a Java properties
+    # file into a hash of key/value pairs. The keys are converted
+    # into symbols.
+    
+    def self.parse text
+      props = {}
+      text = self.normalize(text)
+      text.split(/[\n\r]+/).each do |line|
+	if line =~ /^([^=]*)=(.*)$/ then
+	  key,value = $1,$2
+	elsif line =~ /\S/ then
+	  key,value = line, ''
+	else
+	  key,value = nil,nil
+	end
+	props[Encoding.decode(key).to_sym] = Encoding.decode(value) unless key.nil? && value.nil?
+      end
+      props
+    end
+     
+    # Normalizes the contents of a Java properties file so
+    # that comments are removed, leading spaces are trimmed off,
+    # multiline entries are consolidated and all delimiters
+    # are consistent.
+  
+    def self.normalize text
+      # Remove comment lines
+      text.gsub!( /^\s*[!\#].*$/, '' )
+      # Remove all leading spaces
+      text.gsub!( /^\s+/, '' )
+      # Remove all trailing spaces
+      text.gsub!( /\s+$/, '' )
+      # Concatenate strings ending with \
+      text.gsub!( /\\\s*$[\n\r]+/, '' )
+      # Remove spaces next to delimiters and replace all with =
+      text.gsub!( /^((?:(?:\\[=: \t])|[^=: \t])+)[ \t]*[=: \t][ \t]*/, '\1=' )
+      
+      text
+    end
+  
+  end
+end

data/lib/java_properties/properties-files.rb

@@ -0,0 +1,70 @@
+require 'java_properties/encoding'
+
+# Modules for reading and writing Java properties files.
+
+module JavaProperties
+  
+  # PropFile allows reading and writing properties files
+  #
+  #    props = JavaProperties::PropFile.read( file )
+  #
+  #    JavaProperties::PropFile.write( file, props, "Optional header comment" )
+  #
+  #    JavaProperties::PropFile.append( file, props, "Optional seperator comment" )
+  #
+  
+  module PropFile
+    
+    # Reads in a Java properties file and returns the
+    # contents as a string for parsing.
+    
+    def self.read file
+      file = open(file)
+      text = ''
+      while(line = file.gets) do
+	text += line
+      end
+      text
+    end
+    
+    # Writes out a Hash of key/value pairs to a properities
+    # file. Optionally a  header comment can be provided.
+    
+    def self.write file, props, header = nil
+      unless header.nil? then
+	File.open(file,'w') { |f| f.write "# " + header +"\n" }
+        File.open(file,'a') { |f| f.write self.stringify(props) }
+    else
+        File.open(file,'w') { |f| f.write self.stringify(props) }
+      end
+    end
+    
+    # Appends a Hash of key/value paris to the end of an existing
+    # properties file. Optionally a seperator comment can be
+    # provided.
+    
+    def self.append file, props, seperator = nil
+      unless seperator.nil? then
+	File.open(file,'a') { |f| f.write "\n# " + seperator }
+      end
+      File.open(file,'a') { |f| f.write "\n" + self.stringify(props) }
+    end
+  
+    private
+  
+    # Converts a Hash of key/value pairs into a String that can
+    # be directly saved into a Java properties file.
+    
+    def self.stringify props
+      string = ""
+      # Sort to make testing easier -> output will consistent
+      props.sort_by do |key,val|
+        key.to_s
+      end.each do |key,val|
+	string << Encoding.encode(key.to_s) << "=" << Encoding.encode(val) << "\n"
+      end
+      string
+    end
+    
+  end
+end

data/lib/java_properties/specialchars.rb

@@ -0,0 +1,56 @@
+module JavaProperties
+  
+  module Encoding
+  
+    # Modules for encoding and decoding special characters for
+    # Java properties files.
+    
+    module SpecialChars
+      
+      # Encodes all special characters by replacing them with
+      # the proper \X escaped value.
+      
+      def self.encode string
+	# Replace special chars with proper \n escaped characters
+	string.gsub!( /([\t\n\r\f])/ ) do |c|
+	  char = $1
+	  case char
+	  when "\t"
+	    '\\t'
+	  when "\n"
+	    '\\n'
+	  when "\r"
+	    '\\r'
+	  when "\f"
+	    '\\f'
+	  end
+	end
+	string
+      end
+      
+      # Decodes any \X characters read in from a properties file.
+      
+      def self.decode string
+	# Replace \n escaped chars with proper characters
+	string.gsub!( /\\(.)/ ) do |c|
+	  char = $1 if c =~ /\\(.)/
+	  case char
+	  when 't'
+	    "\t"
+	  when 'n'
+	    "\n"
+	  when 'r'
+	    "\r"
+	  when 'f'
+	    "\f"
+	  else
+	    char
+	  end
+	end
+	string
+      end
+    
+    end
+  
+  end
+end

data/lib/java_properties/utf8.rb

@@ -0,0 +1,119 @@
+module JavaProperties
+  
+  module Encoding
+    
+    # Modules for encoding and decoding UTF-8 characters into ASCII
+    # for Java properties files.
+    #
+    #   # Decode a string with UTF-8 encoded as \uXXXX (e.g. \u0050  = 'P')
+    #   decoded_string = JavaProperties::Encoding::Utf8.decode( encoded_string )
+    #
+    #   # Encode a string so that unicode characters are escaped as \uXXXX
+    #   encoded_string = JavaProperties::Encoding::Utf8.encode( decoded_string )
+    #
+    #   # Get the bytes that represent a given UTF-9 code point
+    #   utf8_char_as_string = JavaProperties::Encoding::Utf8.utf8( code_point )
+    
+    module Utf8
+      
+      # Replaces \uXXXX escaped chars with proper UTF-8 bytes
+      
+      def self.decode(string)
+	string.gsub!( /\\[uU]([0-9a-fA-f]{1,6})/) do |c|
+	  Encoding::Utf8.utf8($1.hex)
+	end
+	string
+      end
+      
+      # Gets the UTF-8 encoding of a given unicode code point (provided as an Fixnum)
+      
+      def self.utf8(ud)
+	s = ""
+	if ud < 128 then
+	  # UTF-8 is 1 byte long, the value of ud.
+	  s << ud
+	elsif ud >= 128 && ud <= 2047 then
+	  # UTF-8 is 2 bytes long.
+	  s << (192 + (ud.div 64))
+	  s << (128 + (ud % 64))
+	elsif ud >= 2048 && ud <= 65535 then
+	  # UTF-8 is 3 bytes long.
+	  s << (224 + (ud.div 4096))
+	  s << (128 + ((ud.div 64) % 64))
+	  s << (128 + (ud % 64))
+	elsif ud >= 65536 && ud <=2097151 then
+	  # UTF-8 is 4 bytes long.
+	  s << (240 + (ud.div 262144))
+	  s << (128 + ((ud.div 4096) % 64))
+	  s << (128 + ((ud.div 64) % 64))
+	  s << (128 + (ud % 64))
+	elsif ud >= 2097152 && ud <= 7108863 then
+	  # UTF-8 is 5 bytes long.
+	  s << (248 + (ud.div 16777216))
+	  s << (128 + ((ud.div 262144) % 64))
+	  s << (128 + ((ud.div 4096) % 64))
+	  s << (128 + ((ud.div 64) % 64))
+	  s << (128 + (ud % 64))
+	elsif ud >= 67108864 && ud <= 2147483647
+	  # then UTF-8 is 6 bytes long.
+	  s << (252 + (ud.div 1073741824))
+	  s << (128 + ((ud.div 16777216) % 64))
+	  s << (128 + ((ud.div 262144) % 64))
+	  s << (128 + ((ud.div 4096) % 64))
+	  s << (128 + ((ud.div 64) % 64))
+	  s << (128 + (ud % 64))
+	end
+	s
+      end
+    
+      # Encodes all UTF-8 characters in the provided string using \uXXXX
+      # format.
+      
+      def self.encode(string)
+	s = ""
+	chars = string.split( // )
+	while(chars.size > 0) do
+	  z = chars.shift[0].to_i
+	  if z >= 0 && z <= 127 then
+	    # 1 byte -- essentially ascii
+	    s << z
+	  elsif z >= 192 && z <= 223 then
+	    # 2 bytes
+	    y = chars.shift[0].to_i
+	    s << "\\u#{sprintf('%02x',( (z-192)*64 + (y-128) ))}"
+	  elsif z >= 224 && z <= 239 then
+	    # 3 bytes
+	    y = chars.shift[0].to_i
+	    x = chars.shift[0].to_i
+	    s << "\\u#{sprintf('%04x',( (z-224)*4096 + (y-128)*64 + (x-128) ))}"
+	  elsif z >= 240 && z <= 247 then
+	    # 4 bytes
+	    y = chars.shift[0].to_i
+	    x = chars.shift[0].to_i
+	    w = chars.shift[0].to_i
+	    s << "\\u#{sprintf('%06x',( (z-240)*262144 + (y-128)*4096 + (x-128)*64 + (w-128) ))}"
+	  elsif z >= 248 && z <= 251 then
+	    # 5 bytes
+	    y = chars.shift[0].to_i
+	    x = chars.shift[0].to_i
+	    w = chars.shift[0].to_i
+	    v = chars.shift[0].to_i
+	    s << "\\u#{sprintf('%08x',( (z-248)*16777216 + (y-128)*262144 + (x-128)*4096 + (w-128)*64 + (v-128) ))}"
+	  elsif z >= 252 && z <= 253 then
+	    # 6 bytes
+	    y = chars.shift[0].to_i
+	    x = chars.shift[0].to_i
+	    w = chars.shift[0].to_i
+	    v = chars.shift[0].to_i
+	    u = chars.shift[0].to_i
+	    s << "\\u#{sprintf('%010x',( (z-252)*1073741824 + (y-128)*16777216 + (x-128)*262144 + (w-128)*4096 + (v-128)*64 + (u-128) ))}"
+	  else
+	    s << z
+	  end
+	end
+	s
+      end  
+    end
+  
+  end
+end

data/lib/java_properties/version.rb

@@ -0,0 +1,9 @@
+module JavaProperties #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 4
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/test/test_data.rb

@@ -0,0 +1,209 @@
+class TestJavaPropertiesData
+
+def self.file1
+  File.dirname(__FILE__) + '/test_files/test1.properties'
+end
+def self.file2
+  File.dirname(__FILE__) + '/test_files/test2.properties'
+end
+def self.file3
+  File.dirname(__FILE__) + '/test_files/test3.properties'
+end
+def self.file4
+  File.dirname(__FILE__) + '/test_files/test4.properties'
+end
+
+def self.properties_contents1
+<<-EOF;
+# Comment 1
+! Comment 2
+item0
+item1 = item1 
+item2 : item2 
+item3   item3
+
+ #Comment 3
+ ! Comment 4
+ 
+ item4=item4
+ item5: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
+
+EOF
+end
+
+def self.properties_contents2
+<<-EOF;
+# Comment 1
+! Comment 2
+
+item1 = item1 again 
+item11 : item11
+item12 : contains \\uAC00 unicode
+item100=
+spaces\\ x : spaces x
+
+EOF
+end
+
+def self.properties_contents3
+<<-EOF;
+# with header
+item100=
+item2=item2
+item8=line\\ 1\\ line\\ 2\\ line\\ 3
+item3=item3
+item9=line\\ 1\\ line\\ 2\\ line\\ 3
+item4=item4
+item1=item1\\ again
+item10=test\\n\\ttestP\\ test\\n\\ttest\\ test\\n\\ttest\\ \\=\\ test
+item5=item5
+item11=item11
+item6=item6
+item12=contains \\uac00 unicode
+spaces\\ x=spaces\\ x
+item0=
+item7=line\\ 1\\ line\\ 2\\ line\\ 3
+EOF
+end
+
+def self.properties_contents4
+<<-EOF;
+# This is a test
+#
+# with a comment
+item100=
+item2=item2
+item8=line\\ 1\\ line\\ 2\\ line\\ 3
+item3=item3
+item9=line\\ 1\\ line\\ 2\\ line\\ 3
+item4=item4
+item1=item1\\ again
+item10=test\\n\\ttestP\\ test\\n\\ttest\\ test\\n\\ttest\\ \\=\\ test
+item5=item5
+item11=item11
+item6=item6
+item12=contains \\uac00 unicode
+spaces\\ x=spaces\\ x
+item0=
+item7=line\\ 1\\ line\\ 2\\ line\\ 3
+EOF
+end
+
+def self.content1
+<<-EOF;
+item0=
+item1=item1
+item10=test\\n\\ttestP\\ test\\n\\ttest\\ test\\n\\ttest\\ \\=\\ test
+item2=item2
+item3=item3
+item4=item4
+item5=item5
+item6=item6
+item7=line\\ 1\\ line\\ 2\\ line\\ 3
+item8=line\\ 1\\ line\\ 2\\ line\\ 3
+item9=line\\ 1\\ line\\ 2\\ line\\ 3
+EOF
+end
+
+def self.content2
+<<-EOF;
+item0=
+item1=item1\\ again
+item10=test\\n\\ttestP\\ test\\n\\ttest\\ test\\n\\ttest\\ \\=\\ test
+item100=
+item11=item11
+item12=contains\\ \\uac00\\ unicode
+item2=item2
+item3=item3
+item4=item4
+item5=item5
+item6=item6
+item7=line\\ 1\\ line\\ 2\\ line\\ 3
+item8=line\\ 1\\ line\\ 2\\ line\\ 3
+item9=line\\ 1\\ line\\ 2\\ line\\ 3
+spaces\\ x=spaces\\ x
+EOF
+end
+
+def self.content3
+<<-EOF;
+# with header
+item0=
+item1=item1\\ again
+item10=test\\n\\ttestP\\ test\\n\\ttest\\ test\\n\\ttest\\ \\=\\ test
+item100=
+item11=item11
+item12=contains\\ \\uac00\\ unicode
+item2=item2
+item3=item3
+item4=item4
+item5=item5
+item6=item6
+item7=line\\ 1\\ line\\ 2\\ line\\ 3
+item8=line\\ 1\\ line\\ 2\\ line\\ 3
+item9=line\\ 1\\ line\\ 2\\ line\\ 3
+spaces\\ x=spaces\\ x
+EOF
+end
+
+def self.content4
+<<-EOF;
+# This is a test
+#
+# with a comment
+item100=
+item2=item2
+item8=line\\ 1\\ line\\ 2\\ line\\ 3
+item3=item3
+item9=line\\ 1\\ line\\ 2\\ line\\ 3
+item4=item4
+item1=item1\\ again
+item10=test\\n\\ttestP\\ test\\n\\ttest\\ test\\n\\ttest\\ \\=\\ test
+item5=item5
+item11=item11
+item6=item6
+item12=contains \\uac00 unicode
+spaces\\ x=spaces\\ x
+item0=
+item7=line\\ 1\\ line\\ 2\\ line\\ 3
+
+# with spacer
+item0=
+item1=item1\\ again
+item10=test\\n\\ttestP\\ test\\n\\ttest\\ test\\n\\ttest\\ \\=\\ test
+item100=
+item11=item11
+item12=contains\\ \\uac00\\ unicode
+item2=item2
+item3=item3
+item4=item4
+item5=item5
+item6=item6
+item7=line\\ 1\\ line\\ 2\\ line\\ 3
+item8=line\\ 1\\ line\\ 2\\ line\\ 3
+item9=line\\ 1\\ line\\ 2\\ line\\ 3
+spaces\\ x=spaces\\ x
+EOF
+end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/java_properties'
+require File.dirname(__FILE__) + '/test_data.rb'
+
+def create_test_files
+  remove_test_files
+  File.open(TestJavaPropertiesData.file1,'w') { |f| f.write TestJavaPropertiesData.properties_contents1 }
+  File.open(TestJavaPropertiesData.file2,'w') { |f| f.write TestJavaPropertiesData.properties_contents2 }
+  #File.open(TestJavaPropertiesData.file3,'w') { |f| f.write TestJavaPropertiesData.properties_contents3 }
+  File.open(TestJavaPropertiesData.file4,'w') { |f| f.write TestJavaPropertiesData.properties_contents4 }
+end
+
+def remove_test_files
+  File.delete(TestJavaPropertiesData.file1) if File.exist?(TestJavaPropertiesData.file1)
+  File.delete(TestJavaPropertiesData.file2) if File.exist?(TestJavaPropertiesData.file2)
+  File.delete(TestJavaPropertiesData.file3) if File.exist?(TestJavaPropertiesData.file3)
+  File.delete(TestJavaPropertiesData.file4) if File.exist?(TestJavaPropertiesData.file4)
+end
+
+def get_file_as_string file_name
+    if File.exist?(file_name) then
+      file_contents = ''
+      File.open(file_name,'r') do |f|
+	while(line = f.gets) do
+	  file_contents += line
+	end
+      end
+      file_contents
+    else
+      nil
+    end
+end

data/test/test_java_properties.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestJavaProperties < Test::Unit::TestCase
+
+  def setup
+    create_test_files
+  end
+  
+  def teardown
+    remove_test_files
+  end
+  
+  def test_truth
+    assert true
+  end
+  
+  def test_can_load_from_file
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file1)
+    assert_equal TestJavaPropertiesData.content1, props.to_s
+  end
+  
+  def test_can_merge_properties_from_two_files
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file1)
+    props.load(TestJavaPropertiesData.file2)
+    assert_equal TestJavaPropertiesData.content2, props.to_s
+  end
+  
+  def test_can_access_property_by_symbol
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file1)
+    assert_equal 'item1', props[:item1]
+  end
+  
+  def test_can_access_property_by_string
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file1)
+    assert_equal 'item1', props['item1']
+  end
+
+  def test_can_access_property_key_with_whitespace
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file2)
+    assert_equal 'spaces x', props['spaces x']
+  end
+
+  def test_can_store_properties_in_file
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file1)
+    props.load(TestJavaPropertiesData.file2)
+    props.store(TestJavaPropertiesData.file3, 'with header')
+    assert( File.exist?(TestJavaPropertiesData.file3) )
+    assert_equal TestJavaPropertiesData.content3, get_file_as_string(TestJavaPropertiesData.file3)
+  end
+
+  def test_append_properties_to_file
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file1)
+    props.load(TestJavaPropertiesData.file2)
+    props.append(TestJavaPropertiesData.file4,'with spacer')
+    assert( File.exist?(TestJavaPropertiesData.file4) )
+    assert_equal TestJavaPropertiesData.content4, get_file_as_string(TestJavaPropertiesData.file4)
+  end
+
+  def test_ignores_hash_comments
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file2)
+    assert_no_match( /Comment 1/, props.to_s)
+  end
+
+  def test_ignores_bang_comments
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file2)
+    assert_no_match( /Comment 2/, props.to_s)
+  end
+
+  def test_sets_key_and_value_seperated_by_equal
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file1)
+    assert_equal 'item1', props[:item1]
+  end
+  
+  def test_sets_key_and_value_seperated_by_colon
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file1)
+    assert_equal 'item2', props[:item2]
+  end
+  
+  def test_sets_key_and_value_seperated_by_whitespace
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file1)
+    assert_equal 'item3', props[:item3]
+  end
+
+  def test_sets_multiline_values
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file1)
+    assert_equal 'line 1 line 2 line 3', props[:item7]
+  end
+  
+  def test_sets_encoded_unicode
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file2)
+    assert_equal "contains \352\260\200 unicode", props[:item12]
+  end
+  
+  def test_sets_backslash_escaped_chars
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file1)
+    assert_equal "test\n\ttestP test\n\ttest test\n\ttest = test", props[:item10]
+  end
+
+  def test_ignores_leading_whitespace
+    props = JavaProperties::Properties.load(TestJavaPropertiesData.file1)
+    assert_equal props[:item7], props[:item8]
+    assert_equal props[:item7], props[:item9]
+  end
+
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: java_properties
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Dwayne Kristjanson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-14 00:00:00 +10:00
+default_executable: 
+dependencies: []
+
+description: |-
+  A class that can read and write to Java properties files that behaves
+  otherwise as a standard ruby Enumerable. The keys to this object can
+  be provided as Strings or Symbols, but internally they are Symbols.
+email: flergl@flergl.net
+executables: 
+- properties2yaml
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- java_properties.gemspec
+- lib/java_properties.rb
+- lib/java_properties/delimiters.rb
+- lib/java_properties/encoding.rb
+- lib/java_properties/parser.rb
+- lib/java_properties/properties-files.rb
+- lib/java_properties/specialchars.rb
+- lib/java_properties/utf8.rb
+- lib/java_properties/version.rb
+- bin/properties2yaml
+- test/test_data.rb
+- test/test_helper.rb
+- test/test_java_properties.rb
+has_rdoc: true
+homepage: http://github.com/flergl/java-properties-for-ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Simple gem for reading/writing Java properties files from Ruby.
+test_files: 
+- test/test_data.rb
+- test/test_helper.rb
+- test/test_java_properties.rb