[RUBY]Chitat

#-// 05/11/2012
#-// 06/02/2012
#-inject gen_module_header 'Chitat'
module Chitat
  STRS_TRUE  = ["TRUE","YES","ON","T","Y"]
  STRS_FALSE = ["FALSE","NO","OFF","F","N"]
  STRS_BOOL  = STRS_TRUE + STRS_FALSE
  module Regexp
    BOOL = /(?:#{STRS_BOOL.join(?|)})/i
    INT = /\d+/
    FLT = /\d+\.\d+/
  end
  def self.obj2str(obj)
    String(obj)
  end
  def self.str2bool(str)
    case str.upcase
    when *STRS_TRUE  ; true
    when *STRS_FALSE ; false
    else             ; nil
    end
  end
  def self.str2int(str)
    Integer(str)
  end
  def self.str2flt(str)
    Float(str)
  end
  def self.str2int_a(str)
    str.scan(/\d+/).map!(&:to_i)
  end
  def self.str2array(str)
    str.split(?,)
  end
  def self.str2obj(str,type=:nil)
    case type
    when :int, :integer ; str2int(str)
    when :flt, :float   ; str2flt(str)
    when :bool,:boolean ; str2bool(str)
    when :str, :string  ; str.to_s
    else # // Guess type
      if str =~ Regexp::FLT
        str2flt(str)
      elsif str =~ Regexp::INT
        str2int(str)
      elsif str =~ Regexp::BOOL_REGEX
        str2bool(str)
      else # // String
        str.to_s
      end
    end
  end
  @data_types = {
    # // [keywords..] => proc { |s| parse_to_proper_type }
    ["string" ,"str" ]=> proc {|*args|args.map!(&:to_s) },
    ["integer","int" ]=> proc {|*args|args.map!(&:to_i) },
    ["boolean","bool"]=> proc {|*args|args.collect{|s|str2bool(s)}},
    ["float"  ,"flt" ]=> proc {|*args|args.map!(&:to_f) },
    ["hex"]           => proc {|*args|args.map!(&:hex)}
  }
  @structs ||= {
  }
  @data_types.merge(@structs)
  str = "(a-)?(%s):(.*)" % @data_types.keys.collect{|a|"(?:"+a.join(?|)+?)}.join(?|)
  DTREGEX = /#{str}/i
  @data_types.enum2keys!
  # // Notebox
  class Note ; end
  class Note::Folder
    class Stack < Array
      attr_reader :match_data
      def initialize(match_data,*args,&block)
        @match_data = match_data
        super *args,&block
      end
    end
    attr_accessor :open_tag,:close_tag
    def initialize(open_tag=nil,close_tag=nil)
      @open_tag,@close_tag = open_tag,close_tag
    end
    def mk_and_set_tag(str)
      @open_tag,@close_tag = /<#{str}>/i,/<\/#{str}>/i
      self
    end
    def parse_str(str)
      lines  = str.split(/[\r\n]+/i)
      i,line,result,arra = 0, nil,[],[]
      while(i < lines.size)
        line = lines[i]
        if mtch = line.match(@open_tag)
          i += 1
          while true
            line = lines[i]
            break if line =~ @close_tag
            result << line
            i += 1
            raise "End of note reached!" if(i > lines.size)
          end
          arra << Stack.new(mtch,result); result = []
        end
        i += 1
      end
      arra
    end
  end
  TAG_REGEXP = /(.+):\s*(.+)/
  def self.parse_knv_str(tag,types=[:nil],has_array=false)
    types = Array(types)
    mtch = tag.match TAG_REGEXP
    return nil unless mtch
    key,value = mtch[1,2]
    values = (has_array ? value.split(?,) : Array(value)).each_with_index.to_a.collect{|(n,index)|value2obj(n,types[index]||:nil)}
    return key, values
  end
  # // Chitat Main
  def self.parse_dtstr(dtstr,return_type=:value)
    mtch = dtstr.match DTREGEX
    raise "Malformed Data String %s" % dtstr unless mtch
    is_array, dt_type, value = mtch[1,3]
    return is_array, dt_type if return_type == :data_type
    is_array = !!is_array
    parser = @data_types[dt_type.downcase]
    #puts "is_array?[%s] dt_type[%s] value[%s]" % [is_array, dt_type, value]
    value = parser.call(is_array ? value.split(?,) : Array(value))
    value if return_type == :value
    return is_array, dt_type, value
  end
  def self.obj_data_type(obj)
    case obj
    when Float     ; "flt"
    when Numeric   ; "int"
    when String    ; "str"
    when true,false; "bool"
    else           ; nil
    end
  end
  def self.obj2dtstr(obj)
    if obj.is_a?(Array)
      "%s:%s" % obj.join(?,)
    else
      type = obj_data_type(obj)
      type ? "%s:%s" % [type,obj] : nil
    end
  end
end