DZone Snippets: match code

Basic Trie data structure in Ruby

ntk () — Sat, 07 Jun 2008 20:54:39 GMT



# Inspired by http://www.rubyquiz.com/quiz103.html

# cf. also http://en.wikipedia.org/wiki/Trie



#!/usr/local/bin/ruby -w



require 'pp'



class Hash



   def deep_merge!(second)

      # cf. http://snippets.dzone.com/posts/show/4146

      merger = proc { |key,v1,v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }

      self.merge!(second, &merger)

   end



   def nested_hash(array)

      node = self

      array.each do |i|

         node[i]=Hash.new if node[i].nil?

         node = node[i]

      end 

      self

   end



   def merge_nested_hash!(nested_hash)

      deep_merge!(nested_hash)

   end



   # code basis taken from: "Find every path and it's value in a Hash" by Florian Aßmann,

   # http://snippets.dzone.com/posts/show/3565



   def each_trie_path

      raise ArgumentError unless block_given?

      self.class.each_trie_path(self) { |path, object| yield(path, object) }

   end



   protected

   def self.each_trie_path(object, path = [], &block)  



      if object.is_a?(Hash)

         object.each do |key, value|



            if key == true && value == {}

               if path == [:root]  # special case for empty string: [[:root], {true=>{}}]

                  yield(path, {true=>{}})

                  next

               end

               yield(path, object)

            end



            self.each_trie_path(value, [path , key].flatten, &block)

         end

      else 

         yield(path, object)

      end

   end 



end





