api_diff 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bcfbf61d2a4f9b1a5abfaf3ee30e6c41a12048e971281424797bfc8067c9d467
-  data.tar.gz: aabe1cc6429ff84100719bf26d691e9825502ffc2bf32736a9880c4f308477c8
+  metadata.gz: 29d7124fb871227197ac950b3b042ae3a6a3c99eafaf0bc0762e8dceefed24fc
+  data.tar.gz: f10484ee00caad08e50bbb217bc5fd3308f4414e780cb93a9a3f4177ea69cd29
 SHA512:
-  metadata.gz: bd3944386bbdf2c713b2ac647dc38fc50132211ee9af2f06c97f821e31aca8981e710b5a9c2bbc987b8866ed512dc09ad9f2ed802f6bfcd98e33fd2d2858d99d
-  data.tar.gz: bbd34214c44954e6f2075fbd26a9115a0cbad590790565c282447b67e6590b8a7533678558f7ca3e7b995d11367df8ee91be131532b3da9fc41dcae954854020
+  metadata.gz: 3966edcf349cc3e43deead3ee42e15449b4278d7eb2f545d00f0a7607cde01b38abb629790dd01252bec9b56d1327a3dd127f5c274765fa1d9882767a9c8f133
+  data.tar.gz: 980f1818d60f005d69c626e1749c84254b41bf184ff37dd9bc1872c3ba80c8dc96d9922a3be3a0f3be27dc27553de4541fe2a5c9a5529a2cc16bac96f0d74262

data/README.md

@@ -31,15 +31,18 @@ gem install api_diff
 All output is printed to `STDOUT`.
 
 - `--format`: required - specifies the format of the input file (see below).
-- `--strip-packages`: optional - shorten type references by removing package qualifiers.
+- `--short-names`: optional - shorten type references by removing package qualifiers.
 - `--normalize`: optional - transform API to a common, cross-language baseline. Less accurate when comparing APIs of the same language but helpful when comparing across languages. (Early WIP)
 
-
 ### Supported Formats
 
