Update dependencies

Godeps/_workspace/src/github.com/codegangsta/inject/inject.go

@@ -1,3 +1,4 @@
+// Package inject provides utilities for mapping and injecting dependencies in various ways.
 package inject
 
 import (
@@ -5,24 +6,49 @@ import (
 	"reflect"
 )
 
+// Injector represents an interface for mapping and injecting dependencies into structs
+// and function arguments.
 type Injector interface {
 	Applicator
 	Invoker
 	TypeMapper
+	// SetParent sets the parent of the injector. If the injector cannot find a
+	// dependency in its Type map it will check its parent before returning an
+	// error.
 	SetParent(Injector)
 }
 
+// Applicator represents an interface for mapping dependencies to a struct.
 type Applicator interface {
+	// Maps dependencies in the Type map to each field in the struct
+	// that is tagged with 'inject'. Returns an error if the injection
+	// fails.
 	Apply(interface{}) error
 }
 
+// Invoker represents an interface for calling functions via reflection.
 type Invoker interface {
+	// Invoke attempts to call the interface{} provided as a function,
+	// providing dependencies for function arguments based on Type. Returns
+	// a slice of reflect.Value representing the returned values of the function.
+	// Returns an error if the injection fails.
 	Invoke(interface{}) ([]reflect.Value, error)
 }
 
+// TypeMapper represents an interface for mapping interface{} values based on type.
 type TypeMapper interface {
+	// Maps the interface{} value based on its immediate type from reflect.TypeOf.
 	Map(interface{}) TypeMapper
+	// Maps the interface{} value based on the pointer of an Interface provided.
+	// This is really only useful for mapping a value as an interface, as interfaces
+	// cannot at this time be referenced directly without a pointer.
 	MapTo(interface{}, interface{}) TypeMapper
+	// Provides a possibility to directly insert a mapping based on type and value.
+	// This makes it possible to directly map type arguments not possible to instantiate
+	// with reflect like unidirectional channels.
+	Set(reflect.Type, reflect.Value) TypeMapper
+	// Returns the Value that is mapped to the current type. Returns a zeroed Value if
+	// the Type has not been mapped.
 	Get(reflect.Type) reflect.Value
 }
 
@@ -31,6 +57,8 @@ type injector struct {
 	parent Injector
 }
 
+// InterfaceOf dereferences a pointer to an Interface type.
+// It panics if value is not an pointer to an interface.
 func InterfaceOf(value interface{}) reflect.Type {
 	t := reflect.TypeOf(value)
 
@@ -45,16 +73,22 @@ func InterfaceOf(value interface{}) reflect.Type {
 	return t
 }
 
+// New returns a new Injector.
 func New() Injector {
 	return &injector{
 		values: make(map[reflect.Type]reflect.Value),
 	}
 }
 
+// Invoke attempts to call the interface{} provided as a function,
+// providing dependencies for function arguments based on Type.
+// Returns a slice of reflect.Value representing the returned values of the function.
+// Returns an error if the injection fails.
+// It panics if f is not a function
 func (inj *injector) Invoke(f interface{}) ([]reflect.Value, error) {
 	t := reflect.TypeOf(f)
 
-	var in = make([]reflect.Value, t.NumIn())
+	var in = make([]reflect.Value, t.NumIn()) //Panic if t is not kind of Func
 	for i := 0; i < t.NumIn(); i++ {
 		argType := t.In(i)
 		val := inj.Get(argType)
@@ -68,6 +102,9 @@ func (inj *injector) Invoke(f interface{}) ([]reflect.Value, error) {
 	return reflect.ValueOf(f).Call(in), nil
 }
 
+// Maps dependencies in the Type map to each field in the struct
+// that is tagged with 'inject'.
+// Returns an error if the injection fails.
 func (inj *injector) Apply(val interface{}) error {
 	v := reflect.ValueOf(val)
 
@@ -76,7 +113,7 @@ func (inj *injector) Apply(val interface{}) error {
 	}
 
 	if v.Kind() != reflect.Struct {
-		return nil
+		return nil // Should not panic here ?
 	}
 
 	t := v.Type()
@@ -99,6 +136,8 @@ func (inj *injector) Apply(val interface{}) error {
 	return nil
 }
 
+// Maps the concrete value of val to its dynamic type using reflect.TypeOf,
+// It returns the TypeMapper registered in.
 func (i *injector) Map(val interface{}) TypeMapper {
 	i.values[reflect.TypeOf(val)] = reflect.ValueOf(val)
 	return i
@@ -109,6 +148,13 @@ func (i *injector) MapTo(val interface{}, ifacePtr interface{}) TypeMapper {
 	return i
 }
 
+// Maps the given reflect.Type to the given reflect.Value and returns
+// the Typemapper the mapping has been registered in.
+func (i *injector) Set(typ reflect.Type, val reflect.Value) TypeMapper {
+	i.values[typ] = val
+	return i
+}
+
 func (i *injector) Get(t reflect.Type) reflect.Value {
 	val := i.values[t]
 	if !val.IsValid() && i.parent != nil {