class Trie



   @hash = Hash.new.merge_nested_hash!(Hash.new)

   #@hash = Hash.new.merge_nested_hash!({:root=>{}})

   #@hash = Hash.new.merge_nested_hash!(Hash.new.nested_hash([:root]))

   class << self; attr_accessor :hash; end    # Trie.hash



   def initialize

      Trie.hash.merge_nested_hash!({:root=>{}})

   end





   def add_int(int)   # for int >= 0

      ia = int.to_s.scan(/[[:digit:]]/).map { |i| i.to_i }  # integer array; ex: [4,6,2]

      ia.unshift(:root).push(true)

      Trie.hash.merge_nested_hash!(Hash.new.nested_hash(ia))

   end



   def matchi(int)  # match integer

      ia = int.to_s.scan(/[[:digit:]]/).map { |i| i.to_i }  

      node = Trie.hash.fetch(:root,nil)

      ia.each do |digit|

         node = node[digit]

         #node = node.fetch(digit,nil)

         return false unless node

      end

      node.fetch(true,nil) ? true : false

   end



   def mfpi(int)   # match first part of integer

      ia = int.to_s.scan(/[[:digit:]]/).map { |i| i.to_i }

      node = Trie.hash.fetch(:root,nil)

      ia.each do |digit|

         node = node[digit]

         return false unless node

      end

      return true

   end





   def add_word(word)

      ca = word.split(//u)    # UTF-8 aware character array

      ca.unshift(:root).push(true)

      Trie.hash.merge_nested_hash!(Hash.new.nested_hash(ca))

   end



   def match(word)   # match entire word

      ca = word.split(//u)    

      node = Trie.hash.fetch(:root,nil)

      ca.each do |char|

         node = node[char]

         #node = node.fetch(char,nil)

         return false unless node

      end

      node.fetch(true,nil) ? true : false

   end



   def mfpw(word)   # match first part of word

      ca = word.split(//u)    

      node = Trie.hash.fetch(:root,nil)

      ca.each do |char|

         node = node[char]

         return false unless node

      end

      return true

   end



end





trie = Trie.new

p Trie.hash



trie.add_word("word")

pp Trie.hash            

p trie.match("word")      

p trie.match("word2")   

trie.add_word("word2")

p trie.match("word2")   

pp Trie.hash            # {:root=>{"w"=>{"o"=>{"r"=>{"d"=>{true=>{}, "2"=>{true=>{}}}}}}}}



trie.add_word("")

p trie.match("")

pp Trie.hash



puts



p trie.match("word")      

p trie.mfpw("wor")     # match first part of word



puts



trie.add_int(12345)

p Trie.hash



trie.add_int(12980345)

pp Trie.hash



trie.add_int(8512)

pp Trie.hash

p trie.matchi(8512)

p trie.matchi(85)

p trie.mfpi(85)     # match first part of integer

p trie.matchi(51)



puts



puts

pp Trie.hash

paths = []

Trie.hash.each_trie_path { |path, value| paths.push([ path ]) }

#Trie.hash.each_trie_path { |path, value| paths.push([ path, value ]) }

#pp paths

puts

paths.each { |x| p x }

puts





#------------------------------------------------------





require 'pp'



class Hash

   def Hash.new_nested_hash

     Hash.new{|h,k| h[k]=Hash.new(&h.default_proc) }

   end

end





class Trie



   @hash = Hash.new_nested_hash

   #@hash = Hash.new_nested_hash.update(true=>{})  # add empty string by default

   class << self; attr_accessor :hash; end    # Trie.hash



   def <<(word)

      ca = word.split(//u)    # UTF-8 aware character array

      wl = ca.size            # word length

      str = ""

      wl.times { |x| str << "[ca.at(#{x})]" }

      str = "Trie.hash" << str << "[true]"

      #p str     # example: "Trie.hash[ca.at(0)][ca.at(1)][ca.at(2)][ca.at(3)][true]"

      eval(str)

   end





   def match(word)

      ca = word.split(//u)    # UTF-8 aware character array

      wl = ca.size            # word length

      str = ""



      wl.times { |x| str << ".fetch(ca.at(#{x}),nil)" }

      str = "Trie.hash" << str << ".fetch(true,nil)"

      #p str   # example: "Trie.hash.fetch(ca.at(0),nil).fetch(ca.at(1),nil).fetch(ca.at(2),nil).fetch(true,nil)"

      ret = eval(str) rescue nil



=begin

      # alternative

      wl.times { |x| str << ".fetch(ca.at(#{x}),{})" }

      str = "Trie.hash" << str << ".fetch(true,nil)"

      #p str   # example: "Trie.hash.fetch(ca.at(0),{}).fetch(ca.at(1),{}).fetch(ca.at(2),{}).fetch(true,nil)"

      ret = eval(str)

=end



      ret == {} ? true : false   # {} is the default value created by Trie.hash or Hash.new_nested_hash respectively

   end



end





trie = Trie.new

trie << "word"

pp Trie.hash            

p trie.match("word")      

p trie.match("word2")   

trie << "word2"

p trie.match("word2")   

pp Trie.hash            # {"w"=>{"o"=>{"r"=>{"d"=>{true=>{}, "2"=>{true=>{}}}}}}}



trie << ""

p trie.match("")

pp Trie.hash





#------------------------------------------





# alternative with default :root element



require 'pp'



class Hash

   def Hash.new_nested_hash

     Hash.new{|h,k| h[k]=Hash.new(&h.default_proc) }

   end

end





class Hash



   # code basis taken from: "Find every path and it's value in a Hash" by Florian Aßmann,

   # http://snippets.dzone.com/posts/show/3565



   def each_trie_path

      raise ArgumentError unless block_given?

      self.class.each_trie_path(self) { |path, object| yield(path, object) }

   end



   protected

   def self.each_trie_path(object, path = [], &block)  



      if object.is_a?(Hash)

         object.each do |key, value|



            if key == true && value == {}

               if path == [:root]  # special case for empty string: [[:root], {true=>{}}]

                  yield(path, {true=>{}})

                  next

               end

               yield(path, object)

            end



            self.each_trie_path(value, [path , key].flatten, &block)

         end

      else 

         yield(path, object)

      end

   end 



end





class Trie



   @hash = Hash.new_nested_hash

   class << self; attr_accessor :hash; end    # Trie.hash



   def initialize

      Trie.hash[:root]

   end





   def add_int(int)   # for int >= 0

      ia = int.to_s.scan(/[[:digit:]]/).map { |i| i.to_i }  # integer array; ex: [4,6,2]

      ia.unshift(:root)

      str = ""

      ia.size.times { |x| str << "[ia.at(#{x})]" }

      str = "Trie.hash" << str << "[true]"

      eval(str)

   end



   def matchi(int)  # match integer

      ia = int.to_s.scan(/[[:digit:]]/).map { |i| i.to_i }  

      node = Trie.hash.fetch(:root,nil)

      ia.each do |digit|

         node = node.fetch(digit,nil)

         return false unless node

      end

      node.fetch(true,nil) ? true : false

   end



   def mfpi(int)   # match first part of integer

      ia = int.to_s.scan(/[[:digit:]]/).map { |i| i.to_i }

      node = Trie.hash.fetch(:root,nil)

      ia.each do |digit|

         node = node.fetch(digit,nil)

         return false unless node

      end

      return true

   end





   def <<(word)

      ca = word.split(//u)    # UTF-8 aware character array

      ca.unshift(:root)

      #ca = [:root, *word.split(//u)]

      #ca = [:root].concat(word.split(//u))

      str = ""

      ca.size.times { |x| str << "[ca.at(#{x})]" }

      str = "Trie.hash" << str << "[true]"

      #p str     # example: "Trie.hash[ca.at(0)][ca.at(1)][ca.at(2)][ca.at(3)][true]"

      eval(str)

   end



   def match(word)

      ca = word.split(//u)    

      ca.unshift(:root)

      #ca = [:root, *word.split(//u)]

      #ca = [:root].concat(word.split(//u))

      str = ""

      ca.size.times { |x| str << ".fetch(ca.at(#{x}),nil)" }

      str = "Trie.hash" << str << ".fetch(true,nil)"

      #p str   # example: "Trie.hash.fetch(ca.at(0),nil).fetch(ca.at(1),nil).fetch(ca.at(2),nil).fetch(true,nil)"

      ret = eval(str) rescue nil



=begin

      # alternative

      ca.size.times { |x| str << ".fetch(ca.at(#{x}),{})" }

      str = "Trie.hash" << str << ".fetch(true,nil)"

      #p str   # example: "Trie.hash.fetch(ca.at(0),{}).fetch(ca.at(1),{}).fetch(ca.at(2),{}).fetch(true,nil)"

      ret = eval(str)

=end



      ret == {} ? true : false   # {} is the default value created by Trie.hash or Hash.new_nested_hash respectively

   end



   def match2(word)   # match entire word

      ca = word.split(//u)    

      node = Trie.hash.fetch(:root,nil)

      ca.each do |char|

         node = node.fetch(char,nil)

         return false unless node

      end

      node.fetch(true,nil) ? true : false

   end



   def mfpw(word)   # match first part of word

      ca = word.split(//u)    

      node = Trie.hash.fetch(:root,nil)

      ca.each do |char|

         node = node.fetch(char,nil)

         return false unless node

      end

      return true

   end



end





trie = Trie.new

trie << "word"

pp Trie.hash            

p trie.match("word")      

p trie.match("word2")   

trie << "word2"

p trie.match("word2")   

pp Trie.hash            # {:root=>{"w"=>{"o"=>{"r"=>{"d"=>{true=>{}, "2"=>{true=>{}}}}}}}}



trie << ""

p trie.match("")

pp Trie.hash



puts



p trie.match2("word")      

p trie.mfpw("wor")     # match first part of word



puts



trie.add_int(8512)

pp Trie.hash

p trie.matchi(8512)

p trie.matchi(85)

p trie.mfpi(85)     # match first part of integer

p trie.matchi(51)



puts



puts

pp Trie.hash

paths = []

Trie.hash.each_trie_path { |path, value| paths.push([ path ]) }

#Trie.hash.each_trie_path { |path, value| paths.push([ path, value ]) }

#pp paths

puts

paths.each { |x| p x }

puts

Matching quoted strings in Ruby

ntk () — Sun, 04 May 2008 18:47:17 GMT

An exercise in string processing and regexp matching, inspired by Parsing Quoted Strings in Ruby and Stupid Ruby Quoting Tricks.



#!/usr/local/bin/ruby -w



# some input examples

str = 'foo "bar baz" qux'

str = 'foo "bar baz " "bar baz" " bar baz" "bar "klr mre" " " \' "abc" \' baz " qux'

str = '" \' \'    " \n "   " \' \' "" foo \'ttt sss\' "bar "qqq zzz" baz" "added term" qux  " \' \'    "  yyy xxx'

str = '"""frickin \'#{bar}\'"""'

str = '""    "frickin chicken "    #{bar}""""'

str = '"""frickin "#{bar}""""'

str = '"a "b c" "d "e" f g" """h""""'       # cf. http://snippets.dzone.com/posts/show/4852



# escaped quotes

str = '\"'

str = "\\\""

str = '\\\''

str = "\\'"



# special cases

str = '"G","H I"'

str = '"G","H I""G","H I"'



str = '"abc""def"'

str = '"""a""b"'

str = '"abc""def""abc""def""abc""def"'

str = '"a"\'\'"b"'



str = "\"abc'vv'tt\"'klt'"



str = "abc,def,\"efg,hij\",klm,nop,\"qrstuv\",wxyz"

str = "abc,def,\"efg,hij\",klm, 'nop, \"qrstuv\",wxyz,mmm '"

str = "abc,def,\"efg,hij\",klm, \"nop, 'qrstuv',wxyz,mmm \""





puts

puts "input string:  #{str}" 

puts "str.inspect :  #{str.inspect}" 

puts



num_of_chars1 = str.count('a-zA-Z_0-9', "^\000ds")



error_code = 0      # in case of a parsing error Shellwords will be used instead of regex1 & regex2

str2 = str.clone



# encode escaped quotes

str = str.gsub(/\\"|\\'/) { |m| m =~ /^\\"$/ ? "\000d\000" : "\000s\000" }



dq_count = str.count('"')

sq_count = str.count("'")



if dq_count % 2 != 0 && sq_count % 2 != 0

   raise ArgumentError, "\e[1modd number of single & double quotes\e[m in: #{str}\nsq_count: #{sq_count}\ndq_count: #{dq_count}\n"

elsif dq_count % 2 != 0

   raise ArgumentError, "\e[1modd number of double quotes\e[m in: #{str}\ndq_count: #{dq_count}\n"

elsif sq_count % 2 != 0

   raise ArgumentError, "\e[1modd number of single quotes\e[m in: #{str}\nsq_count: #{sq_count}\n"

end



# regex1 separates substrings that contain quotes from substrings that do not contain quotes

regex1 = %r{[^"']+|["'].*?["'](?!.*["'])}m  



# example

#"abc 'quote1' pjk 'quote2' xyz".scan(regex1) { |m| puts m } 





regex2 = %r{

# experimental: special cases

\s*["'][^"']+["'][[:punct:]]["'][^"']+["']|  # special case:  xxx "ab c","def g" yyy

\s*["'][^"']+["']{2,}[^"']+["']|             # special case:  xxx "abc""def" yyy

\s"[^"]+"|                                   # special case: xxx "abc 'def' ghi"

\s'[^']+'|                                   # special case: xxx 'abc "def" ghi'

\s*["']\S+["']|                              # special case: "abc'vv'tt"'klt'



\s'\s|                       # xxx ' yyy

\s"\s|                       # xxx " yyy

\s''\s|                      # xxx '' yyy

\s""\s|                      # xxx "" yyy

\s'\s+'\s|                   # xxx '   ' yyy

\s"\s+"\s|                   # xxx "   " yyy

\s"\s[^"]+\s"\s|             # xxx " abc " yyy

\s'\s[^']+\s'\s|             # xxx ' abc ' yyy

\s["']["']+(?=[^"'\s])|      # :qoblock:  xxx "'""'abc yyy

[^"'\s]["']["']+(?=\s)|      # :qcblock:  xxx abc"'""' yyy

\s""+|                       # :dqoblock:  xxx """abc yyy

\s''+|                       # :sqoblock:  xxx '''abc yyy

[^"]""+|                     # :dqcblock:  xxx abc"" yyy

[^']''+|                     # :sqcblock:  xxx abc'' yyy

\s["'](?=[^"'\s])|           # :dqo or :sqo:  xxx "abc yyy  or  xxx 'abc yyy

[^"'\s]["'](?=\s)|           # :dqc or :sqc:  xxx abc" yyy  or  xxx abc' yyy

[^"']+[^"'\s](?=\s)          # no quotes at all

}mx





=begin



There are different kinds of quotes matched by regex2 below. They include:



- :sqo (single quote open)

- :sqc (single quote close)

- :sqoblock (single quote open block)

- :sqcblock (single quote close block)



- :dqo (double quote open)

- :dqc (double quote close)

- :dqoblock (double quote open block)

- :dqcblock (double quote close block)



- :qoblock (quote open block)

- :qcblock (quote close block)



=end





ret = []



str.scan(regex1) do |s| 



   if s !~ /\A["']/



      #puts "s1: #{s}"

      #puts "s1.inspect: #{s.inspect}"



      s.split(/\s+/m).each { |t| ret << t unless t.empty? }



   else



      #puts "s2: #{s}"

      #puts "s2.inspect: #{s.inspect}"



      open_quotes = 0

      close_quotes = 0

      ar = []



      # add spaces to simplify regex2 matching

      s = "\x20" << s << "\x20"    

      s.gsub!(/\x20/, "\x20\x20")  





      s.scan(regex2) do |m|



         # get the index of the quote

         # + 1 for leading space or non-space

         # $` is the prematch string



         index = $`.length + 1 



         post_match = $'  



         #puts

         #puts "index: #{index}"

         #puts "m: #{m.inspect}"

         #puts "m.length: #{m.length}"

         #puts "open_quotes:  #{open_quotes}\nclose_quotes: #{close_quotes}"

         #puts "ret: #{ret.inspect}"

         #puts "ar: #{ar.inspect}"

         #puts





         if m =~ /\A\s''\s\z/



            next unless open_quotes == 0 && close_quotes == 0

            ret << ''

            next



         elsif m =~ /\A\s""\s\z/



            next unless open_quotes == 0 && close_quotes == 0

            ret << ""

            next



         # example: xxx "ab c","def g" yyy

         elsif open_quotes.zero? && close_quotes.zero? && m =~ /\A\s*["'][^"']+["'][[:punct:]]["'][^"']+["']\z/ && m.count('"') % 2 == 0 && m.count("'") % 2 == 0           



            m = m.gsub(/\x20\x20/, "\x20")

            # cf. http://henrik.nyh.se/2008/03/flickr-style-tag-splitting-in-ruby

            m = m.split(/"(.+?)"|\s+/).reject {|sm| sm.empty? }

            #m = m.split(/"(.+?)"|'(.+?)'|\s+/).reject {|sm| sm.empty? }

            #m = m.split(/"(.+?)"|'(.+?)'|([[:punct:]])|\s+/).reject {|sm| sm.empty? }

            ret.concat(m)

            next



         # example: xxx "abc""def" yyy

         elsif open_quotes.zero? && close_quotes.zero? && m =~ /\A\s*["'][^"']+["']{2,}[^"']+["']\z/ && m.count('"') % 2 == 0 && m.count("'") % 2 == 0           

            

            m = m.gsub(/\x20\x20/, "\x20")

            m = m.split(/"(.+?)"|\s+/).reject {|sm| sm.empty? }

            #m = m.split(/"(.+?)"|'(.+?)'|\s+/).reject {|sm| sm.empty? }

            ret.concat(m)

            next





         elsif open_quotes.zero? && close_quotes.zero? && m =~ /\A\s"[^"]+"\z/ && m.count('"') % 2 == 0 && m.count("'") % 2 == 0

            ret.concat(m.split(/"(.+?)"|\s+/).reject {|sm| sm.empty? })

            next



         elsif open_quotes.zero? && close_quotes.zero? && m =~ /\A\s'[^']+'\z/ && m.count('"') % 2 == 0 && m.count("'") % 2 == 0

            ret.concat(m.split(/'(.+?)'|\s+/).reject {|sm| sm.empty? })

            next



         elsif open_quotes.zero? && close_quotes.zero? && m =~ /\A\s*["']\S+["']\z/ && m.count('"') % 2 == 0 && m.count("'") % 2 == 0

            ret.concat(m.split(/"(.+?)"|\s+/).reject {|sm| sm.empty? })

            next





         elsif m =~ /\A\s"\s[^"]+\s"\s\z/



            next unless open_quotes == 0 && close_quotes == 0

            ret << m.gsub(/\x20\x20/, "\x20").strip[1..-2]

            next



         elsif m =~ /\A\s'\s[^']+\s"\s\z/



            next unless open_quotes == 0 && close_quotes == 0

            ret << m.gsub(/\x20\x20/, "\x20").strip[1..-2]

            next



         elsif m =~ /\A\s'\s+'\s\z/



            next unless open_quotes == 0 && close_quotes == 0

            ret << m.gsub(/\x20\x20/, "\x20").strip[1..-2]

            next



         elsif m =~ /\A\s"\s+"\s\z/



           next unless open_quotes == 0 && close_quotes == 0

           ret << m.gsub(/\x20\x20/, "\x20").strip[1..-2]

           next





         elsif m =~ /\A\s""+\z/



            l = m.strip.length

            ar << [:dqoblock, index, l]

            old_open_quotes = open_quotes

            open_quotes += l



            if close_quotes == 0 && old_open_quotes == 0 && open_quotes % 2 == 0 && post_match !~ /"/

               ret << m[2..-2] 

               open_quotes = 0

               ar.pop

               next

            end





         elsif m =~ /\A\s''+\z/



            l = m.strip.length

            ar << [:sqoblock, index, l]

            old_open_quotes = open_quotes

            open_quotes += l



            if close_quotes == 0 && old_open_quotes == 0 && open_quotes % 2 == 0 && post_match !~ /'/

               ret << m[2..-2] 

               open_quotes = 0

               ar.pop

               next

            end





         elsif m =~ /\A[^"]""+\z/



            l = m[1..-1].strip.length

            ar << [:dqcblock, index+l-1, l]      #  index+l-1 is the index of the last closing quote: ''"'[']

            old_close_quotes = close_quotes

            close_quotes += l



            if open_quotes == 0 && old_close_quotes == 0 && close_quotes % 2 == 0 && post_match !~ /"/

               ret << m[2..-2] 

               close_quotes = 0

               ar.pop

               next

            end



         elsif m =~ /\A[^']''+\z/



            l = m[1..-1].strip.length

            ar << [:sqcblock, index+l-1, l]

            old_close_quotes = close_quotes

            close_quotes += l



            if open_quotes == 0 && old_close_quotes == 0 && close_quotes % 2 == 0 && post_match !~ /'/

               ret << m[2..-2] 

               close_quotes = 0

               ar.pop

               next

            end





         elsif m =~ /\A\s'\z/



            ar << [:sqo, index, 1]

            open_quotes += 1



         elsif m =~ /\A\S'\z/



            ar << [:sqc, index, 1]

            close_quotes += 1



         elsif m =~ /\A\s"\z/



            ar << [:dqo, index, 1]

            open_quotes += 1



         elsif m =~ /\A\S"\z/



            ar << [:dqc, index, 1]

            close_quotes += 1





         else





            if m =~ /\A\s"\s\z/              # " surrounded by whitespace



               if open_quotes > close_quotes



                  ar << [:dqc, index, 1]

                  close_quotes += 1



                  # avoid :sqo followed by :dqc or :sqc followed by :dqc

                  if post_match =~ /"/ && open_quotes == close_quotes && (ar.at(-2).first == :sqo || ar.at(-2).first == :sqc)

                     ar.pop

                     ar << [:dqo, index, 1]

                     close_quotes -= 1

                     open_quotes += 1

                  end



               else 



                  ar << [:dqo, index, 1]

                  open_quotes += 1



               end





            elsif m =~ /\A\s'\s\z/          # ' surrounded by whitespace



               if open_quotes > close_quotes



                  ar << [:sqc, index, 1]

                  close_quotes += 1



                  # avoid :dqo followed by :sqc or :dqc followed by :sqc

                  if post_match =~ /'/ && open_quotes == close_quotes && (ar.at(-2).first == :dqo || ar.at(-2).first == :dqc)

                     ar.pop

                     ar << [:sqo, index, 1]

                     close_quotes -= 1

                     open_quotes += 1

                  end



               else 



                  ar << [:sqo, index, 1]

                  open_quotes += 1



               end





            elsif m =~ /\A\s["']["']+\z/              # :qoblock: xxx "'""'abc yyy



               l = m[1..-1].strip.length

               ar << [:qoblock, index, l]

               old_open_quotes = open_quotes

               open_quotes += l



               if close_quotes == 0 && old_open_quotes == 0 && open_quotes % 2 == 0 && post_match !~ /["']/

                  ret << m[2..-2] 

                  open_quotes = 0

                  ar.pop

                  next

               end





            elsif m =~ /\A[^"'\s]["']["']+\z/          # :qcblock: xxx abc"'""' yyy



               l = m[1..-1].strip.length

               ar << [:qcblock, index+l-1, l]

               old_close_quotes = close_quotes

               close_quotes += l



               if open_quotes == 0 && old_close_quotes == 0 && close_quotes % 2 == 0 && post_match !~ /["']/

                  ret << m[2..-2] 

                  close_quotes = 0

                  ar.pop

                  next

               end





            elsif m =~ /\A\s*["'].*?["']\s*\z/       # last try  (experimental)



               ret.concat(m.split(/"(.+?)"|\s+/).reject {|sm| sm.empty? })

               next





            elsif m =~ /\A[^"']+[^"'\s]\z/          # part of quoted substring contains neither " nor '

               next unless open_quotes == 0 && close_quotes == 0

               next if m.strip.empty?

               ret << m.gsub(/\x20\x20/, "\x20").strip; next

            end



         end



         puts

         puts "open_quotes:  #{open_quotes}\nclose_quotes: #{close_quotes}\n"

         #puts "ar: #{ar.inspect}"



         if open_quotes == close_quotes



            #puts "open_quotes & close_quotes: #{close_quotes}"

            puts "ar: #{ar.inspect}"



            ret << s[ar.first[1]..ar.last[1]].gsub(/\x20\x20/, "\x20")[1..-2] unless ar.empty?



            ar.clear

            open_quotes = 0

            close_quotes = 0



         end



      end   # scan 2



      unless open_quotes.zero? && close_quotes.zero?

        error_code = 1

        puts "\e[1mparsing error\e[m for the quoted string: #{str.strip.squeeze[0..20]}"

        #raise "\e[1mparsing error\e[m for the quoted string: #{str.strip.squeeze[0..20]}"

      end



   end   # if



end   # scan 1







num_of_chars2 = ret.join.count('a-zA-Z_0-9', "^\000ds")



unless num_of_chars1 == num_of_chars2

   error_code = 1

   puts "\n\e[1mparsing error due to wrong number of characters a-zA-Z_0-9\e[m: \n#{num_of_chars2} instead of #{num_of_chars1}\n"

   #raise "\e[1mparsing error due to wrong number of characters a-zA-Z_0-9\e[m: \n#{num_of_chars2} instead of #{num_of_chars1}\n in #{str.strip.squeeze[0..20]}"

end





# use Shellwords in case the quote matching above failed

if error_code == 1       

#if error_code == 1 || ret.join =~ /\A["']+\z/        

   require 'shellwords'

   ret.clear

   ret.concat(Shellwords::shellwords(str))

   #str =~ /\A\S+\z/ ? ret.concat(str.split(/"(.+?)"|\s+/).reject {|sm| sm.empty? }) : ret.concat(Shellwords::shellwords(str))

end 







puts "\n\e[1mResult\e[m:\n\n"

ret.each_with_index do |t,i| 

   # decode encoded escaped quotes 

   t = t.gsub(/\000d\000|\000s\000/) { |m| m =~ /^\000d\000$/ ? '\"' : "\\'" }

   puts "#{i+1}:  #{t.inspect}" 

end



puts "\n\e[1mShellwords\e[m:\n\n"

require 'shellwords'

Shellwords::shellwords(str2).each_with_index { |t,i| puts "#{i+1}:  #{t.inspect}" }





#----------------------





# matching quoted strings using backreferences

# See: Regexes in Depth: Advanced Quoted String Matching,

# http://blog.stevenlevithan.com/archives/match-quoted-string



str = '"abc"'



regex = %r{(["'])([^"']*)(\1)}

regex = %r{(["'])([^\1]*)(\1)}

p regex



str.scan(regex) { |m| p m; p $1 << $2 << $3 }

Finding your match with Ruby

jrobertson (James Robertson) — Wed, 20 Feb 2008 09:20:51 GMT

This example finds an email subject in a string and passes the value to a variable called 'subject'.



subject = (/^Subject\: (.+)$/).match(email)[1]

Prior to this code I would have used the following:



  email[/^Subject\: (.+)$/]

  subject = $1

Reference: Ruby SMTP Server - Save to Database [dzone.com]

bScan - Simple Web Aplications Scanner

Black_H (Black_H) — Sun, 03 Feb 2008 11:51:05 GMT

// Web application scanner (ex: phpBB, myCMS, myBlog, mySite etc..) - Only in PHP !
// Find XSS, sql injection, remote file inclusion



#####################################################################################

#	Black_H  / Nooz -- 30:01:07 

#	Bl4ck.H<>gmail<>com

#



class BScan



#####################################################################################

#	Regex

#



@@space    = '([[:space:]]*)'



@@userdat  = '('

@@userdat += '(\$_SERVER\[([\'\"]*)HTTP_)|'

@@userdat += '(\$_GET)|'

@@userdat += '(\$_POST)|'

@@userdat += '(\$_COOKIE)|'

@@userdat += '(\$_REQUEST)|'

@@userdat += '(\$_FILES)|'

@@userdat += '(\$_ENV)|'

@@userdat += '(\$_HTTP_COOKIE_VARS)|'

@@userdat += '(\$_HTTP_ENV_VARS)|'

@@userdat += '(\$_HTTP_GET_VARS)|'

@@userdat += '(\$_HTTP_POST_FILES)|'

@@userdat += '(\$_HTTP_POST_VARS)|'

@@userdat += '(\$_HTTP_SERVER_VARS\[([\'\"]*)HTTP_)'

@@userdat += ')'



@@regex = Hash.new

@@regex = 

	{'TYPE' => 'vars overwrite','LEVEL' => '2','REGEX' => /extract#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'vars overwrite','LEVEL' => '2','REGEX' => /import_request_variables#{@@space}\((.*)\)/i},

	{'TYPE' => 'fopen vuln','LEVEL' => '3','REGEX' => /fopen#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'copy vuln','LEVEL' => '3','REGEX' => /copy#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'fwrite vuln','LEVEL' => '3','REGEX' => /fwrite#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'sql injection','LEVEL' => '2','REGEX' => /(mysql_query|mssql_query|mysqli_query)#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'crlf injection','LEVEL' => '1','REGEX' => /mail#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'cross site scripting','LEVEL' => '1','REGEX' => /\<\?\=#{@@space}(.*)#{@@userdat}/i},

	{'TYPE' => 'cross site scripting','LEVEL' => '1','REGEX' => /(print|echo|print_r|var_dump)#{@@space}(|\(|\")(.*)#{@@userdat}/i},

	{'TYPE' => 'php code execution','LEVEL' => '3','REGEX' => /eval#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'php code execution','LEVEL' => '3','REGEX' => /file_put_contents#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'variable attribution', 'LEVEL' => '2','REGEX' => /(.*)\$#{@@userdat}(.*)/i},

	{'TYPE' => 'chmod affectation','LEVEL' => '1','REGEX' => /chmod#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'file disclosure','LEVEL' => '2','REGEX' => /(readfile|file_get_contents|file)#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'file disclosure','LEVEL' => '2','REGEX' => /(show_source|highlight_file)#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'bzopen vuln','LEVEL' => '2','REGEX' => /bzopen#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'file deletion','LEVEL' => '2','REGEX' => /(rmdir|unlink|delete)#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'command execution','LEVEL' => '3','REGEX' => /(exec|system|passthru|shell_exec|proc_open|pcntl_exec)#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'buffer overflow','LEVEL' => '3','REGEX' => /(confirm_phpdoc_compiled|mssql_pconnect|mssql_connect|crack_opendict|snmpget|ibase_connect)#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'ip falsification','LEVEL' => '1','REGEX' => /(.*)(HTTP_CLIENT_IP|HTTP_X_FORWARDED_FOR|HTTP_PC_REMOTE_ADDR)(.*)/i},

	{'TYPE' => 'putenv vuln','LEVEL' => '2','REGEX' => /putenv#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'full path disclosure','LEVEL' => '1','REGEX' => /(htmlentities|htmlspecialchars)#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'magic_quotes_gpc bypass','LEVEL' => '1','REGEX' => /(stripslashes|urldecode)#{@@space}\((.*)#{@@userdat}(.*)\)/i},

	{'TYPE' => 'file inclusion','LEVEL' => '3','REGEX' => /(include|include_once|require|require_once)#{@@space}(|\(|\")(.*)#{@@userdat}/i}



#####################################################################################

#	Main

#



  def initialize()



	################

	#	Usage



if (ARGV.length < 4)

puts  '

 ---------------------------------------------------------------------

|             Credits: Black_H                     |

|                 URL: Lemon-Inside.sup.fr                            |

|                Note: Premier code Ruby                              |

 ---------------------------------------------------------------------



 ---------------------------------------------------------------------

|   Usage:  scan.rb -d  -i                        |

|   Ex:  scan.rb -d ./ -i output.html                                 |

 ---------------------------------------------------------------------		

 '

 end

 

	################

	#	Options & Vars

	

	@@scan_alldir =  self.options('d')

	@@out_file =  self.options('i')

	

	@@ban = [".", "..", "scan.rb", @@out_file.to_s]



	@@scan_buffer = Array.new

	

	################

	#	Options Error ?

	

	if (@@scan_alldir != false and @@scan_alldir.empty? == false)

	self.dscan(@@scan_alldir)

	self.output(@@scan_buffer)

	@@scan_buffer = ''

	end





	



  end



#####################################################################################

#	Dir Scan 

#

  

  def dscan(dir)

      

	d = Dir.open(dir.to_s)

	d = d.sort - @@ban

	

      d.each { |fichier|



      case File.ftype(dir+fichier)

        when "directory"

          self.dscan(dir + fichier + "/")

        when "file"

		  puts  'Scan => ' + dir + fichier 

          self.fscan(dir + fichier)

      end



	  }

  end



#####################################################################################

#	File Scan 

#

  

  def fscan(file)



	fichier = File.readlines(file)

	i = 1



	fichier.each { |line|

						

		@@regex.each  { |info|

			

			test = (line  =~ info['REGEX']) 

		

				if (test) 

			

				@@scan_buffer += ['FILE' => file, 'LINE' => i.to_s, 'MATCH' => line, 'LEVEL' => info['LEVEL'], 'TYPE' => info['TYPE']]

				#	5 , 1 , 3 , 4 , 2

				next @@scan_buffer

				end

		}



	i += 1

  	} 

	

  end



#####################################################################################

#	Output buffer

#

  

  def output(buffer)

  

	@html_hmodel = ''

	@html_hmodel += 'BScan v1.0
'



	code = @html_hmodel

	

	buffer.each { |infos|

	

	keys = infos.keys

	code += "" + keys[1].to_s + ' : ' + infos["TYPE"] + '
'

	code += "" + keys[3].to_s + ' : ' + infos["LEVEL"] + '
'

	code += "" + keys[4].to_s + ' : ' + infos["FILE"] + '
'

	code += "" + keys[0].to_s + ' : ' + infos["LINE"] + '
'

	code += "" + keys[2].to_s + ' : ' + infos["MATCH"] + '
'

	



	}

		code += ""

		fhtml = File.open(@@out_file.to_s, "w")

		fhtml.write code

		code = ''



	

  end

#####################################################################################

#	Parse & Get Options

#

 

  def options(param)

  

	i = 0

		ARGV.each  { |valeur|

		

    		if (valeur == '-' + param.to_s)

				return ARGV[i+1]

			elseif (valeur != '-' + param.to_s)

				return false

			end

		i += 1

		}

		

	end

  

end



scan = BScan.new

Automate the insertion of text into a file.

jrobertson (James Robertson) — Wed, 23 Jan 2008 15:19:09 GMT

This example updates an xsl file with a new xsl:include declaration, and with a javascript header declaration. It reads 'guide.xsl' as a text file, and reads the template 'guide_ptemplate.xml' as a rexml document.



#!/usr/bin/ruby

#file: create add2guide_xsl.rb



require 'rexml/document'

include REXML



class Add2GuideTxt

  def initialize

    @guide = 'guide.xsl'

    @guide_template = 'guide_ptemplate.xml'

  end

  

  def insertText(project)

    # read guide.txt and return the buffer

    buffer = readGuide(@guide)    

    replaceBuffer(project, buffer, @guide) if not buffer.match("")

  end

  

  def replaceBuffer(project, buffer, output_file)

    # read guide_ptemplate.xsl and return the doc

    doc = readGuideTemplate(@guide_template)    

    # read the xsl:include

    xsl_include = buildIncludeTemplate(project, doc)

    # read the xsl:if

    xsl_if = buildIfTemplate(project,doc)

    

    eoi = ""

    buffer = buffer.gsub(eoi, "#{xsl_include}\n" + eoi)

    eoj = ""

    buffer = buffer.gsub(eoj, "\n#{xsl_if}\n" + eoj)

    

    file = File.new(output_file,'w')

    file.puts buffer.gsub(""","'")

    file.close

  end

  

  def buildIncludeTemplate(project, doc)

    xsl_include = doc.root.elements['xsl:include']

    xsl_include.attributes['href'] = '/xsl/' + project + '.xsl'

    xsl_include

  end

  

  def buildIfTemplate(project, doc)

    xsl_if = doc.root.elements['xsl:if']

    xsl_if.attributes['test'] = project

    xsl_if.elements['script[3]'].text = 'const ProjectX = "' + project + '";'

    xsl_if

  end

  

  def readGuide(filename) 

    file = File.new(filename,'r')

    buffer = file.read

    file.close

    buffer

  end

  

  def readGuideTemplate(filename) 

    file = File.new(filename)

    Document.new(file)

  end

  

end



if __FILE__ == $0

  a2g = Add2GuideTxt.new

  #add the new project to the guide.xsl file  

  a2g.insertText('tasks')

end

file: guide.xsl (target file)

...

file: guide_ptemplate.xml (template used to insert blocks of code into guide.xsl)

words-like - Returns a block of words in the object that match the given pattern.

gregg.irwin (Gregg Irwin) — Sun, 01 Oct 2006 22:25:23 GMT



words-like: func [

    "Returns a block of words in the object that match the given pattern."

    object  [object!]

    pattern [word! any-string!]

    ;??? Add an /unbound refinement

][

    pattern: join form pattern "*"

    collect w [

        foreach word next first object [

            if find/match/any form word pattern [w: bind word in object 'self]

        ]

    ]

]

C# Reflection - Dealing with AmbiguousMatchException

Ozymandias () — Fri, 05 May 2006 17:15:39 GMT

C# code invoking a static method with reflection and dealing with an AmbiguousMatchException
Source: http://msdn2.microsoft.com/en-US/library/xthb9284.aspx





class Myambiguous {

    //The first overload is typed to an Int32

    public static void Mymethod (Int32 number){

       Console.Write("\n{0}", "I am from Int32 method");

    }



    //The second overload is typed to a string

    public static void Mymethod (string alpha) {

       Console.Write("\n{0}", "I am from a string.");

    }

    

    public static void Main() {

        try {

            //The following does not cause as exception

            Mymethod (2);  // goes to Mymethod (Int32)

            Mymethod ("3");   // goes to Mymethod (string)



            Type Mytype = Type.GetType("Myambiguous");



            MethodInfo Mymethodinfo32 = Mytype.GetMethod("Mymethod", new Type[]{typeof(Int32)});

            MethodInfo Mymethodinfostr = Mytype.GetMethod("Mymethod", new Type[]{typeof(System.String)});



            //Invoke a method, utilizing a Int32 integer

            Mymethodinfo32.Invoke(null, new Object[]{2});



            //Invoke the method utilizing a string

            Mymethodinfostr.Invoke(null, new Object[]{"1"});



            //The following line causes an ambiguious exception

            MethodInfo Mymethodinfo = Mytype.GetMethod("Mymethod");

        }  // end of try block

  

        catch(System.Reflection.AmbiguousMatchException theException) {

            Console.Write("\nAmbiguousMatchException message - {0}", theException.Message);

        }

        catch {

            Console.Write("\nError thrown");

        }

        return;

    }

}

 

 //This code produces the following output:

 //I am from Int32 method

 //I am from a string.

 //I am from Int32 method

 //I am from a string.

 //AmbiguousMatchException message - Ambiguous match found.

Return ordered list of near match items based on tag matches

offspinner () — Thu, 09 Feb 2006 21:41:00 GMT

// description of your code here



select t2.dbid, t2.tag, count(t2.dbid) as match_count from tags as t1, tags as t2 where t1.dbid = '105319' and t2.tag = t1.tag and t1.dbid != t2.dbid GROUP BY t2.dbid 1 ORDER BY match_count;