ruote-maestrodev 2.2.1

data/lib/ruote/util/hashdot.rb

@@ -0,0 +1,79 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# 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.
+#
+# Made in Japan.
+#++
+
+
+module Ruote
+
+  module HashDot
+
+    def method_missing(m, *args)
+
+      m = m.to_s
+
+      if m[-1, 1] == '='
+
+        val = args.first
+        self[m[0..-2]] = val
+
+        return val
+      end
+
+      self[m]
+    end
+
+    def dump
+
+      s = "~~ h ~~\n"
+      each do |k, v|
+        s << "  * '#{k}' => "
+        s << v.inspect
+        s << "\n"
+      end
+      s << "~~ . ~~"
+    end
+
+    #--
+    # Useful when debugging some 'stack too deep' issue
+    #
+    #def self.included(target)
+    #  raise target.to_s unless target.to_s.match(/\bHash\b/)
+    #end
+    #++
+  end
+
+  module WithH
+
+    def self.included(target)
+
+      def target.h_reader(*names)
+        names.each do |name|
+          define_method(name) do
+            @h[name.to_s]
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/ruote/util/look.rb

@@ -0,0 +1,128 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# 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.
+#
+# Made in Japan.
+#++
+
+
+module Ruote
+
+  #
+  # Some methods for looking at system/runtime things.
+  #
+  module Look
+
+    def self.lsof
+
+      `lsof -p #{$$}`
+    end
+
+    def self.dump_lsof
+
+      result = lsof
+
+      puts '= lsof =' + '=' * 71
+      puts result
+      puts result.split("\n").size
+      puts '=' * 80
+    end
+
+    def self.dump_lsof_count
+
+      puts '= lsof count =' + '=' * 65
+      puts lsof.split("\n").size
+      puts '=' * 80
+    end
+  end
+
+  #
+  # Some utilities for mem usage analysis
+  #
+  module Mem
+
+    # Returns a Hash : classname => [ count, maxsize, totalsize, avgsize ]
+    #
+    # The relative size of an object is computed with Marshal.dump(o).size
+    #
+    # This uses ObjectSpace.
+    #
+    # see http://www.ruby-forum.com/topic/186339 for better options.
+    #
+    def self.count
+
+      uninteresting = [
+        Array, String, Hash, Set, Module, Range, Float, Bignum
+      ]
+
+      h = {}
+
+      ObjectSpace.each_object do |o|
+
+        next if uninteresting.include?(o.class)
+
+        stats = h[o.class.to_s] ||= [ 0, 0, 0 ]
+        size = (Marshal.dump(o).size rescue 1)
+
+        stats[0] += 1
+        stats[1] = size if size > stats[1]
+        stats[2] += size
+      end
+
+      a = h.to_a
+      a.each { |k, v| v << v[2] / v[0] }
+
+      a.sort { |x, y| x.last[1] <=> y.last[1] }.reverse
+    end
+
+    # Very naive : does a "ps aux | grep pid".
+    #
+    # Returns a hash like this one :
+    #
+    #   {
+    #     :user => "jmettraux",
+    #     :pid => "1100",
+    #     :cpu => "73.0",
+    #     :mem => "0.8",
+    #     :vsz => "2472732",
+    #     :rss => "35308",
+    #     :tt => "s001",
+    #     :stat => "S+",
+    #     :started => "8:55PM",
+    #     :time => "0:01.05",
+    #     :command => "ruby start.rb"
+    #   }
+    #
+    def self.ps
+
+      s = `ps aux | egrep '^.+ +#{$$} '`.split(' ')
+      s[10] = s[10..-1].join(' ') # the command
+
+      h = {}
+
+      %w[
+        user pid cpu mem vsz rss tt stat started time command
+      ].each_with_index { |k, i| h[k.to_sym] = s[i] }
+
+      h
+    end
+  end
+end
+

data/lib/ruote/util/lookup.rb

@@ -0,0 +1,127 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# 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.
+#
+# Made in Japan.
+#++
+
+
+module Ruote
+
+  #   h = { 'a' => { 'b' => [ 1, 3, 4 ] } }
+  #
+  #   p Ruote.lookup(h, 'a.b.1') # => 3
+  #
+  def Ruote.lookup(collection, key, container_lookup=false)
+
+    return collection if key == '.'
+
+    key, rest = pop_key(key)
+    value = fetch(collection, key)
+
+    return [ key, collection ] if container_lookup && rest.size == 0
+    return [ rest.first, value ] if container_lookup && rest.size == 1
+    return value if rest.size == 0
+    return nil if value == nil
+
+    lookup(value, rest, container_lookup)
+  end
+
+  #   h = { 'customer' => { 'name' => 'alpha' } }
+  #
+  #   Ruote.set(h, 'customer.name', 'bravo')
+  #
+  #   h #=> { 'customer' => { 'name' => 'bravo' } }
+  #
+  def Ruote.set(collection, key, value)
+
+    k, c = lookup(collection, key, true)
+
+    if c
+      k = k.to_i if c.is_a?(Array)
+      c[k] = value
+    else
+      collection[key] = value
+    end
+  end
+
+  #   h = { 'customer' => { 'name' => 'alpha', 'rank' => '1st' } }
+  #   r = Ruote.unset(h, 'customer.rank')
+  #
+  #   h # => { 'customer' => { 'name' => 'alpha' } }
+  #   r # => '1st'
+  #
+  def Ruote.unset(collection, key)
+
+    k, c = lookup(collection, key, true)
+
+    if c.nil?
+      collection.delete(key)
+    elsif c.is_a?(Array)
+      c.delete_at(Integer(k)) rescue nil
+    elsif c.is_a?(Hash)
+      c.delete(k)
+    else
+      nil
+    end
+  end
+
+  protected # well...
+
+  # Pops the first key in a path key.
+  #
+  #   Ruote.pop_key('a.b.c') # => 'a'
+  #   Ruote.pop_key('1.2.3') # => 1
+  #
+  # (note the narrowing to an int that happens)
+  #
+  def Ruote.pop_key(key)
+
+    ks = key.is_a?(String) ? key.split('.') : key
+
+    [ narrow_key(ks.first), ks[1..-1] ]
+  end
+
+  # Attempts at turning a key into an integer, if it fails returns the
+  # original key.
+  #
+  def Ruote.narrow_key(key)
+
+    Integer(key) rescue key
+  end
+
+  # Given a collection and a key returns the corresponding value
+  #
+  #   Ruote.fetch([ 12, 13, 24 ], 1) # => 13
+  #   Ruote.fetch({ '1' => 13 }, 1) # => 13
+  #   Ruote.fetch({ 1 => 13 }, 1) # => 13
+  #
+  def Ruote.fetch(collection, key)
+
+    value = (collection[key] rescue nil)
+
+    if value == nil and key.is_a?(Fixnum)
+      (collection[key.to_s] rescue nil)
+    else
+      value
+    end
+  end
+end
+

