mme_tools 0.1.0

data/lib/mme_tools.rb

@@ -0,0 +1,18 @@
+# mme_tools
+# Marcel Massana 1-Sep-2011
+
+$: << File.dirname(__FILE__)
+
+require 'mme_tools/enumerable'
+require 'mme_tools/webparse'
+require 'mme_tools/debug'
+require 'mme_tools/concurrent'
+require 'mme_tools/config'
+require 'mme_tools/args_proc'
+
+#TODO translate all documentation to english
+
+# Comprises various classes and methods 
+module MMETools
+end
+

data/lib/mme_tools/args_proc.rb

@@ -0,0 +1,26 @@
+# NamedArgs
+# Marcel Massana 13-Sep-2011
+#
+# Extends Hash with methods based on ideas from
+# http://saaientist.blogspot.com/2007/11/named-arguments-in-ruby.html
+# Also thanks to ActiveSupport from Rails
+
+module MMETools
+
+  extend self
+
+  module ArgsProc
+
+    # Tests if +options+ includes only valid keys. Raises an error if
+    # any key is not included within +valid_options+.
+    # +valid_options+ is a Hash that must include all accepted keys. values
+    # aren't taken into account.
+    def assert_valid_keys(options, valid_options)
+      unknown_keys = options.keys - valid_options.keys
+      raise(ArgumentError, "Unknown options(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+    end
+
+
+  end
+
+end

data/lib/mme_tools/concurrent.rb

@@ -0,0 +1,52 @@
+# mme_tools/concurrent
+# Marcel Massana 1-Sep-2011
+
+require 'thread'
+
+module MMETools
+
+  # Concurrent classes (some method converted to concurrent versions)
+  module Concurrent
+
+    extend self
+
+    class ConcurrentHash < Hash
+
+      def initialize
+        super
+        @mutex = Mutex.new
+      end
+
+      def [](*args)
+        @mutex.synchronize { super }
+      end
+
+      def []=(*args)
+        @mutex.synchronize { super }
+      end
+    end
+
+    class ConcurrentArray < Array
+
+      def initialize
+        super
+        @mutex = Mutex.new
+      end
+
+      def [](*args)
+        @mutex.synchronize { super }
+      end
+
+      def []=(*args)
+        @mutex.synchronize { super }
+      end
+
+      def <<(*args)
+        @mutex.synchronize { super }
+      end
+
+    end
+
+  end
+
+end

data/lib/mme_tools/config.rb

@@ -0,0 +1,121 @@
+# config
+# Marcel Massana 11-Sep-2011
+#
+# A configuration class to tidy up setup of applications
+# http://mjijackson.com/2010/02/flexible-ruby-config-objects
+
+require 'yaml'
+
+module MMETools
+
+  #TODO try to overcome name conflicts with existent merhods (like dump) and with Upcase keys
+  #TODO mirar un gem que es diu construct. Fa el mateix. Igual es pot canviar
+
+  # Helps keeping configuration parameters, i.e. of any application, grouped
+  # within the same object. Also, it can be saved and restored from a YAML
+  # file easing edition of configuration very easily.
+  # First of all we should create an MMETools::Config object (see documentation)
+  #   config = MMETools::Config.new
+  # Configuration parametres could have any name and can be setted by
+  # assignation:
+  #   config.my_own_param = {:param => 'my own value'}
+  # Of course, their values can be of any type if they can be marshaled with
+  # yaml.
+  # To access those parameters we can use the obvious dot attribute way.
+  #   puts config.my_own_param  # => {:param => 'my own value'}
+  # but also it is possible to chain dots to access inner hashes, for instance:
+  #   puts config.my_own_param.param # => 'my_own_value'
+  class Config
+
+    # creates a MMETools::Config object to gracefully keep configuration
+    # parameters for any app. if a Hash +data+ is given it is used to populate
+    # it.
+    #   cfg = MMETools::Config.new(
+    #     :param1 => 1,
+    #     :param2 => 2
+    #   )
+    # If a +block+ is passed, it can be used to setup additional data. self is
+    # yielded tot tha block. For instance:
+    #   cfg = MMETools::Config.new do |c|
+    #     c.param1 = 1
+    #     c.param2 = 2
+    #   end
+    # Of course, both idioms can be combined though block is the last to be
+    # evaluated, so its actions may overwrite hash created config data.
+    def initialize(data={},&block)
+      @data = {}
+      update!(data)
+      yield(self) if block_given?
+    end
+
+    # updates kept configuration with +data+ (Hash or another MMETools::Config
+    # object. If a key already exists the corresponding value updates.
+    def update!(data)
+      # can't be used @data.merge because []= is differently defined (below)
+      case data
+      when Hash
+      when MMETools::Config
+        data = data.to_hash
+      else raise ArgumentError, "Only Hash objects or MMETools::Config objects admited"
+      end
+      data.each do |key, value|
+        self[key] = value
+      end
+    end
+
+    alias merge! update!
+
+    # creates a hash from a MMETools::Config object.
+    def to_hash
+      @data.inject({}) do |ac,(k,v)|
+        ac.merge! k => ((v.kind_of? self.class) ? v.to_hash : v)
+      end
+    end
+
+    def [](key)
+      @data[key.to_sym]
+    end
+
+    def []=(key, value)
+      if value.class == Hash
+        @data[key.to_sym] = Config.new(value)
+      else
+        @data[key.to_sym] = value
+      end
+    end
+
+    # loads a hash from YAML file +filename+ and merges its contents
+    def load(filename)
+      update! YAML.load_file(filename)
+    end
+
+    # creates a MMETools::Config object form an already dumped one.
+    # +filename+ is the name of the file containing configuration.
+    def self.load(filename)
+      obj = self.new
+      obj.load filename
+      obj
+    end
+
+    # saves configuration into a _yaml_ file named +filename+
+    def dump(filename)
+      File.open(filename,'w') do |f|
+        YAML.dump(self.to_hash,f)
+      end
+    end
+
+    alias save dump
+
+    private
+
+    def method_missing(sym, *args)
+      if sym.to_s =~ /(.+)=$/
+        self[$1] = args.first
+      else
+        self[sym]
+      end
+    end
+
+  end
+
+end

data/lib/mme_tools/debug.rb

@@ -0,0 +1,29 @@
+# mme_tools/debug
+# Marcel Massana 1-Sep-2011
+
+require 'pp'
+require 'thread'
+
+module MMETools
+
+  # tiny methods for debugging
+  module Debug
+
+    extend self
+
+    # outputs a debug message and details of each one of the +vars+ if included.
+    # +stck_lvls+ is the number of stack levels to be showed
+    # +vars+ is a list of vars to be pretty printed. It is convenient to
+    # make the first to be a String with an informative message.
+    def print_debug(stck_lvls, *vars)
+      @mutex ||= Mutex.new  # instance mutex created the first time it is called
+      referers = caller[0...stck_lvls] if stck_lvls > 0
+      @mutex.synchronize do
+        referers.each { |r| puts "#{r}:"}
+        vars.each { |v| pp v } if vars
+      end
+    end
+
+  end
+
+end

data/lib/mme_tools/enumerable.rb

@@ -0,0 +1,88 @@
+# mme_tools/enumerable
+# Marcel Massana 1-Sep-2011
+
+module MMETools
+
+  # Methods for Enumerables (Arrays and other each-enabled stuff)
+  module Enumerable
+
+    extend self
+
+    # torna un array on cada element es una tupla formada per
+    # un element de cada enumerable. Si se li passa un bloc
+    # se li passa al bloc cada tupla i el resultat del bloc
+    # s'emmagatzema a l'array tornat.
+    def compose(*enumerables)
+      res=[]
+      enumerables.map(&:size).max.times do
+        tupla=[]
+        for enumerable in enumerables
+          tupla << enumerable.shift
+        end
+        res << (block_given? ? yield(tupla) : tupla)
+      end
+      res
+    end
+
+    # Interessant iterador que classifica un enumerable
+    # (The Ruby Way , Ed. 2 - p 289)
+    def classify(enumrbl, &block)
+      hash = {}
+      enumrbl.each do |el|
+        res = block.call el # tb res=yield(el)
+        hash[res] = [] unless hash.has_key? res
+        hash[res] << el
+      end
+      hash
+    end
+
+    # FIXME I don't know really why I designed this ... possibly drop candidate
+    # returns an array containing from +first+ to +last+
+    # options is a hash that can contain:
+    # +:comp=>eq_method+ is a a symbol with the name of the method that sent to
+    #     an element with another element as parameter evaluates equality. If not
+    #     supplied +:==+ assumed.
+    # +:max=>max_num+ is the maximum size of the returned array. If not supplied
+    #     false assumed (no limit)
+    # +:last_included?=>true or false+ tells if +last+ should be included.
+    #     If not included +true+ assumed
+    # The code block is not optional: it is passed an element and should return
+    # the next.
+    def from_to(first, last, options=nil)
+      if options && options.is_a?(Hash)
+        maxcount = options.has_key?(:max) ? options[:max] : false
+        lastincluded = options.has_key?(:last_included?) ? options[:last_included?] : true
+      else
+        maxcount = false
+        lastincluded = true
+      end
+      ret = [first]
+      count = 1
+      while true
+        first = yield(first)
+        if first == last or (maxcount ? (count > maxcount) : false)
+          ret << first if lastincluded
+          break
+        end
+        ret << first
+      end
+      ret
+    end
+
+    # torna un array amb els elements parells
+    # mes a http://stackoverflow.com/questions/1614147/odd-or-even-entries-in-a-ruby-array
+    def odd_values(array)
+      array.values_at(* array.each_index.select {|i| i.odd?})
+      # array.select_with_index{|item, i| item if i % 2 == 1}
+    end
+
+    # torna un array amb els elements senars
+    # mes a http://stackoverflow.com/questions/1614147/odd-or-even-entries-in-a-ruby-array
+    def even_values(array)
+      array.values_at(* array.each_index.select {|i| i.even?})
+      # array.select_with_index{|item, i| item if i % 2 == 1}
+    end
+
+  end
+
+end

data/lib/mme_tools/version.rb

@@ -0,0 +1,16 @@
+# it's only a version number
+
+module MMETools
+
+  module Version
+
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+    BUILD = nil  # use nil if not used
+	
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join(".")
+
+  end
+
+end

data/lib/mme_tools/webparse.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+# mme_tools/webparse
+# Marcel Massana 1-Sep-2011
+
+require 'rubygems'
+require 'iconv'
+require 'unicode'
+require 'jcode' if RUBY_VERSION < '1.9'
+require 'date'
+
+# $KCODE = "u"
+
+module MMETools
+
+  # methods for processing strings while parsing webpages
+  module Webparse
+
+    extend self # elegant truc per a que tots els metodes siguin class/module methods 
+    
+    # torna una uri treient-hi les invocacions javascript si n'hi ha. Per exemple
+    #   "javascript:openDoc('/gisa/documentos/cartes/PT.DOC')" -> "/gisa/documentos/cartes/PT.DOC"
+    def clear_uri uri
+      case uri
+      when /Doc\('.*'\)/ then uri.match(/Doc\('(.*)'\)/).captures[0]
+      else uri
+      end
+    end
+
+    # treu els espais innecessaris i codis HTML d'enmig i extrems a un string
+    # neteja l'string eliminant tots els no printables dels extrems i els
+    # d'enmig els substitueiux per un unic espai.
+    # Les opcions +opts+ poden ser:
+    #   +:encoding+ => "ASCII" | "UTF8" (default)
+    #     "ASCII" converteix tots els caracters al mes semblant ASCII (amb Iconv)
+    #     "UTF8" torna una cadena UTF8
+    # (based on an idea of Obie Fernandez http://www.jroller.com/obie/tags/unicode)
+    def clear_string(str, opts={})
+      options = {:encoding=>'UTF8'}.merge opts  # default option :encoding=>'UTF8'
+      str=str.chars.map { |c| (c.bytes[0] <= 127) ? c : translation_hash[c] }.join if options[:encoding]=='ASCII'
+      str.gsub(/[\s\302\240]+/mu," ").strip # el caracter UTF8 "\302\240" correspon al &nbsp; de HTML
+    end
+    ## La versio original basada en Iconv no funciona en algunes circumstancies
+    #    def orig_clear_string(str, options={:encoding=>'UTF8'})
+    #      str=Iconv.conv('ASCII//TRANSLIT//IGNORE', 'UTF8', str) if options[:encoding]=='ASCII'
+    #      str.gsub(/[\s\302\240]+/mu," ").strip # el caracter UTF8 "\302\240" correspon al &nbsp; de HTML
+    #    end
+
+    # Intenta convertir +str+ a ASCII pur i dur
+    def asciify(str)
+      Iconv.conv('ASCII//TRANSLIT//IGNORE', 'UTF8', str)
+    end
+		
+    # Transforms a string +str+ to an acronym
+    def acronymize(str)
+      cleared_str = clear_string(str, :encoding => 'ASCII').gsub(/\W/," ")
+
+      # opcio 1
+      unwanted_words_pttrn = %w[de en].map {|w| "\\b#{w}\\b"}.join("|")
+      res = cleared_str.gsub(/\b\w\b|#{unwanted_words_pttrn}/i," ")
+      res = res.split(" ").map {|s| s[0..0].upcase}.join
+    
+      # opcio 2
+      if res == ""
+        res = cleared_str.split(" ").map {|s| s[0..0].upcase}.join
+      end
+      res
+    end
+	
+    # Transforms +str+ to a shortened version:
+    # strips all non-alphanumeric chars, non-ascii and spaces and joins every word
+    # first two letters capitalized
+    def shorten(str)
+      cleared_str = clear_string(str, :encoding => 'ASCII').gsub(/\W/," ")
+      cleared_str.split(" ").map {|s| s[0..1].capitalize}.join
+    end
+	
+    # Extracts and returns the first provable DateTime from a string
+    def datify(str)
+      pttrn = /(\d+)[\/-](\d+)[\/-](\d+)(\W+(\d+)\:(\d+))?/
+      day, month, year, dummy, hour, min = str.match(pttrn).captures.map {|d| d ? d.to_i : 0 }
+      case year
+      when 0..69
+        year += 2000
+      when 70..99
+        year += 1900
+      end
+      DateTime.civil year, month, day, hour, min
+    end
+	
+    protected
+
+    def translation_hash
+      @@translation_hash ||= setup_translation_hash
+    end
+
+    def setup_translation_hash
+      accented_chars   = "ÀÁÂÃÄÅÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝàáâãäåçèéêëìíîïñòóôõöøùúûüý".chars.map{|c| c}
+      unaccented_chars = "AAAAAACEEEEIIIIDNOOOOOxOUUUUYaaaaaaceeeeiiiinoooooouuuuy".split('')
+
+      translation_hash = {}
+      accented_chars.each_with_index { |char, idx| translation_hash[char] = unaccented_chars[idx] }
+      translation_hash["Æ"] = 'AE'
+      translation_hash["æ"] = 'ae'
+      translation_hash
+    end
+
+  end
+
+end