dot-properties 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,14 @@
+##########################################################################
+# Copyright 2013 Michael B. Klein
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

data/README.md

@@ -0,0 +1,66 @@
+# DotProperties [![Build Status](https://secure.travis-ci.org/mbklein/dot-properties.png)](http://travis-ci.org/mbklein/dot-properties)
+
+Reads and writes [Java .properties files](http://en.wikipedia.org/wiki/.properties) like a champ.
+
+* Intuitive, Hash-like access. Anywhere it makes sense to act like a Hash, it acts like a Hash.
+* Won't clobber comments and blank lines (unless you want to).
+* Will preserve original delimiters for each value (unless you normalize them).
+* Supports all the delimiters (whitespace, `=`, `:`).
+* Supports both comment prefixes (`#`, `!`).
+* Supports expansion of inline `${property}` references.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dot_properties'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dot_properties
+
+## Usage
+
+    require 'dot_properties'
+
+    # Load a .properties file
+    props = DotProperties.new('sample.properties')
+
+    # Get a value
+    props['foo']
+
+    # Set a value
+    props['foo'] = 'bar'
+
+    # Convert key/value pairs to a hash
+    props.to_h
+
+    # Or just let it act like a hash 
+    props.each_pair { |key,value| puts "#{key} :: #{value}" }
+
+    # Remove all comments/blanks/both
+    props.strip_comments!
+    props.strip_blanks!
+    props.compact!
+
+    # Write a .properties file
+    File.open('output.properties','w') { |out| out.write(props.to_s) }
+
+See the spec tests and fixture data for more examples.
+
+## Known Issues
+
+* Multiline values will be converted to single line on output
+
+## History
+
+- <b>0.1.0</b> - Initial release
+
+## Copyright
+
+Copyright (c) 2013 Michael B. Klein. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,19 @@
+require "bundler/gem_tasks"
+require 'rdoc/task'
+require 'dot_properties/version'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = FileList['./spec/**/*_spec.rb']
+end
+  
+task :default => :spec
+
+RDoc::Task.new do |rdoc|
+  version = DotProperties::VERSION
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "dot-properties #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/dot-properties.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dot_properties/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dot-properties"
+  spec.version       = DotProperties::VERSION
+  spec.authors       = ["Michael B. Klein"]
+  spec.email         = ["mbklein@gmail.com"]
+  spec.description   = %q{Java-style .properties file manipulation with a light touch}
+  spec.summary       = %q{Read/write .properties files, respecting comments and existing formatting as much as possible}
+  spec.homepage      = "https://github.com/mbklein/dot-properties"
+  spec.license       = "APACHE2"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rdoc", ">= 2.4.2"
+  spec.add_development_dependency "simplecov"
+end

data/lib/dot-properties.rb

@@ -0,0 +1 @@
+require 'dot_properties'

data/lib/dot_properties.rb

@@ -0,0 +1,144 @@
+require "dot_properties/version"
+
+class DotProperties
+  extend Forwardable
+
+  def_delegators :to_h, :each, :each_key, :each_pair, :each_value, :empty?, 
+                 :fetch, :has_key?, :has_value?, :include?, :inspect, :invert,
+                 :key, :key?, :keys, :length, :member?, :merge, :reject,
+                 :select, :size, :value?, :values, :values_at
+
+
+  # @!attribute [rw] auto_expand
+  #   @return [Boolean] Whether to expand resolvable variables within values on retrieval (default: +true+)
+  # @!attribute [rw] default_delimiter
+  #   @return [String] The delimiter to use when adding new properties or when calling +normalize_delimiters!+ (default: '=')
+  attr_accessor :auto_expand, :default_delimiter
+
+  def initialize(lines=[])
+    @content = lines.collect { |item| tokenize(item) }
+    @auto_expand = true
+    @default_delimiter = '='
+  end
+
+  def self.load(file)
+    self.parse(File.read(file))
+  end
+
+  def self.parse(str)
+    self.new(str.split(/(?<!\\)\n/))
+  end
+
+  def get(key, expand=@auto_expand)
+    item = find_key(key)
+    value = (item && item[:value]) || nil
+    if value and expand
+      value = value.gsub(/\$\{(.+?)\}/) { |v| has_key?($1) ? get($1,true) : v }
+    end
+    return value
+  end
+
+  def set(key, value)
+    item = find_key(key)
+    if item
+      item[:value] = value
+    else
+      @content << { type: :value, key: key, delimiter: default_delimiter, value: value }
+    end
+    return value
+  end
+
+  def [](key)
+    get(key)
+  end
+
+  def []=(key,value)
+    set(key, value)
+  end
+
+  def <<(item)
+    @content << tokenize(item)
+  end
+
+  def delete(key)
+    value = get(key)
+    @content.reject! { |item| item[:type] == :value and item[:key] == key }
+    return value
+  end
+
+  def inspect
+    to_h.inspect
+  end
+
+  # Strip all comments and blank lines, leaving only values
+  def compact!
+    @content.reject! { |item| item[:type] != :value }
+  end
+
+  # Replace all delimiters with +default_delimiter+
+  def normalize_delimiters!
+    @content.each { |item| item[:delimiter] = default_delimiter if item[:type] == :value }
+  end
+
+  # Strip all blank lines, leaving only comments and values
+  def strip_blanks!
+    @content.reject! { |item| item[:type] == :blank }
+  end
+
+  # Strip all comments, leaving only blank lines and values
+  def strip_comments!
+    @content.reject! { |item| item[:type] == :comment }
+  end
+
+  # The assembled .properties file as an array of lines
+  def to_a
+    @content.collect { |item| assemble(item) }
+  end
+
+  # All properties as a hash
+  def to_h
+    Hash[@content.select { |item| item[:type] == :value }.collect { |item| item.values_at(:key,:value) }]
+  end
+  
+  # The assembled .properties file as a string
+  def to_s
+    to_a.join("\n")
+  end
+
+  protected
+  def assemble(item)
+    if item[:type] == :value
+      if item[:value].nil? or item[:value].empty?
+        escape(item[:key])
+      else
+        "#{escape(item[:key])}#{item[:delimiter]}#{item[:value]}"
+      end
+    else
+      item[:value]
+    end
+  end
+
+  def tokenize(item)
+    if item =~ /^\s*[#!]/
+      { type: :comment, value: item }
+    elsif item =~ /^\s*$/
+      { type: :blank, value: item }
+    else
+      key, delimiter, value = item.split /(\s*(?<!\\)[\s:=]\s*)/, 2
+      { type: :value, key: unescape(key), delimiter: delimiter, value: value.to_s.gsub(/\\\n\s*/,'') }
+    end
+  end
+
+  def find_key(key)
+    @content.find { |item| item[:type] == :value and item[:key] == key }
+  end
+
+  def escape(key)
+    key.gsub(/[\s:=]/) { |m| "\\#{m}" }
+  end
+
+  def unescape(key)
+    key.gsub(/\\/,'')
+  end
+
+end

data/lib/dot_properties/version.rb

@@ -0,0 +1,3 @@
+class DotProperties
+  VERSION = "0.1.0"
+end

data/spec/dot_properties_spec.rb

@@ -0,0 +1,127 @@
+if defined?(RUBY_ENGINE) and (RUBY_ENGINE == 'ruby') and (RUBY_VERSION >= '1.9')
+  require 'simplecov'
+  SimpleCov.start
+end
+$:.push(File.join(File.dirname(__FILE__),'..','lib'))
+
+require 'dot_properties'
+
+describe DotProperties do
+  let(:propfile) { File.expand_path('../fixtures/sample.properties', __FILE__) }
+  subject { DotProperties.load(propfile) }
+
+  let(:properties) { 16 }
+  let(:comments)   { 14 }
+  let(:blanks)     {  8 }
+
+  it { should be_an_instance_of(DotProperties) }
+
+  describe "values" do
+    it "should have the right number of properties" do
+      expect(subject.keys.length).to eq(16)
+    end
+
+    it "should have the right values" do
+      expect(subject['foo.normal']).to eq('bar.normal.value')
+      expect(subject['bar.normal']).to eq('baz.normal.value')
+      expect(subject['foo.whitespace']).to eq('bar.whitespace.value')
+      expect(subject['foo.extraspace']).to eq('bar.extraspace.value')
+      expect(subject['bar.extraspace']).to eq('baz.extraspace.value')
+      expect(subject['foo bar']).to eq('bar baz')
+      expect(subject['bar:baz']).to eq('baz quux')
+      expect(subject['foo bar:baz= quux']).to eq('this is getting ridiculous')
+      expect(subject['lots of fruit']).to eq('apple, peach, kiwi, mango, banana, strawberry, raspberry')
+      expect(subject['some.veggies']).to eq('carrot, potato, broccoli')
+      expect(subject['foo.empty']).to be_empty
+      expect(subject['bar.empty']).to be_empty
+      expect(subject['baz.empty']).to be_empty
+      expect(subject['quux.empty']).to be_empty
+    end
+
+    it "#auto_expand" do
+      expect(subject['present']).to eq('This value contains two resolvable references, bar.normal.value and baz.extraspace.value')
+      expect(subject['missing']).to eq('This value contains one resolvable reference, bar.normal.value, and one unresolvable reference, ${quux.missing}')
+    end
+
+    it "#auto_expand=false" do
+      subject.auto_expand = false
+      expect(subject['present']).to eq('This value contains two resolvable references, ${foo.normal} and ${bar.extraspace}')
+      expect(subject['missing']).to eq('This value contains one resolvable reference, ${foo.normal}, and one unresolvable reference, ${quux.missing}')
+    end
+  end
+
+  describe "delimiters" do
+    it "should retain original delimiters and spacing" do
+      expect(subject.to_a.find { |l| l =~ /^foo\.extraspace/ }).to eq('foo.extraspace   = bar.extraspace.value')
+    end
+
+    it "should retain delimiters even after #set" do
+      subject['bar.extraspace'] = 'new value'
+      expect(subject.to_a.find { |l| l =~ /^bar\.extraspace/ }).to eq('bar.extraspace :   new value')
+    end
+
+    it "should #normalize delimiters!" do
+      subject.normalize_delimiters!
+      expect(subject.to_a.find { |l| l =~ /^foo\.extraspace/ }).to eq('foo.extraspace=bar.extraspace.value')
+    end
+
+    it "#default_delimiter" do
+      subject.default_delimiter = ' : '
+      subject['new key'] = 'new value'
+      expect(subject.to_a.last).to eq('new\\ key : new value')
+    end
+  end
+
+  describe "comments and blanks" do
+    it "should leave comments and blanks alone" do
+      expect(subject.to_a.length).to eq(properties + comments + blanks)
+    end
+
+    it "should strip comments" do
+      subject.strip_comments!
+      expect(subject.to_a.length).to eq(properties + blanks)
+    end
+
+    it "should strip blanks" do
+      subject.strip_blanks!
+      expect(subject.to_a.length).to eq(properties + comments)
+    end
+
+    it "should strip comments and blanks" do
+      subject.compact!
+      expect(subject.to_a.length).to eq(properties)
+    end
+  end
+
+  describe "serialization" do
+    it "#inspect" do
+      expect(subject.inspect).to match(/\{.+\}/)
+    end
+
+    it "should round-trip" do
+      hash = subject.to_h.dup
+      array = subject.to_a
+      duplicate = DotProperties.parse(subject.to_s)
+      expect(duplicate.to_h).to eq(hash)
+      expect(duplicate.to_a).to eq(array)
+    end
+  end
+
+  describe "additional methods" do
+    it "#<<" do
+      subject << ""
+      subject << "# This is a comment on some.new.property"
+      subject << "some.new.property = some.new.value"
+      expect(subject['some.new.property']).to eq('some.new.value')
+      expect(subject.to_h.length).to eq(properties + 1)
+      expect(subject.to_a.length).to eq(properties + comments + blanks + 3)
+    end
+
+    it "#delete" do
+      expect(subject.delete('foo bar')).to eq('bar baz')
+      expect(subject).not_to have_key('foo bar')
+    end
+  end
+
+
+end

data/spec/fixtures/sample.properties

@@ -0,0 +1,42 @@
+# Sample .properties file for dot-properties specs
+# It has 16 properties, 14 comments, and 8 blank lines
+# It starts with some comments
+
+# And then has a blank line
+! followed by some other comments
+       # using various comment markers and 
+    ! spacing
+
+# Normal properties
+foo.normal=bar.normal.value
+bar.normal:baz.normal.value
+
+# Whitespace-delimited properties
+foo.whitespace     bar.whitespace.value
+
+# Whitespace surrounding delimiters
+foo.extraspace   = bar.extraspace.value
+bar.extraspace :   baz.extraspace.value
+
+# Escaped characters in keys
+foo\ bar=bar baz
+bar\:baz  : baz quux
+foo\ bar\:baz\=\ quux      this is getting ridiculous
+
+# Multiline values
+lots\ of\ fruit           apple, peach, kiwi, \
+                          mango, banana, strawberry, \
+                          raspberry
+some.veggies=carrot, \
+             potato, \
+        broccoli
+
+# Empty values
+foo.empty
+bar.empty=
+baz.empty:
+quux.empty =
+
+# References
+present = This value contains two resolvable references, ${foo.normal} and ${bar.extraspace}
+missing = This value contains one resolvable reference, ${foo.normal}, and one unresolvable reference, ${quux.missing}

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: dot-properties
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Michael B. Klein
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.4.2
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Java-style .properties file manipulation with a light touch
+email:
+- mbklein@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dot-properties.gemspec
+- lib/dot-properties.rb
+- lib/dot_properties.rb
+- lib/dot_properties/version.rb
+- spec/dot_properties_spec.rb
+- spec/fixtures/sample.properties
+homepage: https://github.com/mbklein/dot-properties
+licenses:
+- APACHE2
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1306251061274732022
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1306251061274732022
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Read/write .properties files, respecting comments and existing formatting
+  as much as possible
+test_files:
+- spec/dot_properties_spec.rb
+- spec/fixtures/sample.properties