cvss: rename v2Score to Score, update deps and tests

3 files changed, 23 insertions, 23 deletions

diff --git a/cvss/v2score.go b/cvss/score.go
index 5740c09..e6a6faa 100644
--- a/cvss/v2score.go
+++ b/cvss/score.go
@@ -4,29 +4,29 @@ import (
   "fmt"
 )
 
-// Individual CVSS v2 score.
+// Individual CVSS score.
 //
 // Note: since scores range from 0.0 to 10.0 with one decimal place of
 // precision, they can be safely represented as a uint8.
-type v2Score uint8
+type Score uint8
 
 // Return floating point representation of score.
-func newV2Score(val float64) (v2Score, error) {
+func NewScore(val float64) (Score, error) {
   // check score range
   if val < 0.0 || val > 10.0 {
-    return v2Score(0), fmt.Errorf("score value out of range [0, 10]: %f", val)
+    return Score(0), fmt.Errorf("score value out of range [0, 10]: %f", val)
   }
 
   // convert to score, return success
-  return v2Score(uint8(10.0 * val)), nil
+  return Score(uint8(10.0 * val)), nil
 }
 
 // Return string representation of score.
-func (s v2Score) String() string {
+func (s Score) String() string {
   return fmt.Sprintf("%d.%d", s / 10, s % 10)
 }
 
 // Return floating point representation of score.
-func (s v2Score) Float() float32 {
+func (s Score) Float() float32 {
   return float32(s) / 10.0
 }
diff --git a/cvss/v2score_test.go b/cvss/score_test.go
index f83b76e..d35c4c8 100644
--- a/cvss/v2score_test.go
+++ b/cvss/score_test.go
@@ -5,13 +5,13 @@ import (
   "testing"
 )
 
-func TestNewV2Score(t *testing.T) {
+func TestNewScore(t *testing.T) {
   // pass tests
   for exp := 0; exp < 100; exp++ {
     val := float64(exp) / 10.0
 
     t.Run(strconv.FormatInt(int64(exp), 10), func(t *testing.T) {
-      got, err := newV2Score(val)
+      got, err := NewScore(val)
       if err != nil {
         t.Error(err)
       } else if int(got) != exp {
@@ -24,14 +24,14 @@ func TestNewV2Score(t *testing.T) {
   failTests := []float64 { -10.0, -0.1, 10.1, 100.0 }
   for _, val := range(failTests) {
     t.Run(strconv.FormatFloat(val, 'f', 2, 64), func(t *testing.T) {
-      if got, err := newV2Score(val); err == nil {
+      if got, err := NewScore(val); err == nil {
         t.Errorf("got %v, exp error", got)
       }
     })
   }
 }
 
-func TestV2ScoreString(t *testing.T) {
+func TestScoreString(t *testing.T) {
   tests := []struct {
     val float64
     exp string
@@ -47,7 +47,7 @@ func TestV2ScoreString(t *testing.T) {
 
   for _, test := range(tests) {
     t.Run(test.exp, func(t *testing.T) {
-      if val, err := newV2Score(test.val); err != nil {
+      if val, err := NewScore(test.val); err != nil {
         t.Error(err)
       } else if val.String() != test.exp {
         t.Errorf("got \"%s\", exp \"%s\"", val.String(), test.exp)
@@ -56,7 +56,7 @@ func TestV2ScoreString(t *testing.T) {
   }
 }
 
-func TestV2ScoreFloat(t *testing.T) {
+func TestScoreFloat(t *testing.T) {
   tests := []struct {
     val float64
     exp float32
@@ -77,7 +77,7 @@ func TestV2ScoreFloat(t *testing.T) {
 
   for _, test := range(tests) {
     t.Run(strconv.FormatFloat(test.val, 'f', 2, 64), func(t *testing.T) {
-      s, err := newV2Score(test.val)
+      s, err := NewScore(test.val)
       if err != nil {
         t.Error(err)
         return
diff --git a/cvss/v2scores.go b/cvss/v2scores.go
index 03bbc24..990b805 100644
--- a/cvss/v2scores.go
+++ b/cvss/v2scores.go
@@ -6,27 +6,27 @@ import (
 
 // CVSS v2 base, temporal, and environmental scores.
 type v2Scores struct {
-  base      v2Score // base score
-  temporal  v2Score // temporal score
-  env       v2Score // environmental score
+  base      Score // base score
+  temporal  Score // temporal score
+  env       Score // environmental score
 }
 
 // Create new CVSS v2Scores from floats.
 func newV2ScoresFromFloats(base, temporal, env float64) (v2Scores, error) {
-  // convert base score from float to v2score
-  baseScore, err := newV2Score(base)
+  // convert base from float to Score
+  baseScore, err := NewScore(base)
   if err != nil {
     return v2Scores{}, err
   }
 
-  // convert temporal score from float to v2score
-  tempScore, err := newV2Score(temporal)
+  // convert temporal from float to Score
+  tempScore, err := NewScore(temporal)
   if err != nil {
     return v2Scores{}, err
   }
 
-  // convert env score from float to v2score
-  envScore, err := newV2Score(env)
+  // convert env from float to Score
+  envScore, err := NewScore(env)
   if err != nil {
     return v2Scores{}, err
   }