Merge pull request #1 from Rican7/feature/mutable-and-immutable

Feature - Mutability and Immutability

Author: Rican7

README.md

@@ -19,16 +19,37 @@ contentTypeString := "application/vnd.google-earth.kml+xml; charset=utf-8"
 
 mediaType, _ := mediatype.Parse(contentTypeString)
 
-mediaType.FullType()   // "application/vnd.google-earth.kml+xml"
-mediaType.Parameters() // ["charset": "utf-8"]
 mediaType.MainType()   // "application"
 mediaType.SubType()    // "kml"
 mediaType.Trees()      // ["vnd", "google-earth"]
 mediaType.Prefix()     // "vnd"
 mediaType.Suffix()     // "xml"
+mediaType.Parameters() // ["charset": "utf-8"]
+
+mediaType.FullType()   // "application/vnd.google-earth.kml+xml"
 mediaType.String()     // "application/vnd.google-earth.kml+xml; charset=utf-8"
 ```
 
+## Mutability and Immutability
+
+```go
+mutable := &mediatype.Mutable{
+    Main: "application",
+    Sub:  "json",
+}
+
+mutable.String()     // "application/json"
+
+mutable.Sub    = "xhtml"
+mutable.Suffix = "xml"
+mutable.String()     // "application/xhtml+xml"
+
+
+immutable := mutable.Immutable()
+mutable.Main = "image"
+immutable.String()     // "application/xhtml+xml"
+```
+
 
 
 

mediatype.go

@@ -9,8 +9,8 @@
 package mediatype
 
 import (
+	"fmt"
 	"mime"
-	"strings"
 )
 
 /**
@@ -40,120 +40,28 @@ const (
 // print out the reconstructed parts of the MediaType model in a standards
 // compliant manner, following the `mime.FormatMediaType()` output
 type MediaType interface {
-	FullType() string
-	Parameters() map[string]string
+	fmt.Stringer
+
 	MainType() string
 	SubType() string
 	Trees() []string
 	Prefix() string
 	Suffix() string
+	Parameters() map[string]string
 
-	String() string
-}
-
-type mediaType struct {
-	fullType string
-	params   map[string]string
-
-	mainType string
-	trees    []string
-	subType  string
-	suffix   string
+	FullType() string
 }
 
-/**
- * Functions
- */
-
 // Parse a raw media type string into a MediaType interface compatible struct
 func Parse(raw string) (MediaType, error) {
-	normalized, params, err := mime.ParseMediaType(raw)
+	normalizedFullType, params, err := mime.ParseMediaType(raw)
 
 	if nil != err {
 		return nil, err
 	}
 
-	// Build from the raw
-	mediaType := &mediaType{
-		fullType: normalized,
-		params:   params,
-	}
-
-	mediaType.splitTypes()
+	mediaType := splitTypes(normalizedFullType)
+	mediaType.Params = params
 
 	return mediaType, nil
 }
-
-// Get the normalized type and sub-type as a string
-func (m *mediaType) FullType() string {
-	return m.fullType
-}
-
-// Get the defined parameters of the media type
-func (m *mediaType) Parameters() map[string]string {
-	return m.params
-}
-
-// Get the "main" (top-level) type as a string
-func (m *mediaType) MainType() string {
-	return m.mainType
-}
-
-// Get the "sub" type as a string
-func (m *mediaType) SubType() string {
-	return m.subType
-}
-
-// Get the split "sub" type as an array of strings split by the namespace separator
-func (m *mediaType) Trees() []string {
-	return m.trees
-}
-
-// Get the prefix of the type's trees
-func (m *mediaType) Prefix() string {
-	if 0 < len(m.trees) {
-		return m.trees[0]
-	}
-
-	return ""
-}
-
-// Get the "suffix" of the type as a string
-func (m *mediaType) Suffix() string {
-	return m.suffix
-}
-
-// Get a string representation conforming to RFC 2045 and RFC 2616
-func (m *mediaType) String() string {
-	return mime.FormatMediaType(m.fullType, m.params)
-}
-
-// Split the full type string into parts and assign those values to our struct
-func (m *mediaType) splitTypes() {
-	// Split the main/sub types
-	mainSubSplit := strings.Split(m.fullType, MainSubSplitCharacter)
-
-	m.mainType = mainSubSplit[0]
-
-	// If we got more than one part, we must have a sub-type
-	if 1 < len(mainSubSplit) {
-		// Split the remaining main/sub split from a possible suffix
-		subSuffixSplit := strings.Split(mainSubSplit[1], SuffixCharacter)
-
-		// If we got more than one part, we must have a suffix
-		if 1 < len(subSuffixSplit) {
-			m.suffix = subSuffixSplit[1]
-		}
-
-		// Split the sub-type split into the possibly different trees
-		treeSubSplit := strings.Split(subSuffixSplit[0], TreeSeparatorCharacter)
-		treeSubSplitLength := len(treeSubSplit)
-
-		m.subType = treeSubSplit[treeSubSplitLength-1]
-
-		// If we got more than one part, we must have tree definitions
-		if 1 < treeSubSplitLength {
-			m.trees = treeSubSplit[0 : treeSubSplitLength-1]
-		}
-	}
-}

mediatype_immutable.go

@@ -0,0 +1,78 @@
+/**
+ * MediaType
+ *
+ * Copyright © 2014 Trevor N. Suarez (Rican7)
+ */
+
+// This file provides provides an immutable implementation of the MediaType interface
+
+package mediatype
+
+/**
+ * Types
+ */
+
+// Immutable is an immutable encapsulation of a Media Type
+type Immutable struct {
+	contained Mutable
+}
+
+/**
+ * Functions
+ */
+
+// NewImmutable returns a new empty instance of a Immutable struct
+func NewImmutable() MediaType {
+	return &Immutable{}
+}
+
+// NewImmutableAsContainer returns a new instance of a Immutable struct
+// with the values matching the values of the passed Mutable struct
+func NewImmutableAsContainer(mutable Mutable) MediaType {
+	return &Immutable{mutable}
+}
+
+// MainType returns the "main" (top-level) type as a string
+func (m *Immutable) MainType() string {
+	return m.contained.MainType()
+}
+
+// SubType returns the "sub" type as a string
+func (m *Immutable) SubType() string {
+	return m.contained.SubType()
+}
+
+// Trees returns the split "sub" type as an array of strings split by the namespace separator
+func (m *Immutable) Trees() []string {
+	return m.contained.Trees()
+}
+
+// Prefix returns the prefix of the type's trees
+func (m *Immutable) Prefix() string {
+	return m.contained.Prefix()
+}
+
+// Suffix returns the "suffix" of the type as a string
+func (m *Immutable) Suffix() string {
+	return m.contained.Suffix()
+}
+
+// Parameters returns the defined parameters of the media type
+func (m *Immutable) Parameters() map[string]string {
+	return m.contained.Parameters()
+}
+
+// FullType returns the normalized full type as a string
+func (m *Immutable) FullType() string {
+	return m.contained.FullType()
+}
+
+// Get a string representation conforming to RFC 2045 and RFC 2616
+func (m *Immutable) String() string {
+	return m.contained.String()
+}
+
+// Mutable returns a mutable version of this structure
+func (m *Immutable) Mutable() Mutable {
+	return m.contained
+}

mediatype_immutable_test.go

@@ -0,0 +1,83 @@
+/**
+ * MediaType
+ *
+ * Copyright © 2014 Trevor N. Suarez (Rican7)
+ */
+
+// Tests for the mediatype immutable structure
+
+package mediatype
+
+import (
+	"testing"
+)
+
+/**
+ * Helper functions
+ */
+
+func parseAndConvertToImmutable(raw string) (*Immutable, error) {
+	mt, err := Parse(validComplexMediaType)
+
+	if nil != err {
+		return nil, err
+	}
+
+	return mt.(*Mutable).Immutable(), nil
+}
+
+/**
+ * Tests functions
+ */
+
+func TestNewImmutable(t *testing.T) {
+	mt := NewImmutable()
+
+	if _, ok := mt.(MediaType); !ok {
+		t.Errorf("%+v doesn't satisfy the MediaType interface", mt)
+	}
+
+	if _, ok := mt.(*Immutable); !ok {
+		t.Errorf("MediaType %+v isn't an immutable", mt)
+	}
+}
+
+func TestNewImmutableAsContainer(t *testing.T) {
+	mutable := &Mutable{Main: "application", Sub: "doge"}
+
+	mt := NewImmutableAsContainer(*mutable)
+
+	if _, ok := mt.(MediaType); !ok {
+		t.Errorf("%+v doesn't satisfy the MediaType interface", mt)
+	}
+
+	if _, ok := mt.(*Immutable); !ok {
+		t.Errorf("MediaType %+v isn't an immutable", mt)
+	}
+
+	mutable.Sub = "nope"
+
+	if mt.String() == mutable.String() {
+		t.Errorf("Immutable was mutated for %+v", mt)
+	}
+}
+
+func TestMutable(t *testing.T) {
+	mt, err := parseAndConvertToImmutable(validComplexMediaType)
+
+	if nil != err {
+		t.Errorf("Parsing failed for valid '%s'", validComplexMediaType)
+	} else {
+		mutable := mt.Mutable()
+
+		if mt.String() != mutable.String() {
+			t.Errorf("Mutable doesn't match for %+v", mt)
+		}
+
+		mutable.Main = "asd"
+
+		if mt.String() == mutable.String() {
+			t.Errorf("Immutable was mutated for %+v", mt)
+		}
+	}
+}