properties-ruby 0.0.2

data/lib/example/example.rb

@@ -0,0 +1,34 @@
+#
+# Suraj Vijayakumar
+# 20-02-2011
+#
+
+require "properties-ruby"
+require "time"
+require "logeasy"
+
+# Load both the property files.
+p = Utils::Properties.load_from_file("example.properties", true)
+Utils::Properties.load_from_file("override.properties", true, p) # Override...
+
+# Adds the property that was referenced in example.properties.
+# Since this is not a String, it will not be eligible for evaluation. It will still be used as a reference though.
+p.add_property("time_now", Time.now)
+
+# Configuring the root logger so that trace information can be seen.
+console_appender_2 = LogEasy::ConsoleAppender.new # Simple console appender.
+console_appender_2.formatter = LogEasy::Appender::FULL_LOGGER_NAME_FORMATTER
+root_logger = LogEasy::Logger.root_logger # Get the handle to the root logger. The root logger's default level is ALL.
+root_logger.add_appender(console_appender_2) # Add the appenders to the root logger.
+root_logger.change_min_level(LogEasy::Level::DEBUG)
+
+# Access the property values.
+full_name = p.full_name
+author = p.author
+information = p.information
+
+# Print the information.
+puts ""
+puts "App: #{full_name}"
+puts "Author: #{author}"
+puts "Built: #{information}"

data/lib/properties-ruby.rb

@@ -0,0 +1,13 @@
+#
+# Suraj Vijayakumar
+# 19-02-2011
+#
+
+#
+# Properties - Provides support to process java style property files.
+#
+module Utils
+
+  require "utils/properties"
+
+end

data/lib/utils/properties.rb