data/lib/ruote/util/misc.rb

@@ -0,0 +1,167 @@
+#--
+# Copyright (c) 2005-2011, John Mettraux, jmettraux@gmail.com
+#
+# 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.
+#
+# Made in Japan.
+#++
+
+
+module Ruote
+
+  # Will be set to true if the Ruby runtime is on Windows
+  #
+  WIN = (RUBY_PLATFORM.match(/mswin|mingw/) != nil)
+
+  # Will be set to true if the Ruby runtime is JRuby
+  #
+  JAVA = (RUBY_PLATFORM.match(/java/) != nil)
+
+  # Prints the current call stack to stdout
+  #
+  def self.p_caller(*msg)
+
+    puts
+    puts "  == #{msg.inspect} =="
+    caller(1).each { |l| puts "  #{l}" }
+    puts
+  end
+
+  # Deep object duplication
+  #
+  def self.fulldup(object)
+
+    return object.fulldup if object.respond_to?(:fulldup)
+      # trusting client objects providing a fulldup() implementation
+      # Tomaso Tosolini 2007.12.11
+
+    begin
+      return Marshal.load(Marshal.dump(object))
+        # as soon as possible try to use that Marshal technique
+        # it's quite fast
+    rescue TypeError => te
+    end
+
+    #if object.is_a?(REXML::Element)
+    #  d = REXML::Document.new object.to_s
+    #  return d if object.kind_of?(REXML::Document)
+    #  return d.root
+    #end
+      # avoiding "TypeError: singleton can't be dumped"
+
+    o = object.class.allocate
+
+    # some kind of collection ?
+
+    if object.is_a?(Array)
+      object.each { |i| o << fulldup(i) }
+    elsif object.is_a?(Hash)
+      object.each { |k, v| o[fulldup(k)] = fulldup(v) }
+    end
+
+    # duplicate the attributes of the object
+
+    object.instance_variables.each do |v|
+      value = object.instance_variable_get(v)
+      value = fulldup(value)
+      begin
+        o.instance_variable_set(v, value)
+      rescue => e
+        # ignore, must be readonly
+      end
+    end
+
+    o
+  end
+
+  # Returns true if the string seems to correpond to a URI
+  #
+  # TODO : wouldn't it be better to simply use URI.parse() ?
+  #
+  def self.is_uri?(s)
+
+    s && (s.index('/') || s.match(/\.[^ ]+$/))
+  end
+
+  # Returns a neutralized version of s, suitable as a filename.
+  #
+  def self.neutralize(s)
+
+    s.to_s.strip.gsub(/[ \/:;\*\\\+\?]/, '_')
+  end
+
+  # Tries to return an Integer or a Float from the given input. Returns
+  #
+  def self.narrow_to_number(o)
+
+    return o if [ Fixnum, Bignum, Float ].include?(o.class)
+
+    s = o.to_s
+
+    (s.index('.') ? Float(s) : Integer(s)) rescue nil
+  end
+
+  # (simpler than the one from active_support)
+  #
+  def self.constantize(s)
+
+    s.split('::').inject(Object) { |c, n| n == '' ? c : c.const_get(n) }
+  end
+
+  # Makes sure all they keys in the given hash are turned into strings
+  # in the resulting hash.
+  #
+  def self.keys_to_s(h)
+
+    h.inject({}) { |h, (k, v)| h[k.to_s] = v; h }
+  end
+
+#  # Upon receiving something like
+#  #
+#  #   "(?-mix:nada)"
+#  #
+#  # will return
+#  #
+#  #   /nada/
+#  #
+#  def self.regex_from_s(s)
+#
+#    if s.is_a?(String) && m = s.match(/^\(\?-mix:(.+)\)$/)
+#      Regexp.new(m[1])
+#    else
+#      nil
+#    end
+#  end
+
+  REGEX_IN_STRING = /^\s*\/(.*)\/\s*$/
+
+  #   regex_or_s("/nada/") #==> /nada/
+  #   regex_or_s("nada") #==> "nada"
+  #   regex_or_s(/nada/) #==> /nada/
+  #
+  def self.regex_or_s(s)
+
+    if s.is_a?(String) && m = REGEX_IN_STRING.match(s)
+      Regexp.new(m[1])
+    else
+      s
+    end
+  end
+end
+