-- `swiftinterface`: Swift module interface files like they are created for frameworks (with library evolution support turned on..?).
+- `swift-interface`: Swift module interface files like they are created for frameworks (with library evolution support turned on..?).
 - `kotlin-bcv`: The output of [Binary Compatibility Validator](https://github.com/Kotlin/binary-compatibility-validator).
 
+### Limitations
+
+- `kotlin-bcv` currently does not support nullability.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. 

data/lib/api_diff/api.rb

@@ -8,19 +8,27 @@ module ApiDiff
       @enums = []
     end
 
-    def class(named:)
-      classes.find { |c| c.name == named }
+    def class(named: nil, fully_qualified_name: nil)
+      classes.find { |c| c.name == named || c.fully_qualified_name == fully_qualified_name }
     end
 
-    def interface(named:)
-      interfaces.find { |i| i.name == named }
+    def interface(named: nil, fully_qualified_name: nil)
+      interfaces.find { |i| i.name == named || i.fully_qualified_name == fully_qualified_name }
     end
 
-    def to_s
+    def enum(named: nil, fully_qualified_name: nil)
+      enums.find { |e| e.name == named || e.fully_qualified_name == fully_qualified_name }
+    end
+
+    def to_s(fully_qualified_names: true, global_sort: false)
       result = []
-      result << enums.map(&:to_s)
-      result << classes.map(&:to_s)
-      result << interfaces.map(&:to_s)
+      if global_sort
+        result << (enums + interfaces + classes).sort.map { |e| e.to_s(fully_qualified_name: fully_qualified_names) }
+      else
+        result << enums.sort.map { |e| e.to_s(fully_qualified_name: fully_qualified_names) }
+        result << interfaces.sort.map { |i| i.to_s(fully_qualified_name: fully_qualified_names) }
+        result << classes.sort.map { |c| c.to_s(fully_qualified_name: fully_qualified_names) }
+      end
       result.flatten.join("\n\n")
     end
   end

data/lib/api_diff/cli.rb

@@ -5,8 +5,9 @@ module ApiDiff
     def parse(arguments)
       parser = OptionParser.new do |opts|
         opts.on("-f", "--format FORMAT", ["swift-interface", "kotlin-bcv"])
-        opts.on("-s", "--strip-packages")
+        opts.on("-s", "--short-names", "Use short instead of fully qualified names")
         opts.on("-n", "--normalize")
+        opts.on("-g", "--global-sort")
       end
       
       options = {}
@@ -34,8 +35,12 @@ module ApiDiff
         parser = KotlinBCVParser.new(options)
       end
 
-      api = parser.parse(IO.read(options[:input]))
-      puts api.to_s
+      parser.parse(IO.read(options[:input]))
+      output = parser.api.to_s(
+        fully_qualified_names: !options[:"short-names"], 
+        global_sort: options[:"global-sort"]
+      )
+      puts output
     end
   end
 end

data/lib/api_diff/interface.rb

@@ -1,4 +1,11 @@
 module ApiDiff
   class Interface < Type
+    def self.type_name
+      @type_name || super
+    end
+    
+    def self.type_name=(name)
+      @type_name = name
+    end
   end
 end

data/lib/api_diff/kotlin_bcv_parser.rb

@@ -2,55 +2,61 @@ module ApiDiff
   # Biggest Drawback: Does not support optionals :-/
   class KotlinBCVParser < Parser
     def parse(content)
-      Property.writable_keyword = "var"
-      Property.readonly_keyword = "val"
-
-      api = Api.new
+      Property.readonly_keyword = "val" unless @options[:normalize]
 
       sections = content.scan(/^.+?{$.*?^}$/m)
       sections.each do |section|
         section.strip!
         first_line = section.split("\n")[0]
         if first_line.include?(" : java/lang/Enum")
-          api.enums << parse_enum(section)
+          parse_enum(section)
+        elsif first_line.include?("interface class")
+          parse_interface(section)
         elsif first_line.match?(/public.+class/)
-          api.classes << parse_class(section)
-        # elsif first_line.match?(/public protocol/)
-        #   api.interfaces << parse_interface(section)
-        # elsif first_line.match?(/extension/)
-        #   parse_extension(api, section)
+          parse_class(section)
         end
       end
 
       normalize!(api) if @options[:normalize]
-
-      api
     end
 
     private
 
     def parse_class(class_content)
-      name = class_content.match(/public.+class ([^\s]+)/)[1]
-      cls = Class.new(transform_package_path(name))
+      qualified_name = transform_package_path class_content.match(/public.+class ([^\s]+)/)[1]
+
+      cls = Class.new(unqualify(qualified_name), qualified_name)
       cls.parents = parse_parents(class_content)
       cls.functions = parse_functions(class_content)
       extract_properties(cls)
-      cls
+      api.classes << cls
+    end
+
+    def parse_interface(interface_content)
+      qualified_name = transform_package_path interface_content.match(/public.+class ([^\s]+)/)[1]
+
+      interface = Interface.new(unqualify(qualified_name), qualified_name)
+      interface.parents = parse_parents(interface_content)
+      interface.functions = parse_functions(interface_content)
+      extract_properties(interface)
+
+      api.interfaces << interface
     end
 
     def parse_enum(enum_content)
-      name = enum_content.match(/public.+class ([^\s]+)/)[1]
-      enum = Enum.new(transform_package_path(name))
+      qualified_name = transform_package_path enum_content.match(/public.+class ([^\s]+)/)[1]
+
+      enum = Enum.new(unqualify(qualified_name), qualified_name)
       enum.cases = parse_enum_cases(enum_content)
       enum.functions = parse_functions(enum_content)
       extract_properties(enum)
-      enum
+      api.enums << enum
     end
 
     def parse_parents(content)
       parents_match = content.match(/\A.+?: (.+?) \{$/)
       return [] if parents_match.nil?
-      parents_match[1].split(",").map { |p| transform_package_path(p.strip) }
+      parents_match[1].split(",").map { |p| unqualify(transform_package_path(p.strip)) }
     end
 
     def parse_functions(content)
@@ -59,12 +65,12 @@ module ApiDiff
         next if match[:name]&.start_with? "component" # don't add data class `componentX` methods
         params_range = ((match.begin(:params) - match.begin(:signature))...(match.end(:params) - match.begin(:signature)))
         signature = match[:signature]
-        signature[params_range] = map_vm_types(match[:params]).join(", ")
+        signature[params_range] = map_jvm_types(match[:params]).join(", ")
         signature.gsub!(/synthetic ?/, "") # synthetic or not, it's part of the API
         Function.new(
           name: (match[:name] || match[:init]),
           signature: signature,
-          return_type: match[:init].nil? ? map_vm_types(match[:return_type]).join : nil,
+          return_type: match[:init].nil? ? map_jvm_types(match[:return_type]).join : nil,
           static: !match[:static].nil?,
           constructor: (not match[:init].nil?)
         )
@@ -103,10 +109,10 @@ module ApiDiff
     end
 
     def transform_package_path(path)
-      strip_packages(path.gsub("/", "."))
+      path.gsub("/", ".")
     end
 
-    def map_vm_types(types)
+    def map_jvm_types(types)
       mapping = {
         "Z" => "Boolean",
         "B" => "Byte",
@@ -121,7 +127,7 @@ module ApiDiff
       vm_types_regexp = /(?<array>\[)?(?<type>Z|B|C|S|I|J|F|D|V|(L(?<class>[^;]+);))/
       all_matches(types, vm_types_regexp).map do |match|
         if match[:class]
-          result = transform_package_path match[:class]
+          result = unqualify(transform_package_path(match[:class]))
         else
           result = mapping[match[:type]]
         end
@@ -131,13 +137,14 @@ module ApiDiff
     end
 
     def normalize!(api)
-      Property.readonly_keyword = "let"
+      api.classes.reject! { |c| c.parents == ["Factory"] }
+      api.classes.reject! { |c| c.name.start_with? "Dagger" }
 
       # remove abstract & final
       # fun -> func
       # <init> -> init
       # remove space before (
-      (api.classes + api.enums).flat_map(&:functions).each do |f|
+      (api.classes + api.interfaces + api.enums).flat_map(&:functions).each do |f|
         f.signature.gsub!(/(?:abstract )?(?:final )?fun (<?\w+>?) \(/, "func \\1(")
         f.signature.gsub!("func <init>", "init")
       end

data/lib/api_diff/parser.rb

@@ -1,7 +1,10 @@
 module ApiDiff
   class Parser
+    attr_reader :api
+    
     def initialize(options = {})
       @options = options
+      @api = Api.new
     end
 
     protected
@@ -11,8 +14,8 @@ module ApiDiff
       string.to_enum(:scan, regex).map { Regexp.last_match }
     end
 
-    def strip_packages(definition)
-      return definition unless @options[:"strip-packages"]
+    def unqualify(definition)
+      return definition unless @options[:"short-names"]
       definition&.gsub(/(?:\w+\.){1,}(\w+)/, "\\1")
     end
   end

data/lib/api_diff/swift_interface_parser.rb

@@ -1,69 +1,101 @@
 module ApiDiff
   class SwiftInterfaceParser < Parser
     def parse(content)
-      api = Api.new
+      Interface.type_name = "protocol" unless @options[:normalize]
 
-      sections = content.scan(/^.+?{$.*?^}$/m)
+      module_name_match = content.match(/@_exported import (\w+)/)
+      container_types = module_name_match ? module_name_match[1] : []
+      parse_blocks(content, container_types)
+      parse_one_line_extensions(content)
+    end
+
+    private
+
+    def parse_blocks(content, container_types = [])
+      sections = content.scan(/^[^\n]+?{$.*?^}$/m)
       sections.each do |section|
         first_line = section.split("\n")[0]
-        if first_line.match?(/public class/)
-          api.classes << parse_class(section)
-        elsif first_line.match?(/public protocol/)
-          api.interfaces << parse_interface(section)
-        elsif first_line.match?(/extension/)
-          parse_extension(api, section)
-        elsif first_line.match?(/public enum/)
-          api.enums << parse_enum(section)
+        if first_line.include? "public class"
+          parse_class(section, container_types)
+        elsif first_line.include? "public protocol"
+          parse_ptotocol(section, container_types)
+        elsif first_line.include? "extension"
+          parse_extension(section, container_types)
+        elsif first_line.include? "public enum"
+          parse_enum(section, container_types)
         end
       end
-
-      api
     end
 
-    private
+    def parse_one_line_extensions(content)
+      one_line_extensions = content.scan(/^extension.+\{\}$/)
+      one_line_extensions.each do |extension|
+        parse_extension(extension, [])
+      end
+    end
 
-    def parse_class(class_content)
+    def parse_class(class_content, container_types)
       name = class_content.match(/public class (\w+)/)[1]
-      cls = Class.new(name)
+
+      cls = Class.new(name, qualified_name(name, container_types))
       cls.parents = parse_parents(class_content)
       cls.properties = parse_properties(class_content)
       cls.functions = parse_functions(class_content)
-      cls
+      api.classes << cls
+
+      parse_nested_types(class_content, [*container_types, name])
     end
 
-    def parse_interface(interface_content)
-      name = interface_content.match(/public protocol (\w+)/)[1]
-      interface = Interface.new(name)
-      interface.parents = parse_parents(interface_content)
-      interface.properties = parse_properties(interface_content)
-      interface.functions = parse_functions(interface_content)
-      interface
+    def parse_ptotocol(protocol_content, container_types)
+      name = protocol_content.match(/public protocol (\w+)/)[1]
+
+      protocol = Interface.new(name, qualified_name(name, container_types))
+      protocol.parents = parse_parents(protocol_content)
+      protocol.properties = parse_properties(protocol_content)
+      protocol.functions = parse_functions(protocol_content)
+      api.interfaces << protocol
+
+      parse_nested_types(protocol_content, [*container_types, name])
     end
 
-    def parse_extension(api, content)
-      name = content.match(/extension (\w+)/)[1]
-      cls = api.class(named: name)
-      cls ||= api.interface(named: name)
-      raise Error.new "Unable to find base type for extension `#{name}`" if cls.nil?
-      cls.parents.append(*parse_parents(content)).uniq!
-      cls.properties.append(*parse_properties(content)).uniq!
-      cls.functions.append(*parse_functions(content)).uniq!
+    def parse_extension(content, container_types)
+      name = content.match(/extension ([\w\.]+)/)[1]
+
+      base_type = api.class(fully_qualified_name: qualified_name(name, container_types))
+      base_type ||= api.interface(fully_qualified_name: qualified_name(name, container_types))
+      base_type ||= api.enum(fully_qualified_name: qualified_name(name, container_types))
+      raise Error.new "Unable to find base type for extension `#{name}`" if base_type.nil?
+      base_type.parents.append(*parse_parents(content)).uniq!
+      base_type.properties.append(*parse_properties(content)).uniq!
+      base_type.functions.append(*parse_functions(content)).uniq!
+
+      parse_nested_types(content, [*container_types, name])
     end
 
-    def parse_enum(enum_content)
+    def parse_enum(enum_content, container_types)
       name = enum_content.match(/public enum (\w+)/)[1]
-      enum = Enum.new(name)
+
+      enum = Enum.new(name, qualified_name(name, container_types))
       enum.cases = parse_enum_cases(enum_content)
       enum.parents = parse_parents(enum_content)
       enum.properties = parse_properties(enum_content)
       enum.functions = parse_functions(enum_content)
-      enum
+      api.enums << enum
+
+      parse_nested_types(enum_content, [*container_types, name])
+    end
+
+    def parse_nested_types(outer_content, container_types)
+      # remove first and last line and un-indent the inner lines
+      inner_content = outer_content.split("\n")[1..-2].map { |l| l.gsub(/^\s{,2}/, "") }.join("\n")
+
+      parse_blocks(inner_content, container_types)
     end
 
     def parse_parents(content)
-      parents_match = content.match(/\A.+?: (.+?) \{$/)
+      parents_match = content.match(/\A.+?: (.+?) \{\}?$/)
       return [] if parents_match.nil?
-      parents_match[1].split(",").map { |p| strip_packages(p.strip) }
+      parents_match[1].split(",").map { |p| unqualify(p.strip) }
     end
 
     def parse_properties(content)
@@ -71,7 +103,7 @@ module ApiDiff
       all_matches(content, property_regexp).map do |match|
         Property.new(
           name: match[:name],
-          type: strip_packages(match[:type]),
+          type: unqualify(match[:type]),
           writable: (match[:varlet] == "var" && (match[:get] == nil || match[:set] != nil)),
           static: !match[:static].nil?
         )
@@ -83,8 +115,8 @@ module ApiDiff
       all_matches(content, method_regexp).map do |match|
         Function.new(
           name: (match[:name] || match[:init]),
-          signature: strip_internal_parameter_names(strip_packages(match[:signature])).strip,
-          return_type: strip_packages(match[:return_type]),
+          signature: strip_internal_parameter_names(unqualify(match[:signature])).strip,
+          return_type: unqualify(match[:return_type]),
           static: !match[:static].nil?,
           constructor: (not match[:init].nil?)
         )
@@ -94,13 +126,16 @@ module ApiDiff
     def parse_enum_cases(content)
       case_regexp = /case (?<name>.+)$/
       all_matches(content, case_regexp).map do |match|
-        match[:name]
+        unqualify(match[:name])
       end
     end
 
+    def qualified_name(name, container_types)
+      [*container_types, name].join(".")
+    end
+
     def strip_internal_parameter_names(signature)
       signature.gsub(/(\w+)\s\w+:/, "\\1:")
     end
-
   end
 end

data/lib/api_diff/type.rb

@@ -1,18 +1,23 @@
 module ApiDiff
   class Type
-    attr_reader :name
+    def self.type_name
+      name.split('::').last.downcase
+    end
+
+    attr_reader :name, :fully_qualified_name
     attr_accessor :parents, :functions, :properties
 
-    def initialize(name)
+    def initialize(name, fully_qualified_name)
       @name = name
+      @fully_qualified_name = fully_qualified_name
       @parents = []
       @functions = []
       @properties = []
     end
 
-    def declaration
-      kind = self.class.name.split('::').last.downcase
-      result = "#{kind} #{name}"
+    def declaration(fully_qualified_name: false)
+      name = fully_qualified_name ? self.fully_qualified_name : self.name
+      result = "#{self.class.type_name} #{name}"
       result += " : #{parents.join(", ")}" if has_parents?
       result
     end
@@ -28,12 +33,16 @@ module ApiDiff
       ]
     end
 
-    def to_s
+    def <=>(other)
+      name <=> other.name
+    end
+
+    def to_s(fully_qualified_name: true)
       body = sections.map { |s| s.empty? ? nil : s }.compact # remove empty sections
       body.map! { |s| s.map { |entry| "    #{entry}" } }  # convert every entry in every section into a string and indent it
       body.map! { |s| s.join("\n") }  # join all entries into a long string
       [
-        "#{declaration} {",
+        "#{declaration(fully_qualified_name: fully_qualified_name)} {",
         body.join("\n\n"),
         "}"
       ].join("\n")

data/lib/api_diff/version.rb

@@ -1,3 +1,3 @@
 module ApiDiff
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/test/kotlin_bcv_parser_test.rb

@@ -1,12 +1,14 @@
 require "test_helper"
 
 class KotlinBCVParserTest < Minitest::Test
-  def parser(strip: true, normalize: false)
-    ApiDiff::KotlinBCVParser.new "strip-packages": strip, normalize: normalize
+  def parse(content, short_names: true, normalize: false)
+    parser = ApiDiff::KotlinBCVParser.new "short-names": short_names, normalize: normalize
+    parser.parse(content)
+    parser.api
   end
 
   def test_returns_api
-    assert_instance_of ApiDiff::Api, parser.parse("")
+    assert_instance_of ApiDiff::Api, parse("")
   end
 
   def test_classes
@@ -23,7 +25,7 @@ class KotlinBCVParserTest < Minitest::Test
       }
     EOF
 
-    api = parser(strip: false).parse(input)
+    api = parse(input, short_names: false)
     classes = api.classes
     assert_equal 5, classes.size
 
@@ -63,7 +65,7 @@ class KotlinBCVParserTest < Minitest::Test
       }
     EOF
 
-    api = parser.parse(input)
+    api = parse(input)
     functions = api.classes.first.functions
     assert_equal 9, functions.size
 
@@ -110,7 +112,7 @@ class KotlinBCVParserTest < Minitest::Test
       }
     EOF
 
-    api = parser.parse(input)
+    api = parse(input)
     functions = api.classes.first.functions
     assert_equal 0, functions.size
   end
@@ -126,7 +128,7 @@ class KotlinBCVParserTest < Minitest::Test
       }
     EOF
 
-    api = parser.parse(input)
+    api = parse(input)
     assert_equal 0, api.classes.first.functions.size
     properties = api.classes.first.properties
     assert_equal 4, properties.size
@@ -150,6 +152,29 @@ class KotlinBCVParserTest < Minitest::Test
     assert_equal "fqdn", fqdn.name
   end
 
+  def test_interfaces
+    input = <<~EOF
+      public abstract interface class com/package/WithFunctions {
+        public abstract fun abstractAction ()V
+      }
+      public abstract interface class com/nested/package/WithProperties {
+        public final fun getName ()Ljava/lang/String;
+        public final fun setName (Ljava/lang/String;)V
+      }
+    EOF
+
+    api = parse(input)
+    interfaces = api.interfaces
+    assert_equal 2, interfaces.size
+
+    with_functions = interfaces[0]
+    assert_equal "abstractAction", with_functions.functions[0].name
+
+    with_properties = interfaces[1]
+    assert_equal 1, with_properties.properties.size
+    assert_equal "name", with_properties.properties[0].name
+  end
+
   def test_companion_objects
     # TypeCode
     # Metadata
@@ -171,7 +196,7 @@ class KotlinBCVParserTest < Minitest::Test
       }
     EOF
 
