spdx 3.1.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce3731b9fb9a2196aace855f2f9f23ed0932990b7a60b62c2ed5d3b7d023fb73
-  data.tar.gz: d7d2344da8d844fdc11a2eed6cc56e6911a989eb276c655ce92a720857f397c7
+  metadata.gz: 57eb1d8fa593ee4d8502733dd5257f050a5a421e8e272036517f146a362f1eea
+  data.tar.gz: e6d33c4be673643a9e052df93fcac4d41a3c8c809fca6293482979f0ffb62fb1
 SHA512:
-  metadata.gz: 5bc839f45793acbc7ae22e0230a801a8cec40e5b5935c4a289f0eb5eb1bea451071dc733bad9c4965a98cb073453e93d0ee971c20645c8acc279e6811322bd8c
-  data.tar.gz: 98ced2d7c93929c544f68d150b9dde28d87f816c62df0d0b3b7fb438ef4a54d347606236a71ef33ec09fa0a2099e74bb00065a749ecf55634f089f067b440019
+  metadata.gz: 29d8dd9dd27711bc077d2a6828cfa58a8f378a5bcd2e6a0b3915fc070e2561b03b412f7683027985d50624a013310d6e4bdd4f053e3646c4fb659d4675553fd6
+  data.tar.gz: 03ea3f99549c654a817c53077f584feaacd4a85200f008e987a7aebac684435974269ab6edac88a22d253d78f4dd9171ab12f6713c9241a5cf153966ae8b7863

data/README.md

@@ -20,25 +20,81 @@ Or install it yourself as:
 ## Usage
 
 ```ruby
-Spdx.valid_spdx?("(MIT OR AGPL-3.0+)")
+Spdx.valid?("(MIT OR AGPL-3.0+)")
 => true
 ```
+
 ```ruby
-Spdx.parse_spdx("(MIT OR AGPL-3.0+)")
-=> CompoundExpression+CompoundExpression0 offset=0, "((MIT OR AGPL-3.0+))" (body):
-  Body offset=1, "(MIT OR AGPL-3.0+)":
-    CompoundExpression+CompoundExpression0 offset=1, "(MIT OR AGPL-3.0+)" (body):
-      Body offset=2, "MIT OR AGPL-3.0+":
-        License+License0 offset=2, "MIT"
-        LogicalOr+Or0 offset=5, " OR " (space1,space2)
-        License+License0 offset=9, "AGPL-3.0+"
+Spdx.parse("MIT OR AGPL-3.0+")
+=> LogicalOr+OrExpression4 offset=0, "MIT OR AGPL-3.0+":
+  License+LicenseId0 offset=0, "MIT" (idstring)
+  LicensePlus+SimpleExpression0 offset=7, "AGPL-3.0+" (license_id):
+    License+LicenseId0 offset=7, "AGPL-3.0" (idstring)
 ```
 
+```ruby
+Spdx.normalize("Mit OR agpl-3.0+ AND APACHE-2.0")
+=> "MIT OR (AGPL-3.0+ AND Apache-2.0)"
+
+Spdx.normalize("Mit OR agpl-3.0+ AND APACHE-2.0", top_level_parens: true)
+=> "(MIT OR (AGPL-3.0+ AND Apache-2.0))"
+```
+
+### Nodes
+
+Parsed SPDX license expressions can be a number of various nodes. Each of these nodes share a few methods, most notably `text_value` which contains the text that spans that node, and `licenses` which contains an array of individual licenses used in that portion of the expression. Below are the nodes in more detail, and their additional methods.
+
+#### `License`
+
+This node represents a single license, and is the result of the most simple form of expression, e.g. `Spdx.parse("MIT")`. It can also be found as a child node of other nodes.
+
+#### `LicensePlus`
+
+This node represents the current version of a license or any later version, e.g. `Spdx.parse("CDDL-1.0+")`. The inner license node can be found via the `child` method.
+
+#### `LicenseRef`
+
+This node represents a reference to a license not defined in the SPDX license list, e.g. `Spdx.parse("LicenseRef-23")`.
+
+#### `DocumentRef`
+
+Similar to `LicenseRef`, this node also represents a reference to a license not defined in the SPDX license list, e.g. `Spdx.parse("DocumentRef-spdx-tool-1.2:LicenseRef-MIT-Style-2")`.
+
+#### `LicenseException`
+
+This node represents an exception to a license. See `With`.
+
+#### `With`
+
+This node represents a license with an SPDX-defined license exception, e.g. `Spdx.parse("GPL-2.0-or-later WITH Bison-exception-2.2")`. This node has two extra methods, `license` and `exception`, which return the nodes for the license portion of the expression and the exception portion of the expression, respectively.
+
+#### `LogicalAnd`
+
+This node represents an "AND" expression, e.g. `Spdx.parse("LGPL-2.1-only AND MIT")`. This node has two extra methods, `left` and `right`, which return the node for the left side of the expression and the node for the right side of the expression, respectively. Any node can be the child of `LogicalAnd`, including `LogicalAnd`/`LogicalOr`.
+
+`Spdx.parse("(MIT AND GPL-1.0) OR MPL-2.0 AND Apache-2.0")` would result in the following tree:
+
+```txt
+LogicalOr
+├── LogicalAnd
+│   ├── License (MIT)
+│   └── License (GPL-1.0)
+└── LogicalAnd
+    ├── License (MPL-2.0)
+    └── License Apache-2.0
+```
+
+#### `LogicalOr`
+
+The same as `LogicalAnd`, but for "OR" expressions.
+
 ## Testing
 
 Run the tests with:
 