@@ -0,0 +1,196 @@
+#
+# Suraj Vijayakumar
+# 19-02-2011
+#
+
+require "logeasy"
+
+module Utils
+
+  # Utility class that provides the ability to load java style properties files. The files can also contain references to any property using the ${key} format.
+  # References are evaluated only when a property's value is requested.
+  #
+  # Example:
+  #
+  # Load property files.
+  # p = Utils::Properties.load_from_file("example.properties", true)
+  # Utils::Properties.load_from_file("override.properties", true, p) # Override...
+  #
+  # Adds the property that was referenced in example.properties.
+  # Since this is not a String, it will not be eligible for evaluation. It will still be used as a reference though.
+  # p.add_property("time_now", Time.now)
+  #
+  # Configuring the root logger so that trace information can be seen.
+  # console_appender_2 = LogEasy::ConsoleAppender.new # Simple console appender.
+  # console_appender_2.formatter = LogEasy::Appender::FULL_LOGGER_NAME_FORMATTER
+  # root_logger = LogEasy::Logger.root_logger # Get the handle to the root logger. The root logger's default level is ALL.
+  # root_logger.add_appender(console_appender_2) # Add the appenders to the root logger.
+  #
+  # Access the property values.
+  # full_name = p.full_name
+  # author = p.author
+  # information = p.information
+  #
+  # Print the information.
+  # puts "App: #{full_name}"
+  # puts "Author: #{author}"
+  # puts "Built: #{information}"
+
+  class Properties
+
+    @@logger = LogEasy::Logger.get_logger(name)
+
+    # Creates a new Properties object by loading the specified file.
+    # Optionally an existing properties object can be passed in to put the loaded properties into. Existing properties with the same key will be overwritten.
+    # Also the evaluate properties flag can be turned off if it is not required.
+    #
+    # Comments (lines starting with '#') and empty lines are skipped.
+    #
+    # Returns => Properties
+    def Properties.load_from_file(file_path, evaluate_properties = true, existing_properties = Properties.new(evaluate_properties))
+      raise "Properties file not found!" if not File.exists?(file_path)
+      # Read each line, check if it is empty, a comment or starts with an =. If it does then skip it and go to the next line.
+      File.open(file_path, 'r') do |file|
+        line_number = 0
+        file.read.each_line do |line|
+          line.strip!
+          line_number += 1
+          # Skip empty / comment lines.
+          next if (line.length == 0 or line[0] == ?#)
+          # Exception for invalid first character.
+          raise "Invalid property format on line #{line_number}." if line[0] == ?=
+
+          i = line.index("=")
+          if i
+            # Extract the key and value.
+            name = line[0..i - 1].strip
+            value = line[i + 1..-1].strip
+            @@logger.trace("Property '#{name}=#{value} added.")
+            existing_properties.add_property(name, value)
+          else
+            # Not a key-value pair.
+            raise "Invalid property format on line #{line_number}."
+          end
+        end
+      end
+      # Return the updated / new properties.
+      existing_properties
+    end
+
+    # Saves a properties value. If a property with this name already exists, it is replaced with this one. Its evaluated flag is also reset.
+    # The name is converted to a Symbol and used as the key.
+    def add_property(name, value)
+      property = Property.new(name, value)
+      key = name.to_sym
+      props[key] = property
+    end
+
+    # Force evaluation of all properties right now.
+    def evaluate_all
+      props.each_key { |key| get(key, true) }
+    end
+
+    # Gets the value (as a String) of a property. The key used must be a Symbol.
+    # If 'force_evaluate' is set to true, the property (and all referenced properties) will be re-evaluated.
+    # If 'evaluate_property' is set to true all nested references will be evaluated even if the global 'evaluate_properties' flag is false.
+    #
+    # Returns => String
+    def get(key, force_evaluate = false, evaluate_property = evaluate_properties)
+      raise "Property '#{key}' not found!" if not props.has_key?(key)
+      # The property exists. Get it. Evaluate it if required.
+      property = props[key]
+      property.evaluate(force_evaluate) do |ref_key|
+        next false if not props.has_key?(ref_key)
+        next get(ref_key, force_evaluate, evaluate_property)
+      end if evaluate_property
+      # Return the value of the fully evaluated property.
+      property.evaluated_value
+    end
+
+    private
+
+    # Flag to indicate if properties should be evaluated. This can be overridden on a per property basis in the 'get' method.
+    attr_reader :evaluate_properties
+    attr_reader :props
+
+    # New empty properties.
+    def initialize(evaluate_properties)
+      @evaluate_properties = evaluate_properties
+      @props = Hash.new
+    end
+
+    # Property values can be accessed directly using the name of the property. i.e. p.app_name (where app_name is the name of the property).
+    def method_missing(symbol, *args, &block)
+      # Use 'get' to get the property's value. It will raise an exception if it does not exist.
+      get(symbol, *args)
+    end
+
+  end
+
+  # Represents a single property value from a properties file.
+  class Property
+
+    @@logger = LogEasy::Logger.get_logger(name)
+
+    REFERENCE_REGEX = /\${[^}]+}/
+
+    attr_reader :name
+    attr_reader :value
+    attr_reader :evaluated_value
+
+    # Creates a new property.
+    def initialize(name, value)
+      @name = name
+      @value = value
+      @evaluated_value = value
+      @evaluating = false
+      @evaluated = false
+    end
+
+    # Each reference present in this property is passed to the given block. If no block is given the method returns immediately.
+    # The method will return immediately if this property has already been evaluated too.
+    #
+    # If a block is given its result replaces each reference.
+    # A false may be returned to keep the original reference as is.
+    def evaluate(force_evaluate = false)
+      if not force_evaluate and self.evaluated
+        # Property has already been evaluated. Return immediately.
+        # The property has been evaluated. Do not evaluate again.
+        @@logger.fine("Already evaluated '#{name}'.")
+      elsif self.evaluating
+        # The property is currently being evaluated and has been referenced again. Circular reference.
+        raise "Circular reference detected starting at property #{name}=#{value}."
+      elsif block_given?
+        # This property is being evaluated. If a call to evaluate is made while evaluating is true an exception is raised.
+        @@logger.fine("Evaluating '#{name}'...")
+        self.evaluating = true
+        self.evaluated_value = value.gsub(REFERENCE_REGEX) do |match|
+          # Extract the key from the ${key} match and pass it to the block. If there is no block then do nothing.
+          key = match[2..-2].to_sym
+          @@logger.fine("Found reference '#{key}' in '#{name}'.")
+          replacement = yield key
+          # Return the original match as is if the replacement value is false.
+          next match if not replacement
+          # Otherwise return the replacement.
+          @@logger.fine("Replacing '#{key}' in '#{name}' with '#{replacement}'.")
+          next replacement
+        end if value.instance_of?(String) # Only do this for Strings.
+        # The property has been evaluated. Do not evaluate again.
+        @@logger.debug("Final value for '#{name}' is '#{evaluated_value}'.")
+        self.evaluating = false
+        self.evaluated = true
+      end
+    end
+
+    protected
+
+    # Flag to indicate that this property is currently being evaluated.
+    attr_accessor :evaluating
+    # Flag to indicate that this property has been fully evaluated.
+    attr_accessor :evaluated
+    # The evaluated value. Calculated by the 'evaluate' method.
+    attr_writer :evaluated_value
+
+  end
+
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: properties-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Suraj Vijayakumar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-02-20 00:00:00.000000000 +05:30
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logeasy
+  requirement: &22772172 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *22772172
+description: A simple properties file API. Support for Java style properties file.
+  The property files can contain references to other properties using the ${<key_name>}
+  format. Access their values directly using p.prop_name.
+email: vijayakumar.suraj@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/properties-ruby.rb
+- lib/utils/properties.rb
+- lib/example/example.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/properties-ruby/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: properties-ruby
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A simple properties file API.
+test_files: []