-    api = parser.parse(input)
+    api = parse(input)
     enums = api.enums
     assert_equal 1, enums.size
 
@@ -201,7 +226,7 @@ class KotlinBCVParserTest < Minitest::Test
       }
     EOF
 
-    api = parser(normalize: true).parse(input)
+    api = parse(input, normalize: true)
     
     first_class = api.classes.first
     assert_equal 3, first_class.functions.size

data/test/swift_interface_parser_test.rb

@@ -1,12 +1,14 @@
 require "test_helper"
 
 class SwiftInterfaceParserTest < Minitest::Test
-  def parser
-    ApiDiff::SwiftInterfaceParser.new "strip-packages": true
+  def parse(content)
+    parser = ApiDiff::SwiftInterfaceParser.new "short-names": true
+    parser.parse(content)
+    parser.api
   end
 
   def test_returns_api
-    assert_instance_of ApiDiff::Api, parser.parse("")
+    assert_instance_of ApiDiff::Api, parse("")
   end
 
   def test_classes
@@ -20,7 +22,7 @@ class SwiftInterfaceParserTest < Minitest::Test
       public class Fourth : Swift.Codable, Swift.Hashable {
       }
     EOF
-    api = parser.parse(input)
+    api = parse(input)
     classes = api.classes
     assert_equal 4, classes.size
 