-    $ bundle exec rspec
+```sh
+bundle exec rspec
+```
 
 ## Contributing
 

data/lib/spdx.rb

@@ -61,7 +61,54 @@ module Spdx
     @exceptions_downcase
   end
 
-  def self.valid_spdx?(spdx_string)
+  def self.normalize(spdx_string, top_level_parens: false)
+    normalize_tree(SpdxParser.parse(spdx_string), parens: top_level_parens)
+  end
+
+  private_class_method def self.normalize_tree(node, parens: true)
+    case node
+    when SpdxGrammar::LogicalAnd
+      left = normalize_tree(node.left)
+      right = normalize_tree(node.right)
+      if parens
+        "(#{left} AND #{right})"
+      else
+        "#{left} AND #{right}"
+      end
+    when SpdxGrammar::LogicalOr
+      left = normalize_tree(node.left)
+      right = normalize_tree(node.right)
+      if parens
+        "(#{left} OR #{right})"
+      else
+        "#{left} OR #{right}"
+      end
+    when SpdxGrammar::With
+      license = normalize_tree(node.license)
+      exception = normalize_tree(node.exception)
+      if parens
+        "(#{license} WITH #{exception})"
+      else
+        "#{license} WITH #{exception}"
+      end
+    when SpdxGrammar::None
+      "NONE"
+    when SpdxGrammar::NoAssertion
+      "NOASSERTION"
+    when SpdxGrammar::License
+      licenses_downcase[node.text_value.downcase]
+    when SpdxGrammar::LicensePlus
+      "#{normalize_tree(node.child)}+"
+    when SpdxGrammar::LicenseRef
+      node.text_value
+    when SpdxGrammar::DocumentRef
+      node.text_value
+    when SpdxGrammar::LicenseException
+      exceptions_downcase[node.text_value.downcase]
+    end
+  end
+
+  def self.valid?(spdx_string)
     return false unless spdx_string.is_a?(String)
 
     SpdxParser.parse(spdx_string)
@@ -70,7 +117,7 @@ module Spdx
     false
   end
 
-  def self.parse_spdx(spdx_string)
+  def self.parse(spdx_string)
     SpdxParser.parse(spdx_string)
   end
 end

data/lib/spdx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Spdx
-  VERSION = "3.1.0"
+  VERSION = "4.0.0"
 end

data/lib/spdx_grammar.rb

@@ -1,19 +1,40 @@
 # frozen_string_literal: true
 
 module SpdxGrammar
-  class CompoundExpression < Treetop::Runtime::SyntaxNode
+  class LogicalBinary < Treetop::Runtime::SyntaxNode
+    # Used internally
+
     def licenses
-      elements[0].licenses
+      (left.licenses + right.licenses).uniq
+    end
+
+    def left
+      elements[0]
+    end
+
+    def right
+      elements[1]
     end
   end
 
-  class LogicalOr < Treetop::Runtime::SyntaxNode
+  class LogicalAnd < LogicalBinary
   end
 
-  class LogicalAnd < Treetop::Runtime::SyntaxNode
+  class LogicalOr < LogicalBinary
   end
 
   class With < Treetop::Runtime::SyntaxNode
