stringformat 0.0.1

data/lib/LICENSE

@@ -0,0 +1,10 @@
+Copyright (c) 2007 Erik Hollensbe
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    * Neither the name of the NGSLib nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/stringformat.rb

@@ -0,0 +1,164 @@
+#
+# StringFormat: A string format library that's programmable.
+#
+# Synopsis:
+#
+#   # up-front interface
+#   f = StringFormat.new(
+#       "d" => proc { |item, num| num + ' ' + item } # %0.2d
+#       "s"  => proc { |item, num| item } # %s
+#   )
+#
+#   s = f.new_string "my_string %s"
+#
+#   # StringFormat is just a subclass of String, so this works:
+# 
+#   s % "hello there" # => "my_string hello there"
+#
+#   # something more complex (using base-class String methods): 
+#
+#   s[s.length - 2 .. s.length - 1] % "something new" # => "something new"
+#   
+#   # add iteratively -- works with generated Format#new_string objects as well
+#   f.add_format("f") do |item, num|
+#       num + ' ' + item
+#   end
+#
+#   f.del_format("d")
+#
+#   # add a format that does not require an argument:
+#   f.add_format("e") do
+#       Date.new.strftime("%s")
+#   end
+#
+#   # and use it like such:
+#
+#   s = f.clone("string %e %f")
+#   s % [1.2] => "string 12345667787 1.2"
+#   s = f.clone("string %e")
+#   s % nil => "string 12345667787"
+#
+#   # these also work on the string objects themselves, so you can add on for specific strings:
+#
+#   s.add_format("s") do |item, num|
+#       "monkeys around"
+#   end
+#
+#   s % "foobar" # => "my_string monkeys around"
+#
+#   An improperly formatted string (one that is passed too many or too little
+#   arguments for what is expected) will raise a StringFormat::FormatError
+#   exception.
+#
+# Author:: Erik Hollensbe <erik@hollensbe.org>
+#--
+# TODO LIST
+#
+# Spec conflict checking
+#++
+
+class StringFormat < String
+
+    VERSION = "0.0.1"
+
+    class FormatError < Exception
+    end
+
+    attr_accessor :format_leader
+
+    # takes a listing of specifications and procs. For a description of how to
+    # define formats, see Format#add_format.
+    def initialize(*args)
+        @format_table = args[0] || { }
+        @format_table.to_hash unless @format_table.respond_to? :keys
+        @format_leader = "%"
+
+        super ""
+    end
+
+    # Factory method for producing new strings. Strings will be of class Format
+    # and contain all the existing Format definitions at the time this is called.
+    # 
+    # StringFormat#clone is an alias for this method.
+    def new_string(s="")
+        retval = self.dup
+        retval.replace(s)
+        return retval
+    end
+
+    # Takes a spec and a block to process.
+    #
+    # "Specs" are one character strings that get transformed into a standard
+    # printf()-style format string. The "spec" actually gets used as a
+    # combination of the format_leader (usually "%"), any following
+    # numeric-like values, and the spec. f.e., the spec "s" would match "%s",
+    # or "%03s" or "%1.3s".
+    #
+    # The block (or in the case of Format.new, the proc) takes two explicit
+    # arguments. First, the item that is to be formatted, and second is the
+    # numeric-like portion of the format, to be utilized by the callback during 
+    # processing. The return value (last value evaluated) will be used as the
+    # replacement for the format string.
+    #
+    # If the block does not take any arguments, this format does not take any
+    # arguments and it will be skipped in the argument list.
+    #
+    # Please see the top-level documentation for the Format class for examples.
+    #
+    def add_format(spec, &block)
+        @format_table[spec] = block    
+    end
+
+    # Removes a format, given a spec.
+    def del_format(spec)
+        @format_table.delete spec
+    end
+
+    # Processes the format and returns a string result. Items passed to this call will
+    # correspond to the formats in order from left to right in the string.
+    # 
+    # An improperly formatted string (one that is passed too many or too
+    # little required arguments for what is expected) will raise a
+    # StringFormat::FormatError exception.
+    def format(arg)
+        arg = [arg] unless arg.kind_of? Array
+
+        if arg == [nil]
+            arg = []
+        end
+
+        count = 0
+
+        new_string = self.dup
+        scan(/#{Regexp.quote(@format_leader)}[\d.]*\w/).each do |format|
+            tabled_format = format.sub(/^#{Regexp.quote(@format_leader)}[\d.]*/, '')
+            unless @format_table[tabled_format]
+                raise FormatError, "Invalid format passed in format string"
+            end
+
+            num = nil
+
+            if matches = /([\d.]+)/.match(format)
+                num = matches[1]
+            end
+
+            proc_args = []
+            if @format_table[tabled_format].arity == 2
+                proc_args = [arg[count], num]
+                count += 1
+            end
+
+            new_string.sub!(/#{Regexp.quote(format)}/, @format_table[tabled_format].call(*proc_args).to_s)
+        end
+
+        if arg.length != count
+            raise FormatError, "Not enough formats: #{count} processed when #{arg.length} arguments were attempted"
+        end
+
+        return new_string
+    end
+
+    alias :clone :new_string
+    alias :% :format
+    alias :string= :replace
+end

data/test/tc_stringformat.rb

@@ -0,0 +1,89 @@
+require 'test/unit'
+require 'stringformat'
+require 'date'
+require 'time'
+
+class StringFormatTest < Test::Unit::TestCase
+
+    # test a basic "%s" style stringformat.
+    def test_01_basic_format
+        f = StringFormat.new(
+           "s" => proc do |item, num|
+            if num == num.to_i
+                item[0..num.to_i - 1]
+            elsif num 
+                snum = num.to_s
+                left, right = snum.split(/\./).collect { |x| x.to_i }
+                new_string = ""
+
+                if left && left > 0
+                    new_string += item[0..left - 1]
+                end
+
+                if right && right < item.length
+                    new_string += item[item.length - right..item.length-1]
+                end
+                new_string
+            else
+                item
+            end
+           end
+        )
+
+        s = f.clone("string %s %s")
+
+        assert_equal(s % %w(asdf asdf2), "string asdf asdf2")
+
+        s = f.new_string("string %s %s")
+
+        assert_equal(s % %w(asdf asdf2), "string asdf asdf2")
+
+        # ensure that the formatted strings are copies and not modified references
+        assert_not_equal(s % %w(asdf asdf2), s)
+
+        # ensure that a lack of enough (or too many) formats raises an error
+        assert_raise(StringFormat::FormatError) do
+            s % %w(asdf)
+        end
+
+        assert_raise(StringFormat::FormatError) do
+            s % %w(asdf asdf adsf)
+        end
+    end
+
+    # test if the base class string methods are still working.
+    def test_02_string_methods
+        f = StringFormat.new()
+        s = f.new_string "blah"
+
+        assert_equal(s, s.to_s)
+        assert_equal(s + "foo", "#{s}foo")
+        assert_equal(s.sub(/blah/, 'foo'), "foo")
+    end
+
+    # test more esoteric formats.
+    def test_03_fancy_formats
+        # here's some time formats - test our arity functionality
+        f = StringFormat.new(
+            't' => proc do
+                Time.new.rfc2822
+            end,
+            'e' => proc do
+                Date.new.strftime("%s")
+            end,
+            's' => proc do |item, num|
+                item
+            end
+        )
+
+        assert_nothing_raised do
+            s = f.clone("epoch %e") % nil
+            s = f.clone("epoch %e %s") % ["asdf"] 
+        end
+
+        assert_equal(f.clone("epoch %e") % nil, "epoch #{Date.new.strftime('%s')}")
+        assert_equal(f.clone("epoch %e %s") % ["asdf"], "epoch #{Date.new.strftime('%s')} asdf")
+        assert_equal(f.clone("epoch %e %s %e %s") % %w(asdf asdf2),  "epoch #{Date.new.strftime('%s')} asdf #{Date.new.strftime('%s')} asdf2")
+        assert_equal(f.clone("rfc2822 %t") % nil, "rfc2822 #{Time.new.rfc2822}")
+    end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: stringformat
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-09-07 00:00:00 -07:00
+summary: StringFormat is a string formatter library that's intended to be highly flexible
+require_paths: 
+- lib
+email: erik@hollensbe.com
+homepage: http://rubyforge.org/projects/ngslib
+rubyforge_project: ngslib
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Erik Hollensbe
+files: 
+- lib/LICENSE
+- lib/stringformat.rb
+- test/tc_stringformat.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: 
+- lib/LICENSE
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+