@@ -55,7 +57,7 @@ class SwiftInterfaceParserTest < Minitest::Test
         }
       }
     EOF
-    api = parser.parse(input)
+    api = parse(input)
     properties = api.classes.first.properties
     assert_equal 4, properties.size
     
@@ -93,7 +95,7 @@ class SwiftInterfaceParserTest < Minitest::Test
       }
     EOF
 
-    api = parser.parse(input)
+    api = parse(input)
     functions = api.classes.first.functions
     assert_equal 6, functions.size
 
@@ -144,7 +146,7 @@ class SwiftInterfaceParserTest < Minitest::Test
       }
     EOF
 
-    api = parser.parse(input)
+    api = parse(input)
     classes = api.classes
     assert_equal 3, classes.size
 
@@ -175,7 +177,7 @@ class SwiftInterfaceParserTest < Minitest::Test
       }
     EOF
 
-    api = parser.parse(input)
+    api = parse(input)
     interfaces = api.interfaces
     assert_equal 2, interfaces.size
 
@@ -216,7 +218,7 @@ class SwiftInterfaceParserTest < Minitest::Test
       }
     EOF
 
-    api = parser.parse(input)
+    api = parse(input)
     interfaces = api.interfaces
     assert_equal 3, interfaces.size
 
@@ -241,8 +243,9 @@ class SwiftInterfaceParserTest < Minitest::Test
         case a
       }
       @frozen public enum Beta {
-        case c
-        case d
+        case c(number: Swift.Int)
+        case d(name: Swift.String? = nil)
+        case lambda(func: ((Swift.Double) -> Swift.Void)?)
       }
       @frozen public enum Gamma : Swift.String, Swift.CaseIterable {
         case e
@@ -251,7 +254,7 @@ class SwiftInterfaceParserTest < Minitest::Test
       }
     EOF
 
-    api = parser.parse(input)
+    api = parse(input)
     enums = api.enums
     assert_equal 3, enums.size
 
@@ -261,7 +264,7 @@ class SwiftInterfaceParserTest < Minitest::Test
 
     beta = enums[1]
     assert_equal "Beta", beta.name
-    assert_equal ["c", "d"], beta.cases
+    assert_equal ["c(number: Int)", "d(name: String? = nil)", "lambda(func: ((Double) -> Void)?)"], beta.cases
 
     gamma = enums[2]
     assert_equal "Gamma", gamma.name
@@ -269,4 +272,130 @@ class SwiftInterfaceParserTest < Minitest::Test
     assert_equal ["e", "f", "g"], gamma.cases
     assert_equal ["String", "CaseIterable"], gamma.parents
   end
+
+  def test_ignores_header_noise
+    input = <<~EOF
+      // swift-interface-format-version: 1.0
+      // swift-compiler-version: Apple Swift version 5.3 (swiftlang-1200.0.29.2 clang-1200.0.30.1)
+      // swift-module-flags: -target arm64-apple-ios12.0 -enable-objc-interop -enable-library-evolution -swift-version 5 -enforce-exclusivity=checked -O -module-name ePA
+      import AVFoundation
+      import CoreMotion
+      import CoreNFC
+      import Foundation
+      import Security
+      import Swift
+      import UIKit
+      @_exported import MyLib
+      import os.log
+      import os
+      public class NotIgnored {
+      }
+    EOF
+
+    api = parse(input)
+
+    assert api.class(named: "NotIgnored")
+  end
+
+  def test_full_name_qualification
+    input = <<~EOF
+      @_exported import MyLib
+      public class Qualified {
+      }
+    EOF
+
+    api = parse(input)
+
+    qualified = api.classes.first
+    assert_equal "MyLib.Qualified", qualified.fully_qualified_name
+  end
+
+  def test_nested_types
+    input = <<~EOF
+      public class OuterClass {
+        public class InnerClass {
+          public func a()
+        }
+      }
+      extension OuterClass {
+        @frozen public enum ExtensionInner {
+          case ei1
+        }
+      }
+      public enum OuterEnum {
+        public class EnumInnerClass {
+        }
+      }
+      public enum Level1 {
+        public class Level2 {
+          public enum Level3 {
+            public class Level4 {
+
+            }
+          }
+        }
+      }
+    EOF
+
+    api = parse(input)
+
+    inner_class = api.class(named: "InnerClass")
+    assert_equal "OuterClass.InnerClass", inner_class.fully_qualified_name
+    assert_equal "a", inner_class.functions.first.name
+
+    extension_inner = api.enum(named: "ExtensionInner")
+    assert_equal ["ei1"], extension_inner.cases
+    assert_equal "OuterClass.ExtensionInner", extension_inner.fully_qualified_name
+
+    enum_inner_class = api.class(named: "EnumInnerClass")
+    assert_equal "OuterEnum.EnumInnerClass", enum_inner_class.fully_qualified_name
+
+    assert api.enum(named: "Level1")
+    assert api.class(named: "Level2")
+    assert api.enum(named: "Level3")
+    assert api.class(named: "Level4")
+    assert_equal "Level1.Level2.Level3.Level4", api.class(named: "Level4").fully_qualified_name
+  end
+
+  def test_nested_name_conflict
+    input = <<~EOF
+      public class Conflict {
+      }
+      public enum Nested {
+        public class Conflict {
+        }
+      }
+      extension Conflict {
+        public func topLevel()
+      }
+      extension Nested.Conflict {
+        public func nested()
+      }
+    EOF
+
+    api = parse(input)
+
+    assert_equal 2, api.classes.size
+
+    top_level = api.class(fully_qualified_name: "Conflict")
+    assert_equal "topLevel", top_level.functions.first.name
+
+    nested = api.class(fully_qualified_name: "Nested.Conflict")
+    assert_equal "nested", nested.functions.first.name
+  end
+
+  def test_qualified_one_line_extensions
+    input = <<~EOF
+      @_exported import MyLib
+      public enum Enum {
+        case a
+      }
+      extension MyLib.Enum : Swift.Hashable {}
+    EOF
+
+    api = parse(input)
+    enum = api.enums.first
+
+    assert_equal ["Hashable"], enum.parents
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: api_diff
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Sebastian Ludwig
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-25 00:00:00.000000000 Z
+date: 2021-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest