joker 0.0.1

data/HISTORY.markdown

@@ -0,0 +1,6 @@
+# 0.0.1 #
+
+*   Initial release
+*   Ability to match Wildcards against strings
+*   Ability to quote strings for use in Wildcards
+

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2009 Fabian Streitel
+
+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/README.markdown

@@ -0,0 +1,70 @@
+# Joker #
+
+<http://karottenreibe.github.com/joker>
+
+Joker is a simple Wildcard (a.k.a Glob Pattern) implementition
+for Ruby.
+
+## Features ##
+
+*   Behaves much like Regexp
+*   ` * ` and ` ? ` as wildcard characters
+*   ` \ ` for escaping
+*   `\a` matches `\a`, but not `a`
+*   Wildcards must always match whole string
+*   Wildcards can be case insensitive
+
+## Installation ##
+
+    gem install karottenreibe-joker --source http://gems.github.com
+    gem install joker
+
+## Usage ##
+
+    require 'rubygems'
+    require 'joker'
+
+
+    wild = Wildcard['Fairy?ake*']
+
+    wild =~ 'Fairycake'                     #=> true
+    wild =~ 'Fairyfakes'                    #=> true
+    wild =~ 'Fairylake is a cool place'     #=> true
+
+    wild =~ 'Dairycake'                     #=> false
+    wild =~ 'Fairysteakes'                  #=> false
+    wild =~ 'fairycake'                     #=> false
+
+    wildi = Wildcard['Fairy?ake*\?', true]
+
+    wildi =~ 'FairyCake?'                   #=> true
+    wildi =~ 'fairyfakes?'                  #=> true
+    wildi =~ 'FairyLake IS A COOL Place?'   #=> true
+
+    Wildcard.quote('*?\\')                  #=> '\\*\\?\\\\'
+
+## License ##
+
+    Copyright (c) 2009 Fabian Streitel
+
+    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

@@ -0,0 +1,20 @@
+require 'jeweler'
+
+task :build => :gemspec
+
+Jeweler::Tasks.new do |gem|
+    gem.name = 'joker'
+    gem.summary = gem.description =
+        'Joker is a simple wildcard implementation that works much like Regexps'
+    gem.email = 'karottenreibe@gmail.com'
+    gem.homepage = 'http://karottenreibe.github.com/joker'
+    gem.authors = ['Fabian Streitel']
+    gem.rubyforge_project = 'k-gems'
+end
+
+Jeweler::RubyforgeTasks.new
+
+task :test do
+    sh 'bacon -Ilib test/test_*.rb'
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/joker.rb

@@ -0,0 +1,179 @@
+#
+# Joker is a simple Wildcard implementation that works much like Regexps.
+#
+
+#
+# Implements wildcards for Ruby. Modeled after the Regexp class.
+#
+# This implementation supports the following special characters:
+#
+# - ?      matches a single character
+# - *      matches any number of characters, including 0
+# - \\*    matches a literal '*'
+# - \\?    matches a literal '?'
+# - \\\\   matches a literal '\\'
+# - [xyz]  matches either 'x', 'y' or 'z'. NOTE that you have
+#          to escape ']' in these groups: \\] 
+#
+# NOTE that '\\a' will match the literal string '\\a', not 'a' as
+# one might expect.
+#
+#   wild = Wildcard['Fairy?ake*']
+#   wild =~ 'Fairycake'                     #=> true
+#   wild =~ 'Fairyfakes are mean'           #=> true
+#   wild =~ 'Fairysteakes are delicious'    #=> false
+#
+# Also there is a case sensitivity flag. By default it is set to true,
+# but it can be turned off at construction time:
+#
+#   wild = Wildcard['Fairy?ake*', true]
+#   wild =~ 'Fairycake'
+#   wild =~ 'fairyCAKE'
+#   wild =~ 'FaIrYfAkEs, the Movie'
+#
+# Furthermore, any given Wildcard expression must match the whole string:
+#
+#   wild = Wildcard['Fairy?ake']
+#   wild =~ 'some Fairycake'                #=> false
+#   wild =~ 'Fairycake is good for you'     #=> false
+#
+class Wildcard
+
+    #
+    # Boolean. Determines case sensitivity of the Wildcard.
+    #
+    # If this is true, the Wildcard will ignore case.
+    #
+    attr_reader :casefold
+
+    #
+    # The string from which the Wildcard was constructed.
+    #
+    attr_reader :source
+
+    #
+    # Creates a new Wildcard from the given string.
+    # If casefold is true, the Wildcard will ignore case.
+    #
+    def initialize( wildcard_string, casefold = false )
+        @source   = wildcard_string
+        @casefold = casefold
+        @regexp   =
+            if casefold then Regexp.new(compile, Regexp::IGNORECASE)
+            else             Regexp.new(compile)
+            end
+    end
+
+    class << self
+
+        #
+        # Returns a new string with any characters escaped that would have
+        # special meaning in a Wildcard.
+        #
+        def quote( string )
+            string.gsub(%r{[\\?*\[]}) { |char| "\\#{char}" }
+        end
+
+        alias_method :[], :new
+        alias_method :compile, :new
+        alias_method :escape, :quote
+
+    end
+
+    def inspect
+        %{Wildcard[#{@source.inspect}]#{@casefold ? 'i' : ''}}
+    end
+
+    #
+    # Matches the wildcard against $_:
+    #
+    #   $_ = 'I love fairycakes'
+    #   ~Wildcard['*fairy*']        #=> true
+    #
+    def ~
+        self =~ $_
+    end
+
+    #
+    # Matches the Wildcard against the given string.
+    #
+    # NOTE: Since a wildcard has to match the whole string,
+    # this method only returns true or false, not the position
+    # of the match.
+    #
+    #   Wildcard['*fairy*'] =~ 'I love fairycake'   #=> true
+    #   'I love fairycake' =~ Wildcard['*dairy*']   #=> false
+    #
+    def =~( string )
+        !!(@regexp =~ string)
+    end
+
+    #
+    # The case operator. Allows you to use Wildcards in case
+    # expressions:
+    #
+    #   case 'I love fairycake'
+    #   when Wildcard['*fairy*'] then puts 'fairy!'
+    #   else puts 'no fairy...'
+    #   end
+    #
+    def ===( object )
+        !!(@regexp =~ object)
+    end
+
+    #
+    # Compares to Wildcards for equality.
+    #
+    # Two wildcards are equal, if they were constructed from the
+    # same string and have the same #casefold?().
+    #
+    def eql?( that )
+        return false unless that.is_a?(Wildcard)
+        @source == that.source && @casefold == that.casefold
+    end
+
+    alias_method :==, :eql?
+    alias_method :casefold?, :casefold
+
+    private
+
+    #
+    # Converts the wildcard string into a Regexp.
+    # A simple parser, I just threw it in there, no
+    # optimizations.
+    #
+    def compile
+        ptr = 0
+        compiled = '^'
+        while ptr < @source.length
+            snip = @source[ptr..-1]
+            if snip.scan(%r{^\\\\}).first
+                compiled << '\\\\'
+                ptr += 2
+            elsif snip.scan(%r{^\\\?}).first
+                compiled << '\\?'
+                ptr += 2
+            elsif snip.scan(%r{^\\\*}).first
+                compiled << '\\*'
+                ptr += 2
+            elsif snip.scan(%r{^\?}).first
+                compiled << '.'
+                ptr += 1
+            elsif snip.scan(%r{^\*}).first
+                compiled << '.*'
+                ptr += 1
+            elsif group = snip.scan(%r{^\[(?:\\\]|[^\]])+\]}).first
+                ptr += group.length
+                group = group[1..-2]  # remove []
+                group = group.gsub(%r{\\\]}) { ']' }
+                compiled << '[' << Regexp.quote(group) << ']'
+            else
+                compiled << Regexp.quote(@source[ptr..ptr])
+                ptr += 1
+            end
+        end
+        compiled + '$'
+    end
+
+end
+

