string_formatter 1.0.0 → 2.0.1

data/lib/format_evaluator.rb

@@ -0,0 +1,62 @@
+class FormatEvaluator
+
+  ################
+  #              #
+  # Declarations #
+  #              #
+  ################
+  
+  attr_reader :evaluations
+
+  ###############
+  #             #
+  # Constructor #
+  #             #
+  ###############
+  
+  def initialize(evaluations)
+    @evaluations = evaluations
+  end
+
+  ####################
+  #                  #
+  # Instance Methods #
+  #                  #
+  ####################
+  
+  def evaluate(object, parsed_components)
+    evaluated = parsed_components.map do |component|
+      evaluate_component(object, component)
+    end
+
+    evaluated.join ''
+  end
+
+  protected
+
+    def behavior_for(format)
+      format = format.to_s
+
+      evaluations.fetch(format) do
+        evaluations[format] = ->() { format }
+      end
+    end
+
+    def evaluate_component(object, component)
+      case component
+        when String
+          component
+        when Array
+          evaluate_format(object, *component)
+        else
+          raise ArgumentError, component.inspect
+      end
+    end
+
+    def evaluate_format(object, format, *options)
+      behavior = behavior_for(format)
+
+      object.instance_exec(*options, &behavior)
+    end
+
+end

data/lib/format_parser.rb

@@ -0,0 +1,91 @@
+class FormatParser
+
+  ################
+  #              #
+  # Declarations #
+  #              #
+  ################
+  
+  attr_reader :escape_sequences, :escape_options
+
+  ###############
+  #             #
+  # Constructor #
+  #             #
+  ###############
+  
+  def initialize(escape_sequences, escape_options)
+    @escape_sequences = escape_sequences
+    @escape_options   = escape_options
+  end
+
+  ####################
+  #                  #
+  # Instance Methods #
+  #                  #
+  ####################
+  
+  def parse(string)
+    split_string = string.scan(string_format_regex)
+
+    split_string.map { |match| extract_escape(match) }
+  end
+
+  protected
+
+    def escape_regexp(escape)
+      escape_option = escape_options[escape]
+      clean_escape  = Regexp.escape(escape)
+
+      escape_option.to_s + clean_escape
+    end
+
+    def escape_regex_fragment
+      fragments = sorted_sequences.map { |escape| escape_regexp(escape) }
+      fragments << '.'
+      fragments.join '|'
+    end
+
+    def explicit_sequences
+      escape_sequences.select do |escape|
+        escape.length > 1 || escape_options[escape]
+      end
+    end
+
+    def extract_escape(match)
+      if match[0]
+        match[0]
+      else
+        extract_options match[1]
+      end
+    end
+
+    def extract_options(match)
+      return [match] if match.length == 1
+
+      matching_escape = explicit_sequences.detect do |escape|
+        match =~ /#{Regexp.escape(escape)}$/
+      end
+      
+      if match == matching_escape
+        [match]
+      else
+        options = match[0...-matching_escape.length]
+
+        [matching_escape, options]
+      end
+    end
+    
+    def multichar_sequences
+      escape_sequences.select { |seq| seq.length > 1 }
+    end
+
+    def sorted_sequences
+      explicit_sequences.sort_by(&:length).reverse
+    end
+
+    def string_format_regex
+      /([^%]+)|%(#{ escape_regex_fragment })/
+    end
+
+end

data/lib/formattable.rb

@@ -0,0 +1,59 @@
+module Formattable
+
+  module ClassMethods
+
+    def define_format_string(meth, options = {}, &block)
+      base_class = options.fetch(:with) { StringFormatter }
+      klass      = formatter_class(base_class, block)
+
+      set_formatter_for meth, klass
+      
+      define_formatter_method(meth)
+
+      define_default_alias(meth) if options[:default]
+    end
+
+    def formatter_for(meth)
+      @formatters ||= {}
+      @formatters[meth]
+    end
+
+    protected
+
+      def define_default_alias(meth)
+        alias_method :%, meth
+      end
+
+      def define_formatter_method(meth)
+        define_method(meth) do |format_string|
+          formatter = self.class.formatter_for meth
+          formatter.format(self, format_string)
+        end
+      end
+
+      def formatter_class(superclass, inline_definition)
+        if inline_definition
+          Class.new(superclass, &inline_definition)
+        else
+          superclass
+        end
+      end
+
+      def set_formatter_for(meth, formatter_class)
+        @formatters ||= {}
+        @formatters[meth] = formatter_class.new
+      end
+
+  end
+
+  ##################
+  #                #
+  # Module Methods #
+  #                #
+  ##################
+  
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+end

data/lib/string_formatter.rb

@@ -1,76 +1,64 @@
+require './lib/formattable'
+require './lib/format_parser'
+require './lib/format_evaluator'
+
 class StringFormatter
 
-  ################
-  #              #
-  # Declarations #
-  #              #
-  ################
-  
-  VERSION = "1.0.0"
-  
   #############
   #           #
   # Constants #
   #           #
   #############
   
-  STRING_FORMAT_REGEX = /[^%]+|%./
-  
-  SPECIAL_CHARACTER_FORMATS = {
-    'ampersand' => '&',
-    'at' => '@',
-    'backslash' => '\\',
-    'backtick' => '`',
-    'bang' => '!',
-    'caret' => '^',
-    'cash' => '$',
-    'colon' => ':',
-    'comma' => ',',
-    'dash' => '-',
-    'double_quote' => '"',
-    'eight' => '8',
-    'equals' => '=',
-    'five' => '5',
-    'four' => '4',
-    'hash' => '#',
-    'left_bracket' => '[',
-    'left_chevron' => '<',
-    'left_paren' => '(',
-    'left_stache' => '{',
-    'nine' => '9',
-    'one' => '1',
-    'percent' => '%', # Defining this method is not recommended
-    'period' => '.',
-    'pipe' => '|',
-    'plus' => '+',
-    'quote' => "'",
+  PUNCTUATION_FORMATS = {
+    'ampersand'     => '&',
+    'at'            => '@',
+    'backslash'     => '\\',
+    'backtick'      => '`',
+    'bang'          => '!',
+    'caret'         => '^',
+    'cash'          => '$',
+    'colon'         => ':',
+    'comma'         => ',',
+    'dash'          => '-',
+    'double_quote'  => '"',
+    'eight'         => '8',
+    'equals'        => '=',
+    'five'          => '5',
+    'four'          => '4',
+    'hash'          => '#',
+    'left_brace'    => '{',
+    'left_bracket'  => '[',
+    'left_chevron'  => '<',
+    'left_paren'    => '(',
+    'left_shovel'   => '<<',
+    'left_stache'   => '{{',
+    'nine'          => '9',
+    'one'           => '1',
+    # Defining this method is not recommended:
+    'percent'       => '%',
+    'period'        => '.',
+    'pipe'          => '|',
+    'plus'          => '+',
+    'quote'         => "'",
+    'right_brace'   => '}',
     'right_bracket' => ']',
     'right_chevron' => '>',
-    'right_paren' => ')',
-    'right_stache' => '}',
-    'semicolon' => ';',
-    'seven' => '7',
-    'six' => '6',
-    'slash' => '/',
-    'splat' => '*',
-    'three' => '3',
-    'tilde' => '~',
-    'two' => '2',
-    'underscore' => '_',
-    'what' => '?',
-    'zero' => '0'
-  }
-  
-  ###############
-  #             #
-  # Constructor #
-  #             #
-  ###############
-  
-  def initialize(object, format_string)
-    @object = object
-    @format_string = format_string
-  end
+    'right_paren'   => ')',
+    'right_shovel'  => '>>',
+    'right_stache'  => '}}',
+    'semicolon'     => ';',
+    'seven'         => '7',
+    'six'           => '6',
+    'slash'         => '/',
+    'splat'         => '*',
+    'three'         => '3',
+    'tilde'         => '~',
+    'two'           => '2',
+    'underscore'    => '_',
+    'what'          => '?',
+    'zero'          => '0'
+  }.freeze
   
   #################
   #               #
@@ -78,55 +66,90 @@ class StringFormatter
   #               #
   #################
   
-  def self.escape_character(object, char)
-    escape_method = @escapes[char]
-    escape_method ? escape_method[object] : char
+  def self.method_missing(escape_sequence, *args, &behavior)
+    super unless behavior
+
+    if escaping_as_punctuation? && valid_punctuation_sequence?(escape_sequence)
+      escape_sequence = characters_for_punctuation_sequence(escape_sequence)
+    end
+
+    set_escape(escape_sequence, behavior)
+    set_escape_options(escape_sequence, args.first) if args.length > 0
   end
-  
-  def self.method_missing(meth, *args, &block)
-    str = meth.to_s
-    if str.length == 1
-      @escapes ||= {}
-      @escapes[str] = block
-    elsif SPECIAL_CHARACTER_FORMATS[str]
+
+  def self.punctuation
+    @parsing_punctuation = true
+  end
+
+  protected
+
+    def self.characters_for_punctuation_sequence(sequence)
+      PUNCTUATION_FORMATS.fetch(sequence.to_s)
+    end
+
+    def self.escapes
       @escapes ||= {}
-      @escapes[ SPECIAL_CHARACTER_FORMATS[str] ] = block
-    else
-      super
     end
-  end
+
+    def self.escape_options
+      @escape_options ||= {}
+    end
+
+    def self.escaping_as_punctuation?
+      @parsing_punctuation
+    end
+
+    def self.set_escape(escape_sequence, behavior)
+      escapes[escape_sequence.to_s] = behavior
+    end
+
+    def self.set_escape_options(escape_sequence, options_regex)
+      escape_options[escape_sequence.to_s] = options_regex
+    end
+
+    def self.valid_punctuation_sequence?(sequence)
+      PUNCTUATION_FORMATS.include? sequence.to_s
+    end
+
+  public
   
   ####################
   #                  #
   # Instance Methods #
   #                  #
   ####################
-  
-  def to_s
-    split_string = @format_string.scan STRING_FORMAT_REGEX
-    
-    split_string.map { |str| translate_component(str) }.join
+
+  def escape(object, format_string)
+    escape_method = self.class.escapes[format_string]
+    escape_method ? escape_method[object] : format_string
   end
   
-  def translate_component(string)
-    if string[0...1] == '%'
-      char = string[1..-1]
-      self.class.escape_character(@object, char)
-    else
-      string
-    end
+  def format(object, format_string)
+    parsed_string = parser.parse(format_string)
+
+    evaluator.evaluate(object, parsed_string)
   end
-  
-end
 
-class Module
-  
-  def define_format_string(formatter_method, options = {})
-    formatter_class = options[:with]
+  protected
     
-    define_method formatter_method do |format_string|
-      formatter_class.new(self, format_string).to_s
+    def escape_options
+      self.class.escape_options
     end
-  end
-  
+    
+    def escape_sequences
+      self.class.escapes.keys
+    end
+
+    def evaluations
+      self.class.escapes
+    end
+
+    def evaluator
+      @evaluator ||= FormatEvaluator.new(evaluations)
+    end
+
+    def parser
+      @parser ||= FormatParser.new(escape_sequences, escape_options)
+    end
+
 end

metadata

@@ -1,92 +1,50 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: string_formatter
-version: !ruby/object:Gem::Version 
-  hash: 23
+version: !ruby/object:Gem::Version
+  version: 2.0.1
   prerelease: 
-  segments: 
-  - 1
-  - 0
-  - 0
-  version: 1.0.0
 platform: ruby
-authors: 
+authors:
 - Mark Josef
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-01-11 00:00:00 -05:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: hoe
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 47
-        segments: 
-        - 2
-        - 8
-        - 0
-        version: 2.8.0
-  type: :development
-  version_requirements: *id001
-description: A gem for creating strf-style methods in any Ruby object.
-email: 
-- McPhage@gmail.com
+date: 2013-07-05 00:00:00.000000000 Z
+dependencies: []
+description: ! "    Ruby has useful formatter methods, like Time#strftime.  This gem\n
+  \   allows you to define your own similar methods on any Ruby\n    object easily,
+  using a nice little DSL.\n"
+email: McPhage@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- README.txt
-files: 
-- .autotest
-- History.txt
-- Manifest.txt
-- README.txt
-- Rakefile
+extra_rdoc_files: []
+files:
 - lib/string_formatter.rb
-- test/test_string_formatter.rb
-has_rdoc: true
+- lib/format_evaluator.rb
+- lib/format_parser.rb
+- lib/formattable.rb
 homepage: http://github.com/mark/string_formatter
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --main
-- README.txt
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+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 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: string_formatter
-rubygems_version: 1.4.2
+rubyforge_project: 
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: A gem for creating strf-style methods in any Ruby object.
-test_files: 
-- test/test_string_formatter.rb
+summary: A gem for creating strf-style methods on any Ruby object.
+test_files: []

data/.autotest

@@ -1,23 +0,0 @@
-# -*- ruby -*-
-
-require 'autotest/restart'
-
-# Autotest.add_hook :initialize do |at|
-#   at.extra_files << "../some/external/dependency.rb"
-#
-#   at.libs << ":../some/external"
-#
-#   at.add_exception 'vendor'
-#
-#   at.add_mapping(/dependency.rb/) do |f, _|
-#     at.files_matching(/test_.*rb$/)
-#   end
-#
-#   %w(TestA TestB).each do |klass|
-#     at.extra_class_map[klass] = "test/test_misc.rb"
-#   end
-# end
-
-# Autotest.add_hook :run_command do |at|
-#   system "rake build"
-# end

data/History.txt

@@ -1,3 +0,0 @@
-=== 1.0.0 / 2011-01-11
-
-* First (test) release!  Yay!

data/Manifest.txt

@@ -1,7 +0,0 @@
-.autotest
-History.txt
-Manifest.txt
-README.txt
-Rakefile
-lib/string_formatter.rb
-test/test_string_formatter.rb

data/README.txt

@@ -1,92 +0,0 @@
-= string_formatter
-
-* http://github.com/mark/string_formatter
-
-== DESCRIPTION:
-
-A gem for creating strf-style methods in any Ruby object.
-
-== FEATURES/PROBLEMS:
-
-* Creates strf-style methods
-
-== SYNOPSIS:
-
-class PersonFormatter < StringFormatter
-  
-  f { |p| p.first_name }
-  F { |p| p.first_name.upcase }
-  l { |p| p.last_name  }
-  pipe { |p| 'PIPE' }
-  
-end
-
-class UpcaseFormatter < StringFormatter
-  
-  f { |p| p.first_name.upcase }
-  l { |p| p.last_name.upcase  }
-  
-end
-
-class Person
-  attr_accessor :first_name, :last_name
-
-  define_format_string :strf,   :with => PersonFormatter
-  define_format_string :strfup, :with => UpcaseFormatter
-  
-  def initialize(*names)
-    @first_name, @last_name = names
-  end
-  
-end
-
-p = Person.new("Bob", "Smith")
-
-p.strf('%l, %f %|')
-# => "Smith, Bob PIPE"
-
-p.strfup('%l, %f')
-# => "SMITH, BOB"
-
-
-== REQUIREMENTS:
-
-* None
-
-== INSTALL:
-
-* gem install string_formatter
-
-== DEVELOPERS:
-
-After checking out the source, run:
-
-  $ rake newb
-
-This task will install any missing dependencies, run the tests/specs,
-and generate the RDoc.
-
-== LICENSE:
-
-(The MIT License)
-
-Copyright (c) 2011 Mark Josef
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -1,21 +0,0 @@
-# -*- ruby -*-
-
-require 'rubygems'
-require 'hoe'
-
-# Hoe.plugin :compiler
-# Hoe.plugin :gem_prelude_sucks
-# Hoe.plugin :inline
-# Hoe.plugin :racc
-# Hoe.plugin :rubyforge
-
-Hoe.spec 'string_formatter' do
-  # HEY! If you fill these out in ~/.hoe_template/Rakefile.erb then
-  # you'll never have to touch them again!
-  # (delete this comment too, of course)
-
-  developer('Mark Josef', 'McPhage@gmail.com')
-
-end
-
-# vim: syntax=ruby

data/test/test_string_formatter.rb

@@ -1,8 +0,0 @@
-require "test/unit"
-require "string_formatter"
-
-class TestStringFormatter < Test::Unit::TestCase
-  def test_sanity
-    flunk "write tests or I will kneecap you"
-  end
-end