+    def licenses
+      license.licenses
+    end
+
+    def license
+      elements[0]
+    end
+
+    def exception
+      elements[1]
+    end
   end
 
   class None < Treetop::Runtime::SyntaxNode
@@ -30,22 +51,29 @@ module SpdxGrammar
 
   class License < Treetop::Runtime::SyntaxNode
     def licenses
-      text_value
+      [text_value]
     end
   end
 
-  class UserDefinedLicense < Treetop::Runtime::SyntaxNode
+  class LicensePlus < Treetop::Runtime::SyntaxNode
+    def licenses
+      child.licenses
+    end
+
+    def child
+      elements[0]
+    end
   end
 
   class LicenseRef < Treetop::Runtime::SyntaxNode
     def licenses
-      text_value
+      [text_value]
     end
   end
 
   class DocumentRef < Treetop::Runtime::SyntaxNode
     def licenses
-      text_value
+      [text_value]
     end
   end
 
@@ -53,10 +81,12 @@ module SpdxGrammar
     # TODO: actually do license exceptions
   end
 
-  class Body < Treetop::Runtime::SyntaxNode
-    def licenses
-      elements.map { |node| node.licenses if node.respond_to?(:licenses) }.flatten.uniq.compact
-    end
+  class GroupedExpression < Treetop::Runtime::SyntaxNode
+    # Used internally
+  end
+
+  class Operand < Treetop::Runtime::SyntaxNode
+    # Used internally
   end
 
   class SpdxParseError < StandardError

data/lib/spdx_parser.rb

@@ -21,20 +21,48 @@ class SpdxParser
 
   private_class_method def self.parse_tree(data)
     parser = SpdxGrammarParser.new # The generated grammar parser is not thread safe
-    # Couldn't figure out treetop to make parens optional
-    data = "(#{data})" unless SKIP_PARENS.include?(data)
 
     tree = parser.parse(data)
     raise SpdxGrammar::SpdxParseError, "Unable to parse expression '#{data}'. Parse error at offset: #{parser.index}" if tree.nil?
 
-    clean_tree(tree)
-    tree
+    prune(tree)
   end
 
-  private_class_method def self.clean_tree(root_node)
-    return if root_node.elements.nil?
+  private_class_method def self.clean(root_node)
+    root_node.elements&.delete_if { |node| node.instance_of?(Treetop::Runtime::SyntaxNode) }
+  end
+
+  private_class_method def self.prune(root_node)
+    clean(root_node)
+
+    root_node.elements&.each_with_index do |node, i|
+      case node
+      when SpdxGrammar::GroupedExpression, SpdxGrammar::Operand
+        clean(node)
+        child = node.elements[0]
+        child.parent = root_node
+        root_node.elements[i] = child
+
+        case child
+        when SpdxGrammar::GroupedExpression, SpdxGrammar::Operand
+          # re-prune if child's child is a GroupedExpression or Operand
+          prune(root_node)
+        else
+          prune(child)
+        end
+      else
+        prune(node)
+      end
+    end
+
+    case root_node
+    when SpdxGrammar::GroupedExpression
+      child = root_node.elements[0]
+      child.parent = root_node.parent
+
+      return child
+    end
 
-    root_node.elements.delete_if { |node| node.class.name == "Treetop::Runtime::SyntaxNode" }
-    root_node.elements.each { |node| clean_tree(node) }
+    root_node
   end
 end

data/lib/spdx_parser.treetop

@@ -1,47 +1,56 @@
 grammar SpdxGrammar
 
-  rule spdx_expression
+  rule license_expression
     compound_expression / none / no_assertion
   end
 
   rule compound_expression
-    '(' body ')' <CompoundExpression>
+    or_expression / and_expression / expression / grouped_expression
   end
 
-  rule body
-    ( compound_expression / and / or / with / license_ref / document_ref / license )* <Body>
+  rule and_expression
+    ( expression space <Operand> / grouped_expression space? <Operand> ) "AND" ( space ( and_expression / expression ) <Operand> / space? grouped_expression <Operand> ) <LogicalAnd>
   end
 
-  rule and
-    space "AND" space !reserve_words <LogicalAnd>
+  rule or_expression
+    ( ( and_expression / expression ) space <Operand> / grouped_expression space? <Operand> ) "OR"  ( space compound_expression <Operand> / space? grouped_expression <Operand> ) <LogicalOr>
   end
 
-  rule or
-    space "OR" space !reserve_words <LogicalOr>
+  rule expression
+    simple_expression space "WITH" space license_exception_id <With> /
+    simple_expression
   end
 
-  rule with
-    space "WITH" space license_exception <With>
+  rule grouped_expression
+    '(' compound_expression ')' <GroupedExpression>
   end
 
-  rule license
-    [a-zA-Z0-9\-\.\+]+ &{|seq| Spdx.license_exists?(seq.first.text_value) || Spdx.license_exists?(seq.first.text_value.delete_suffix('+')) }  <License>
+  rule simple_expression
+    license_id '+' <LicensePlus> / license_id / ref
+  end
+
+  rule ref
+    document_ref / license_ref
   end
 
   rule license_ref
-    "LicenseRef-" [a-zA-Z0-9\-\.]+ <LicenseRef>
+    "LicenseRef-" idstring <LicenseRef>
   end
 
   rule document_ref
-    "DocumentRef-" [a-zA-Z0-9\-\.]+ ":" license_ref <DocumentRef>
+    "DocumentRef-" idstring ':' license_ref <DocumentRef>
+  end
+
+  rule license_id
+    idstring &{|seq| Spdx.license_exists?(seq.first.text_value) } <License>
   end
 
-  rule license_exception
-    [a-zA-Z0-9\-\.]+ &{|seq| Spdx.exception_exists?(seq.first.text_value) } <LicenseException>
+  rule license_exception_id
+    idstring &{|seq| Spdx.exception_exists?(seq.first.text_value) } <LicenseException>
   end
 
-  rule reserve_words
-    "AND" / "OR" / "WITH"
+  rule idstring
+    [a-zA-Z0-9\-\.]+
   end
 
   rule none

data/spec/spdx_spec.rb

@@ -4,67 +4,121 @@ require "spec_helper"
 
 describe Spdx do
   context "spdx parsing" do
-    context "valid_spdx?" do
+    context "valid?" do
       it "returns false for invalid spdx" do
-        expect(Spdx.valid_spdx?("AND AND")).to be false
-        expect(Spdx.valid_spdx?("MIT OR MIT AND OR")).to be false
-        expect(Spdx.valid_spdx?("MIT OR FAKEYLICENSE")).to be false
-        expect(Spdx.valid_spdx?(nil)).to be false
-        expect(Spdx.valid_spdx?("")).to be false
-        expect(Spdx.valid_spdx?("MIT (MIT)")).to be false
+        expect(Spdx.valid?("AND AND")).to be false
+        expect(Spdx.valid?(" AND ")).to be false
+        expect(Spdx.valid?(" WITH ")).to be false
+        expect(Spdx.valid?("MIT AND ")).to be false
+        expect(Spdx.valid?("MIT OR MIT AND OR")).to be false
+        expect(Spdx.valid?("MIT OR FAKEYLICENSE")).to be false
+        expect(Spdx.valid?(nil)).to be false
+        expect(Spdx.valid?("")).to be false
+        expect(Spdx.valid?("MIT (MIT)")).to be false
       end
       it "returns true for valid spdx" do
-        expect(Spdx.valid_spdx?("(MIT OR MPL-2.0)")).to be true
-        expect(Spdx.valid_spdx?("MIT")).to be true
-        expect(Spdx.valid_spdx?("((MIT OR AGPL-1.0) AND (MIT OR MPL-2.0))")).to be true
-        expect(Spdx.valid_spdx?("MIT OR (MIT)")).to be true
+        expect(Spdx.valid?("(MIT OR MPL-2.0)")).to be true
+        expect(Spdx.valid?("MIT")).to be true
+        expect(Spdx.valid?("MIT OR MPL-2.0 AND AGPL-1.0")).to be true
+        expect(Spdx.valid?("MIT OR (GPL-1.0 OR MPL-2.0) AND AGPL-1.0")).to be true
+        expect(Spdx.valid?("MIT AND MPL-2.0 OR AGPL-1.0")).to be true
+        expect(Spdx.valid?("MIT AND (GPL-1.0 OR MPL-2.0) OR AGPL-1.0")).to be true
+        expect(Spdx.valid?("MIT OR (DocumentRef-something-1:LicenseRef-MIT-style-1 OR MPL-2.0) AND AGPL-1.0")).to be true
+        expect(Spdx.valid?("((MIT OR AGPL-1.0) AND (MIT OR MPL-2.0))")).to be true
+        expect(Spdx.valid?("MIT OR (MIT)")).to be true
       end
       it "returns true for NONE and NOASSERTION" do
-        expect(Spdx.valid_spdx?("NONE")).to be true
-        expect(Spdx.valid_spdx?("(NONE)")).to be false
-        expect(Spdx.valid_spdx?("NOASSERTION")).to be true
-        expect(Spdx.valid_spdx?("MIT OR NONE")).to be false
+        expect(Spdx.valid?("NONE")).to be true
+        expect(Spdx.valid?("(NONE)")).to be false
+        expect(Spdx.valid?("NOASSERTION")).to be true
+        expect(Spdx.valid?("MIT OR NONE")).to be false
       end
       it "returns true for + expression" do
-        expect(Spdx.valid_spdx?("AGPL-3.0+")).to be true
+        expect(Spdx.valid?("AGPL-3.0+")).to be true
       end
       it "is case insentive for license ids" do
-        expect(Spdx.valid_spdx?("mit OR agpl-3.0+")).to be true
+        expect(Spdx.valid?("mit OR agpl-3.0+")).to be true
       end
       it "handles LicenseRef" do
-        expect(Spdx.valid_spdx?("MIT OR LicenseRef-MIT-style-1")).to be true
+        expect(Spdx.valid?("MIT OR LicenseRef-MIT-style-1")).to be true
       end
       it "handles DocumentRef" do
-        expect(Spdx.valid_spdx?("MIT OR DocumentRef-something-1:LicenseRef-MIT-style-1")).to be true
-        expect(Spdx.valid_spdx?("MIT OR DocumentRef-something-1")).to be false
+        expect(Spdx.valid?("MIT OR DocumentRef-something-1:LicenseRef-MIT-style-1")).to be true
+        expect(Spdx.valid?("MIT OR DocumentRef-something-1")).to be false
       end
     end
   end
+  context "normalize" do
+    it "normalizes simple licenses" do
+      expect(Spdx.normalize("MIT")).to eq "MIT"
+      expect(Spdx.normalize("mit")).to eq "MIT"
+      expect(Spdx.normalize("MiT")).to eq "MIT"
+      expect(Spdx.normalize("(MiT)")).to eq "MIT"
+      expect(Spdx.normalize("(((MiT)))")).to eq "MIT"
+      expect(Spdx.normalize("LicenseRef-MIT-style-1")).to eq "LicenseRef-MIT-style-1"
+      expect(Spdx.normalize("DocumentRef-something-1:LicenseRef-MIT-style-1")).to eq "DocumentRef-something-1:LicenseRef-MIT-style-1"
+      expect(Spdx.normalize("Apache-2.0+")).to eq "Apache-2.0+"
+      expect(Spdx.normalize("apache-2.0+")).to eq "Apache-2.0+"
+    end
+    it "normalizes NONE/NOASSERTION" do
+      expect(Spdx.normalize("NONE")).to eq "NONE"
+      expect(Spdx.normalize("NOASSERTION")).to eq "NOASSERTION"
+    end
+    it "normalizes boolean expressions" do
+      expect(Spdx.normalize("mit AND gPL-2.0")).to eq "MIT AND GPL-2.0"
+      expect(Spdx.normalize("mit OR gPL-2.0")).to eq "MIT OR GPL-2.0"
+      expect(Spdx.normalize("mit OR gPL-2.0")).to eq "MIT OR GPL-2.0"
+
+      # With top level parens
+      expect(Spdx.normalize("mit AND gPL-2.0", top_level_parens: true)).to eq "(MIT AND GPL-2.0)"
+      expect(Spdx.normalize("mit OR gPL-2.0", top_level_parens: true)).to eq "(MIT OR GPL-2.0)"
+      expect(Spdx.normalize("mit OR gPL-2.0", top_level_parens: true)).to eq "(MIT OR GPL-2.0)"
+
+      # Does semantic grouping
+      expect(Spdx.normalize("mit OR gPL-2.0 AND apAcHe-2.0+")).to eq "MIT OR (GPL-2.0 AND Apache-2.0+)"
+
+      # But also preserves original groups
+      expect(Spdx.normalize("(mit OR gPL-2.0) AND apAcHe-2.0+")).to eq "(MIT OR GPL-2.0) AND Apache-2.0+"
+    end
+    it "normalizes WITH expressions" do
+      expect(Spdx.normalize("GPL-2.0-only WITH Classpath-exception-2.0")).to eq "GPL-2.0-only WITH Classpath-exception-2.0"
+      expect(Spdx.normalize("Gpl-2.0-ONLY WITH ClassPath-exception-2.0")).to eq "GPL-2.0-only WITH Classpath-exception-2.0"
+
+      # With top level parens
+      expect(Spdx.normalize("GPL-2.0-only WITH Classpath-exception-2.0", top_level_parens: true)).to eq "(GPL-2.0-only WITH Classpath-exception-2.0)"
+      expect(Spdx.normalize("Gpl-2.0-ONLY WITH ClassPath-exception-2.0", top_level_parens: true)).to eq "(GPL-2.0-only WITH Classpath-exception-2.0)"
+
+      expect(Spdx.normalize("EPL-2.0 OR (GPL-2.0-only WITH Classpath-exception-2.0)")).to eq "EPL-2.0 OR (GPL-2.0-only WITH Classpath-exception-2.0)"
+      expect(Spdx.normalize("epl-2.0 OR (gpl-2.0-only WITH classpath-exception-2.0)")).to eq "EPL-2.0 OR (GPL-2.0-only WITH Classpath-exception-2.0)"
+      expect(Spdx.normalize("epl-2.0 OR gpl-2.0-only WITH classpath-exception-2.0")).to eq "EPL-2.0 OR (GPL-2.0-only WITH Classpath-exception-2.0)"
+      expect(Spdx.normalize("epl-2.0 OR gpl-2.0-only WITH classpath-exception-2.0 AND mpl-2.0+")).to eq "EPL-2.0 OR ((GPL-2.0-only WITH Classpath-exception-2.0) AND MPL-2.0+)"
+    end
+  end
   context "licenses" do
     it "returns a list of possible licenses" do
-      expect(Spdx.parse_spdx("MIT OR MPL-2.0").licenses).to eq ["MIT", "MPL-2.0"]
+      expect(Spdx.parse("MIT OR MPL-2.0").licenses).to eq ["MIT", "MPL-2.0"]
     end
     it "returns empty array for NONE or NOASSERTION" do
-      expect(Spdx.parse_spdx("NONE").licenses).to eq []
-      expect(Spdx.parse_spdx("NOASSERTION").licenses).to eq []
+      expect(Spdx.parse("NONE").licenses).to eq []
+      expect(Spdx.parse("NOASSERTION").licenses).to eq []
     end
     it "returns LicenseRefs" do
-      expect(Spdx.parse_spdx("MIT OR LicenseRef-MIT-style-1").licenses).to eq %w[MIT LicenseRef-MIT-style-1]
+      expect(Spdx.parse("MIT OR LicenseRef-MIT-style-1").licenses).to eq %w[MIT LicenseRef-MIT-style-1]
     end
     it "returns DocumentRefs" do
-      expect(Spdx.parse_spdx("MIT OR DocumentRef-something-1:LicenseRef-MIT-style-1").licenses).to eq %w[MIT DocumentRef-something-1:LicenseRef-MIT-style-1]
+      expect(Spdx.parse("MIT OR DocumentRef-something-1:LicenseRef-MIT-style-1").licenses).to eq %w[MIT DocumentRef-something-1:LicenseRef-MIT-style-1]
     end
   end
 
   context "exceptions" do
-    it "parses a valid spdx with expression" do
-      expect(Spdx.valid_spdx?("EPL-2.0 OR (GPL-2.0-only WITH Classpath-exception-2.0)")).to be true
+    it "parses a valid spdx WITH expression" do
+      expect(Spdx.valid?("EPL-2.0 OR (GPL-2.0-only WITH Classpath-exception-2.0)")).to be true
     end
     it "returns false for a license in the exception spot" do
-      expect(Spdx.valid_spdx?("EPL-2.0 OR (GPL-2.0-only WITH AGPL-3.0)")).to be false
+      expect(Spdx.valid?("EPL-2.0 OR (GPL-2.0-only WITH AGPL-3.0)")).to be false
     end
     it "provides full details for a parse error" do
-      expect { Spdx.parse_spdx("MIT OR ((WHAT)") }.to raise_error(SpdxGrammar::SpdxParseError, "Unable to parse expression '(MIT OR ((WHAT))'. Parse error at offset: 0")
+      expect { Spdx.parse("MIT OR ((WHAT)") }.to raise_error(SpdxGrammar::SpdxParseError, "Unable to parse expression 'MIT OR ((WHAT)'. Parse error at offset: 3")
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spdx
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Tidelift, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-11 00:00:00.000000000 Z
+date: 2021-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop