many things: head, any, encodingemitter, copy, flushfwd

Author: keks

any_test.go

@@ -0,0 +1,69 @@
+package cmds
+
+import (
+	"encoding/json"
+	"io"
+	"strings"
+	"testing"
+)
+
+type Foo struct {
+	Bar int
+}
+
+type Bar struct {
+	Foo string
+}
+
+type ValueError struct {
+	Error error
+	Value interface{}
+}
+
+type anyTestCase struct {
+	Types   []interface{}
+	JSON    string
+	Decoded []ValueError
+}
+
+func TestMaybe(t *testing.T) {
+	testcases := []anyTestCase{
+		anyTestCase{
+			Types: []interface{}{Foo{}, &Bar{}},
+			JSON:  `{"Bar":2}{"Foo":"abc"}`,
+			Decoded: []ValueError{
+				ValueError{Error: nil, Value: Foo{2}},
+				ValueError{Error: nil, Value: Bar{"abc"}},
+			},
+		},
+	}
+
+	for _, tc := range testcases {
+		a := &Any{}
+
+		for _, t := range tc.Types {
+			a.Add(t)
+		}
+
+		r := strings.NewReader(tc.JSON)
+		d := json.NewDecoder(r)
+
+		var err error
+
+		for _, dec := range tc.Decoded {
+			err = d.Decode(a)
+			if err != dec.Error {
+				t.Fatalf("error is %v, expected %v", err, dec.Error)
+			}
+
+			if a.Interface() != dec.Value {
+				t.Fatalf("value is %#v, expected %#v", a.Interface(), dec.Value)
+			}
+		}
+
+		err = d.Decode(a)
+		if err != io.EOF {
+			t.Fatal("data left in decoder:", a.Interface())
+		}
+	}
+}

chan.go

@@ -34,18 +34,34 @@ type chanResponse struct {
 }
 
 func (r *chanResponse) Request() *Request {
+	if r == nil {
+		return nil
+	}
+
 	return r.req
 }
 
 func (r *chanResponse) Error() *cmdsutil.Error {
+	if r == nil {
+		return nil
+	}
+
 	return r.err
 }
 
 func (r *chanResponse) Length() uint64 {
+	if r == nil {
+		return 0
+	}
+
 	return r.length
 }
 
 func (r *chanResponse) Next() (interface{}, error) {
+	if r == nil {
+		return nil, io.EOF
+	}
+
 	v, ok := <-r.ch
 	if ok {
 		return v, nil
@@ -65,9 +81,11 @@ type chanResponseEmitter struct {
 
 func (re *chanResponseEmitter) SetError(err interface{}, t cmdsutil.ErrorType) {
 	// don't change value after emitting
-	if re.emitted {
-		return
-	}
+	/*
+		if re.emitted {
+			return
+		}
+	*/
 
 	*re.err = &cmdsutil.Error{Message: fmt.Sprint(err), Code: t}
 }
@@ -81,6 +99,13 @@ func (re *chanResponseEmitter) SetLength(l uint64) {
 	*re.length = l
 }
 
+func (re *chanResponseEmitter) Head() Head {
+	return Head{
+		Len: *re.length,
+		Err: *re.err,
+	}
+}
+
 func (re *chanResponseEmitter) Close() error {
 	close(re.ch)
 	re.ch = nil

cmdsutil/option_test.go

@@ -7,7 +7,7 @@ import (
 
 func TestOptionValueExtractBoolNotFound(t *testing.T) {
 	t.Log("ensure that no error is returned when value is not found")
-	optval := &OptionValue{found: false}
+	optval := &OptionValue{ValueFound: false}
 	_, _, err := optval.Bool()
 	if err != nil {
 		t.Fatal("Found was false. Err should have been nil")
@@ -18,13 +18,13 @@ func TestOptionValueExtractWrongType(t *testing.T) {
 
 	t.Log("ensure that error is returned when value if of wrong type")
 
-	optval := &OptionValue{value: "wrong type: a string", found: true}
+	optval := &OptionValue{Value: "wrong type: a string", ValueFound: true}
 	_, _, err := optval.Bool()
 	if err == nil {
 		t.Fatal("No error returned. Failure.")
 	}
 
-	optval = &OptionValue{value: "wrong type: a string", found: true}
+	optval = &OptionValue{Value: "wrong type: a string", ValueFound: true}
 	_, _, err = optval.Int()
 	if err == nil {
 		t.Fatal("No error returned. Failure.")

command.go

@@ -21,7 +21,7 @@ import (
 	logging "gx/ipfs/QmSpJByNKFX1sCsHBEp3R73FL4NF6FnQTEGyNAXHm2GS52/go-log"
 )
 
-var log = logging.Logger("command")
+var log = logging.Logger("cmds")
 
 // Function is the type of function that Commands use.
 // It reads from the Request, and writes results to the ResponseEmitter.
@@ -39,7 +39,7 @@ type Command struct {
 	// after writing when using multipart requests. The request body will not be
 	// available for reading after the HTTP connection has been written to.
 	Run      Function
-	PostRun  interface{}
+	PostRun  map[EncodingType]func(Request, Response) Response
 	Encoders map[EncodingType]func(io.Writer) Encoder
 	Helptext cmdsutil.HelpText
 
@@ -85,6 +85,22 @@ func (c *Command) Call(req Request, re ResponseEmitter) error {
 		return err
 	}
 
+	// wat
+	if re_, ok := re.(EncodingEmitter); ok {
+		if encType, found, err := req.Option(cmdsutil.EncShort).String(); found && err == nil {
+			if enc, ok := cmd.Encoders[EncodingType(encType)]; ok {
+				re_.SetEncoder(enc)
+				log.Debug("updated encoder to", enc)
+			} else {
+				log.Debug("no encoder found for encoding", encType)
+			}
+		} else {
+			log.Debug("no encoding found in request. err:", err)
+		}
+	} else {
+		log.Debugf("responseemitter is not an EncodingEmitter, but a %T", re)
+	}
+
 	cmd.Run(req, re)
 
 	return nil
@@ -96,7 +112,10 @@ func (c *Command) fakeOldCall(cmd *oldcmds.Command, req Request, re ResponseEmit
 	}
 
 	// fake old response
-	res := FakeOldResponse(re)
+	res := &fakeResponse{
+		re:  re,
+		req: &requestWrapper{req},
+	}
 
 	optDefs := make(map[string]cmdsutil.Option)
 
@@ -300,7 +319,12 @@ func (c *Command) Subcommand(id string) *Command {
 		return cmd
 	}
 
-	return NewCommand(c.OldSubcommands[id])
+	oldcmd := c.OldSubcommands[id]
+	if oldcmd != nil {
+		return NewCommand(oldcmd)
+	}
+
+	return nil
 }
 
 type CommandVisitor func(*Command)