woe/sitef/sitef.go

package sitef

import "os"
import "io"
import "strings"
import "fmt"
import "bytes"
import "bufio"
import "strconv"
import "reflect"
import "errors"
import "github.com/beoran/woe/monolog"


// Sitef format for serialization
// Sitef is a simple text format for serializing data to
// It's intent is to be human readable and easy to 
// use for multi line text.
// It is quite similar to recfiles, though not compatible because 
// in sitef files the first character on the line determines the meaning, 
// and there is no backslash escaping.
//
// Sitef is a line based syntax where the first character on the line
// determines the meaning of the line.
// Several lines together form a record.
// A line that starts with # is a comment. There may be no whitespace
// in front of the comment.
// A newline character by itself (that is, an empty line), 
// or a - ends a record.
// A plus character, an escape on the previous line or a tab or 
// a space continues a value.
// A Continues value gets a newline inserted only when a space or tab was used.
// + supresses the newline.
// Anything else signifies the beginning of the next key.
// % is allowed for special keys for recfile compatibility.  
// However % directives are not implemented.
// Keys may not be nested, however, you could use spaces or dots, 
// or array indexes to emulate nexted keys. 
// A # at the start optionally after whitespace is a comment
// 

type Record struct { 
        dict map[string]string
        order []string
}

func NewRecord() (* Record) {
    rec := &Record{}
    rec.dict  = make(map[string]string)
    rec.order = make([]string, 0)
    return rec
}

func (me * Record) Put(key string, val string) {
    me.order = append(me.order, key)
    me.dict[key] = val
}

func (me * Record) Putf(key string, format string, values ...interface{}) {
    me.Put(key, fmt.Sprintf(format, values...))
    monolog.Debug("After putf: %s %v", key, me.order)
}

func (me * Record) PutArrayIndex(key string, index int, value string) {
    realkey := fmt.Sprintf("%s[%d]", key, index)
    me.Put(realkey, value)
} 

func (me * Record) PutArray(key string, values []string) {
    for i, value := range values {
        me.PutArrayIndex(key, i, value)
    }
} 

func (me * Record) PutInt(key string, val int) {
    me.Putf(key, "%d", val)
}


func (me * Record) PutInt64(key string, val int64) {
    me.Putf(key, "%d", val)
}

func (me * Record) PutFloat64(key string, val float64) {
    me.Putf(key, "%lf", val)
}

func (me Record) MayGet(key string) (result string, ok bool) {
    result, ok = me.dict[key]
    return result, ok
}


func (me Record) Get(key string) (result string) {
    result= me.dict[key]
    return result
}

func (me * Record) GetArrayIndex(key string, i int) (result string) {
    realkey := fmt.Sprintf("%s[%d]", key, i)
    return me.Get(realkey)
}


func (me Record) Getf(key string, format string, 
    values ...interface{}) (amount int, ok bool) {
    val := me.Get(key)
    count, err := fmt.Sscanf(val, format, values...)
    if err != nil {
        return 0, false
    }
    return count, true
}

func (me Record) GetInt(key string) (val int, err error) {
    i, err := strconv.ParseInt(me.Get(key), 0, 0)
    return int(i), err
}

func (me Record) GetIntDefault(key string, def int) (val int) {
    i, err := strconv.ParseInt(me.Get(key), 0, 0)
    if err != nil {
        return def;
    }
    return int(i);
}


func (me Record) GetFloat(key string) (val float64, error error) {
    return strconv.ParseFloat(me.Get(key), 64)
}

func (me * Record) convSimple(typ reflect.Type, val reflect.Value) (res string, err error) {
    switch val.Kind() {
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    return strconv.FormatInt(val.Int(), 10), nil
        
    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
    return strconv.FormatUint(val.Uint(), 10), nil
    
    case reflect.Float32, reflect.Float64:
    return strconv.FormatFloat(val.Float(), 'g', -1, val.Type().Bits()), nil
    case reflect.String:
    return val.String(), nil
    case reflect.Bool:
    return strconv.FormatBool(val.Bool()), nil
    default: 
    return "", errors.New("Unsupported type")
    }
}


func (me * Record) PutValue(key string, value reflect.Value) {

    monolog.Debug("PutValue: %s %v", key, value)

    stringer, ok := value.Interface().(fmt.Stringer)
    if ok {
        me.Put(key, stringer.String())
        return
    }
    
    switch (value.Kind()) {
        case reflect.Int, reflect.Int32, reflect.Int64:
            me.Putf(key, "%d", value.Int())
        case reflect.Uint, reflect.Uint32, reflect.Uint64:
            me.Putf(key, "%d", value.Uint())
        case reflect.Float32, reflect.Float64:
            me.Putf(key, "%f", value.Float())
        case reflect.String:
            me.Putf(key, "%s", value.String())
        case reflect.Struct:
            me.PutStruct(key + ".", value.Interface());
        default:
            me.Put(key, "???")
    }
    
    monolog.Debug("Put: key %s value %s, result %v", key, value, me) 
    
}

func (me * Record) PutStruct(prefix string, structure interface {}) {
    st := reflect.TypeOf(structure)
    vt := reflect.ValueOf(structure)
    
    for i:= 0 ; i < st.NumField() ; i++ {
        field := st.Field(i)
        key := strings.ToLower(field.Name)
        value :=  vt.Field(i)
        me.PutValue(prefix + key, value)
    }
}


func (me Record) GetValue(key string, value reflect.Value) (err error){
    /*stringer, ok := value.Interface().(fmt.Stringer)
    if ok {
        me.Gut(key, stringer.String())
        return
    }*/
    monolog.Debug("GetValue: %s %v", key, value)
    
    switch (value.Kind()) {
        case reflect.Int, reflect.Int32, reflect.Int64:
            value.SetInt(int64(me.GetIntDefault(key, 0)))
        case reflect.Uint, reflect.Uint32, reflect.Uint64:
            value.SetUint(uint64(me.GetIntDefault(key, 0)))
        case reflect.Float32, reflect.Float64:
            f, err := me.GetFloat(key)
            if (err != nil) { 
                return err
            }
            value.SetFloat(f)
        case reflect.String:
            s, ok := me.MayGet(key)
            if (!ok) {
                return fmt.Errorf("Could not get string for key %s", key)
            }
            value.SetString(s)
        case reflect.Struct:
            me.GetStruct(key + ".", value.Addr().Interface());
        default:
            monolog.Warning("Don't know what to do with %v", value)
    }
    return nil
}


func (me Record) GetStruct(prefix string, structure interface {}) {
    monolog.Info("GetStruct: structure %v, %v\n", structure, 
        reflect.TypeOf(structure))
    
    st := reflect.TypeOf(structure).Elem()
    vt := reflect.Indirect(reflect.ValueOf(structure))
    monolog.Info("GetStruct: type %v value %v\n", st, vt)
    
    for i:= 0 ; i < st.NumField() ; i++ {
        field := st.Field(i)
        key := prefix + strings.ToLower(field.Name)
        value :=  reflect.Indirect(vt).Field(i)
        me.GetValue(key, value)
    }
}


type Error struct {
    error   string
    lineno  int
}

func (me Error) Error() string {
    return fmt.Sprintf("%d: %s", me.Lineno, me.error)
}

func (me Error) Lineno() int {
    return me.lineno
}


type ParserState int

const (
    PARSER_STATE_INIT   ParserState = iota
    PARSER_STATE_KEY
    PARSER_STATE_VALUE
)

type RecordList []*Record


func ParseReader(read io.Reader) (RecordList, error) {
    var records     RecordList
    record      := NewRecord()
    var err         Error
    lineno      := 0
    scanner     := bufio.NewScanner(read)
    var key     bytes.Buffer
    var value   bytes.Buffer
    
    
    for scanner.Scan() {
        lineno++
        line := scanner.Text()
        // End of record?
        if (len(line) < 1) || line[0] == '-' {
            // Append last record if needed. 
            if len(key.String()) > 0 {
                record.Put(key.String(), value.String())
            }
            // save the record and make a new one
            records = append(records, record)
            record  = NewRecord()
        // comment?
        } else if line[0] == '#' {
            continue; 
        // continue value?
        } else if line[0] == '\t' || line[0] == ' '|| line[0] == '+' {
            
            /* Add a newline unless + is used */
            if (line[0] != '+') {
                value.WriteRune('\n')          
            }
            
            // continue the value, skipping the first character
            value.WriteString(line[1:])            
        // new key
        } else if strings.ContainsRune(line, ':') {
            // save the previous key/value pair if needed
            if len(key.String()) > 0 {
                record.Put(key.String(), value.String())
            }
            
            key.Reset()
            value.Reset()

            parts := strings.SplitN(line, ":", 2)
                            
            key.WriteString(parts[0])
            if len(parts) > 1 {
               value.WriteString(parts[1])   
            }            
        // Not a key. Be lenient and assume this is a continued value.
        } else {
            value.WriteString(line)   
        }
    }
    
    // Append last record if needed. 
    if len(key.String()) > 0 {
        record.Put(key.String(), value.String())
    }
    
    if (len(record.order) > 0) {
        records = append(records, record)
    }

    

    if serr := scanner.Err(); serr != nil {
       err.lineno = lineno
       err.error  = serr.Error()
       monolog.Error("Sitef parse error: %d %s", lineno, serr.Error) 
       return records, err
    }
    
    return records, nil
    
}

func ParseFilename(filename string) (RecordList, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    return ParseReader(file)
}

func WriteField(writer io.Writer, key string, value string) {
    monolog.Debug("WriteField %s:%s", key, value)
    replacer := strings.NewReplacer("\n", "\n\t")    
    writer.Write([]byte(key))
    writer.Write([]byte{':'})    
    writer.Write([]byte(replacer.Replace(value)))
    writer.Write([]byte{'\n'})
}

func WriteRecord(writer io.Writer, record Record) {
    monolog.Debug("WriteRecord %v", record)

    for index := 0 ; index < len(record.order) ; index++ {
        key := record.order[index];
        value := record.dict[key];
        WriteField(writer, key, value);
    }
    writer.Write([]byte{'-', '-', '-', '-', '\n'})
}

func WriteRecordList(writer io.Writer, records RecordList) {
    for _, record := range records {
        WriteRecord(writer, *record);
    }
}


func SaveRecord(filename string, record Record) (error) {
    file, err := os.Create(filename)
    if err != nil {
        monolog.WriteError(err)
        return err
    }
    defer file.Close()
    WriteRecord(file, record)
    return nil
}



func SaveRecordList(filename string, records RecordList) (error) {
    file, err := os.Create(filename)
    if err != nil {
        return err
    }
    defer file.Close()
    WriteRecordList(file, records)
    return nil
}


/*
func ParseFile(file)
    lineno   = 0
    results  = []
    errors   = []
    
    record   = {}
    key      = nil
    value    = nil
    until file.eof?
      lineno     += 1 
      line        = file.gets(256)
      break if line.nil?
      next if line.empty? 
      // new record
      if line[0,2] == '--' 
        // Store last key used if any.
        if key          
          record[key] = value.chomp
          key = nil
        end  
        results << record
        record = {}
      elsif line[0] == '//'
      // Comments start with //
      elsif line[0] == ':'
      // a key/value pair
      key, value  = line[1,line.size].split(':', 2)
      record[key] = value.chomp
      key = value = nil
      elsif line[0, 2] == '..'
      // end of multiline value 
      record[key] = value.chomp
      key = value = nil
      elsif (line[0] == '.') && key.nil?
      // Multiline key/value starts here (but is ignored 
      // until .. is encountered)
      key   = line[1, line.size]
      key.chomp!
      value = ""
      // multiline value
      elsif key
          if line[0] == '\\'
            // remove any escapes
            line.slice!(0)
          end
          // continue the value
          value << line
      else
          // Not in a key, sntax error.
          errors << "//{lineno}: Don't know how to process line"
      end      
    end
    // Store last key used if any.
    if key      
      record[key] = value.chomp
    end  
    // store last record 
    results << record unless record.empty?
    return results, errors
  end  
  
  func load_filename(filename)
    results, errors = nil, nil, nil;
    file = File.open(filename, 'rt') rescue nil
    return nil, ["Could not open //{filename}"] unless file
    begin 
      results, errors = parse_file(file)
    ensure
      file.close
    end
    return results, errors
  end
  
  // Loads a Sitef fileas obejcts. Uses the ruby_klass atribute to load the object
  // If that is missing, uses defklass
  func load_objects(filename, defklass=nil)
    results, errors = load_filename(filename)
    p filename, results, errors
    unless errors.nil? || errors.empty?
      return nil, errors 
    end
    
    objres = [] 
    results.each do | result |
      klassname = result['ruby_class'] || defklass
      return nil unless klassname
      klass = klassname.split('::').inject(Kernel) { |klass, name| klass.const_get(name) rescue nil } 
      return nil unless klass
      if klass.respond_to? :from_sitef
        objres << klass.from_sitef(result)
      else
        objres << klass.new(result)
      end      
    end
    return objres, errors    
  end
  
  
  // Saves a single field to a file in Sitef format.
  func save_field(file, key, value)
    if value.is_a? String
      sval = value.dup
    else
      sval = value.to_s
    end
    if sval["\n"]
      file.puts(".//{key}\n")
      // Escape everything that could be misinterpreted with a \\
      sval.gsub!(/\n([\.\-\:\//\\]+)/, "\n\\\\\\1")
      sval.gsub!(/\A([\.\-\:\//\\]+)/, "\\\\\\1")
      file.printf("%s", sval)
      file.printf("\n..\n")
    else
      file.printf("://{key}://{sval}\n")
    end
  end
  
  func save_object(file, object, *fields)
    save_field(file, :ruby_class, object.class.to_s)
    fields.each do | field |
      value = object.send(field.to_sym)
      save_field(file, field, value)
    end
  end
  
  func save_record(file, record, *fields)
    record.each do | key, value |
      next if fields && !fields.empty? && !fields.member?(key)
      save_field(file, key, value)
    end
  end

  func save_file(file, records, *fields)
    records.each do | record |
      if record.is_a? Hash
        save_record(file, record, *fields)
      else 
        save_object(file, record, *fields)
      end
      file.puts("--\n")
    end
  end
  
  func save_filename(filename, records, *fields)
    results , errors = nil, nil
    file = File.open(filename, 'wt')
    return false, ["Could not open //{filename}"] unless file
    begin 
      save_file(file, records, *fields)
    ensure
      file.close
    end
    return true, []
  end
  
end

*/