data/test/test_joker.rb

@@ -0,0 +1,59 @@
+require 'bacon'
+require 'joker'
+
+describe 'A Wildcard' do
+
+    before do
+        @wild  ||= Wildcard['Fairy?ake*']
+        @wildi ||= Wildcard['Fairy?ake*\?', true]
+        @wildc ||= Wildcard['Fairy[cf]ake[!\\]]']
+    end
+
+    it 'should be constructed correctly' do
+        @wild.casefold?.should.be.false
+        @wildi.casefold?.should.be.true
+        @wildc.casefold?.should.be.false
+        regexp  = @wild.instance_variable_get(:@regexp)
+        regexpi = @wildi.instance_variable_get(:@regexp)
+        regexpc = @wildc.instance_variable_get(:@regexp)
+        regexp.should.be  == /^Fairy.ake.*$/
+        regexpi.should.be == /^Fairy.ake.*\?$/i
+        regexpc.should.be == /^Fairy[cf]ake[!\]]$/
+    end
+
+    it 'should match correct strings' do
+        @wild.should =~ 'Fairycake'
+        @wild.should =~ 'Fairyfakes'
+        @wild.should =~ 'Fairylake is a cool place'
+    end
+
+    it 'should not match incorrcet strings' do
+        @wild.should.not =~ 'Dairycake'
+        @wild.should.not =~ 'Fairysteakes'
+        @wild.should.not =~ 'fairycake'
+    end
+
+    it 'should match case insensitive' do
+        @wildi.should =~ 'FairyCake?'
+        @wildi.should =~ 'fairyfakes?'
+        @wildi.should =~ 'FairyLake IS A COOL Place?'
+    end
+
+    it 'should handle escapes correctly' do
+        wild   = Wildcard['\\\\a\\?b\\*c\\d.][+']  # \\a\?b\*c\d.][+
+        regexp = wild.instance_variable_get(:@regexp)
+        regexp.should.be == /^\\a\?b\*c\\d\.\]\[\+$/
+    end
+
+    it 'should quote correctly' do
+        Wildcard.quote('*?\\').should.be  == '\\*\\?\\\\'   # *?\  -->  \*\?\\
+        Wildcard.quote('\\\\').should.be  == '\\\\\\\\'     # \\   -->  \\\\
+    end
+
+    it 'should know about character classes' do
+        @wildc.should =~ 'Fairycake!'
+        @wildc.should =~ 'Fairyfake]'
+    end
+
+end
+

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: joker
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Fabian Streitel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-15 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Joker is a simple wildcard implementation that works much like Regexps
+email: karottenreibe@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.markdown
+files: 
+- HISTORY.markdown
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- VERSION
+- lib/joker.rb
+- test/test_joker.rb
+has_rdoc: true
+homepage: http://karottenreibe.github.com/joker
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: k-gems
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Joker is a simple wildcard implementation that works much like Regexps
+test_files: 
+- test/test_joker.rb