api_diff 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bcfbf61d2a4f9b1a5abfaf3ee30e6c41a12048e971281424797bfc8067c9d467
+  data.tar.gz: aabe1cc6429ff84100719bf26d691e9825502ffc2bf32736a9880c4f308477c8
+SHA512:
+  metadata.gz: bd3944386bbdf2c713b2ac647dc38fc50132211ee9af2f06c97f821e31aca8981e710b5a9c2bbc987b8866ed512dc09ad9f2ed802f6bfcd98e33fd2d2858d99d
+  data.tar.gz: bbd34214c44954e6f2075fbd26a9115a0cbad590790565c282447b67e6590b8a7533678558f7ca3e7b995d11367df8ee91be131532b3da9fc41dcae954854020

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in api_diff.gemspec
+gemspec
+
+gem "rake", "~> 12.0"

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Sebastian Ludwig
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,58 @@
+# API Diff
+
+Bring APIs into an easily diff-able format.
+
+## Installation
+
+Add this line to your application's `Gemfile`
+
+```ruby
+gem 'api_diff'
+```
+
+and then execute
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install api_diff
+```
+
+## Usage
+
+```bash
+./api_diff --format FORMAT <input-file>
+```
+
+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.
+- `--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..?).
+- `kotlin-bcv`: The output of [Binary Compatibility Validator](https://github.com/Kotlin/binary-compatibility-validator).
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 
+Then, run `rake test` to run the tests. 
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. 
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sebastianludwig/api-diff.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/exe/api_diff

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require "api_diff"
+
+begin
+  ApiDiff::Cli.new.run!(ARGV)
+rescue ApiDiff::Error => e
+  abort e.message
+end

data/lib/api_diff.rb

@@ -0,0 +1,16 @@
+require "api_diff/version"
+require "api_diff/api"
+require "api_diff/type"
+require "api_diff/class"
+require "api_diff/interface"
+require "api_diff/enum"
+require "api_diff/function"
+require "api_diff/property"
+require "api_diff/parser"
+require "api_diff/swift_interface_parser"
+require "api_diff/kotlin_bcv_parser"
+require "api_diff/cli"
+
+module ApiDiff
+  class Error < StandardError; end
+end

data/lib/api_diff/api.rb

@@ -0,0 +1,27 @@
+module ApiDiff
+  class Api
+    attr_accessor :classes, :interfaces, :enums
+
+    def initialize
+      @classes = []
+      @interfaces = []
+      @enums = []
+    end
+
+    def class(named:)
+      classes.find { |c| c.name == named }
+    end
+
+    def interface(named:)
+      interfaces.find { |i| i.name == named }
+    end
+
+    def to_s
+      result = []
+      result << enums.map(&:to_s)
+      result << classes.map(&:to_s)
+      result << interfaces.map(&:to_s)
+      result.flatten.join("\n\n")
+    end
+  end
+end

data/lib/api_diff/class.rb

@@ -0,0 +1,4 @@
+module ApiDiff
+  class Class < Type
+  end
+end

data/lib/api_diff/cli.rb

@@ -0,0 +1,41 @@
+require "optparse"
+
+module ApiDiff
+  class Cli
+    def parse(arguments)
+      parser = OptionParser.new do |opts|
+        opts.on("-f", "--format FORMAT", ["swift-interface", "kotlin-bcv"])
+        opts.on("-s", "--strip-packages")
+        opts.on("-n", "--normalize")
+      end
+      
+      options = {}
+      begin
+        parser.parse!(arguments, into: options)
+      rescue OptionParser::ParseError => e
+        raise Error.new e.message
+      end
+
+      options[:input] = arguments.pop
+      
+      raise Error.new "Missing argument: format" if options[:format].nil?
+      raise Error.new "Missing argument: input" if options[:input].nil?
+
+      options
+    end
+
+    def run!(arguments)
+      options = parse(arguments)
+      raise Error.new "Input file not found: #{options[:input]}" if not File.exist? options[:input]
+
+      if options[:format] == "swift-interface"
+        parser = SwiftInterfaceParser.new(options)
+      elsif options[:format] == "kotlin-bcv"
+        parser = KotlinBCVParser.new(options)
+      end
+
+      api = parser.parse(IO.read(options[:input]))
+      puts api.to_s
+    end
+  end
+end

data/lib/api_diff/enum.rb

@@ -0,0 +1,12 @@
+module ApiDiff
+  class Enum < Type
+    attr_accessor :cases
+
+    def sections
+      [
+        cases.sort.map { |c| "case #{c}" },
+        *super
+      ]
+    end
+  end
+end

data/lib/api_diff/function.rb

@@ -0,0 +1,58 @@
+module ApiDiff
+  class Function
+    attr_reader :name, :signature, :return_type
+
+    def initialize(name:, signature:, return_type:, static:, constructor:)
+      @name = name
+      @signature = signature
+      @return_type = return_type
+      @static = static
+      @constructor = constructor
+    end
+
+    def is_constructor?
+      @constructor
+    end
+
+    def is_static?
+      @static
+    end
+
+    def to_s
+      full_signature
+    end
+
+    def full_signature
+      if return_type.nil?
+        signature
+      else
+        "#{signature} -> #{return_type}"
+      end
+    end
+
+    def hash
+      full_signature.hash
+    end
+
+    def eql?(other)
+      full_signature == other.full_signature
+    end
+
+    def <=>(other)
+      # static at the bottom
+      return 1 if is_static? and not other.is_static?
+      return -1 if not is_static? and other.is_static?
+
+      # constructors first
+      return -1 if is_constructor? and not other.is_constructor?
+      return 1 if not is_constructor? and other.is_constructor?
+
+      if is_constructor?
+        # sort constructors by length
+        [full_signature.size, full_signature] <=> [other.full_signature.size, other.full_signature]
+      else
+        [name, full_signature] <=> [other.name, other.full_signature]
+      end
+    end
+  end
+end

data/lib/api_diff/interface.rb

@@ -0,0 +1,4 @@
+module ApiDiff
+  class Interface < Type
+  end
+end

data/lib/api_diff/kotlin_bcv_parser.rb

@@ -0,0 +1,157 @@
+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
+
+      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)
+        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)
+        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))
+      cls.parents = parse_parents(class_content)
+      cls.functions = parse_functions(class_content)
+      extract_properties(cls)
+      cls
+    end
+
+    def parse_enum(enum_content)
+      name = enum_content.match(/public.+class ([^\s]+)/)[1]
+      enum = Enum.new(transform_package_path(name))
+      enum.cases = parse_enum_cases(enum_content)
+      enum.functions = parse_functions(enum_content)
+      extract_properties(enum)
+      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) }
+    end
+
+    def parse_functions(content)
+      method_regexp = /public (?<signature>(?<static>static )?.*fun (?:(<(?<init>init)>)|(?<name>[^\s]+)) \((?<params>.*)\))(?<return_type>.+)$/
+      all_matches(content, method_regexp).map do |match|
+        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.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,
+          static: !match[:static].nil?,
+          constructor: (not match[:init].nil?)
+        )
+      end.compact
+    end
+
+    def parse_enum_cases(content)
+      case_regexp = /public static final field (?<name>[A-Z_0-9]+)/
+      all_matches(content, case_regexp).map do |match|
+        match[:name]
+      end
+    end
+
+    def extract_properties(type)
+      getters = type.functions.select { |f| f.signature.match(/fun get[A-Z](\w+)? \(\)/) }
+      getters.each do |getter|
+        setter_name = getter.name.gsub(/^get/, "set")
+        setter = type.functions.find { |f| f.signature.match(/fun #{setter_name} \(#{getter.return_type}\)/) }
+
+        type.functions.delete getter
+        type.functions.delete setter if setter
+
+        name = getter.name.gsub(/^get/, "")
+        if name == name.upcase  # complete uppercase -> complete lowercase
+          name.downcase!
+        else
+          name[0] = name[0].downcase
+        end
+        type.properties << Property.new(
+          name: name,
+          type: getter.return_type,
+          writable: (setter != nil),
+          static: getter.is_static?
+        )
+      end
+    end
+
+    def transform_package_path(path)
+      strip_packages(path.gsub("/", "."))
+    end
+
+    def map_vm_types(types)
+      mapping = {
+        "Z" => "Boolean",
+        "B" => "Byte",
+        "C" => "Char",
+        "S" => "Short",
+        "I" => "Int",
+        "J" => "Long",
+        "F" => "Float",
+        "D" => "Double",
+        "V" => "Void"
+      }
+      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]
+        else
+          result = mapping[match[:type]]
+        end
+        result = "[#{result}]" if match[:array]
+        result
+      end
+    end
+
+    def normalize!(api)
+      Property.readonly_keyword = "let"
+
+      # remove abstract & final
+      # fun -> func
+      # <init> -> init
+      # remove space before (
+      (api.classes + api.enums).flat_map(&:functions).each do |f|
+        f.signature.gsub!(/(?:abstract )?(?:final )?fun (<?\w+>?) \(/, "func \\1(")
+        f.signature.gsub!("func <init>", "init")
+      end
+
+      # enum screaming case -> camel case
+      api.enums.each do |e|
+        e.cases = e.cases.map do |c|
+          # supports double _ by preserving one of them
+          c.scan(/_?[A-Z0-9]+_?/).map.with_index do |p, index|
+            p.gsub(/_$/, "").downcase.gsub(/^_?\w/) { |m| index == 0 ? m : m.upcase }
+          end.join
+        end
+      end
+
+    end
+  end
+end

data/lib/api_diff/parser.rb

@@ -0,0 +1,19 @@
+module ApiDiff
+  class Parser
+    def initialize(options = {})
+      @options = options
+    end
+
+    protected
+
+    def all_matches(string, regex)
+      # taken from https://stackoverflow.com/a/6807722/588314
+      string.to_enum(:scan, regex).map { Regexp.last_match }
+    end
+
+    def strip_packages(definition)
+      return definition unless @options[:"strip-packages"]
+      definition&.gsub(/(?:\w+\.){1,}(\w+)/, "\\1")
+    end
+  end
+end

data/lib/api_diff/property.rb

@@ -0,0 +1,52 @@
+module ApiDiff
+  class Property
+    @writable_keyword = "var"
+    @readonly_keyword = "let"
+
+    class << self
+      attr_accessor :writable_keyword, :readonly_keyword
+    end
+
+    attr_reader :name, :type
+
+    def initialize(name:, type:, writable:, static:)
+      @name = name
+      @type = type
+      @writable = writable
+      @static = static
+    end
+
+    def is_writable?
+      @writable
+    end
+
+    def is_static?
+      @static
+    end
+
+    def hash
+      to_s.hash
+    end
+
+    def eql?(other)
+      to_s == other.to_s
+    end
+
+    def to_s
+      result = []
+      result << "static" if is_static?
+      result << (is_writable? ? self.class.writable_keyword : self.class.readonly_keyword)
+      result << "#{name}: #{type}"
+      result.join(" ")
+    end
+
+    def <=>(other)
+      # static at the bottom
+      return 1 if is_static? and not other.is_static?
+      return -1 if not is_static? and other.is_static?
+
+      # sort by name
+      name <=> other.name
+    end
+  end
+end

data/lib/api_diff/swift_interface_parser.rb

@@ -0,0 +1,106 @@
+module ApiDiff
+  class SwiftInterfaceParser < Parser
+    def parse(content)
+      api = Api.new
+
+      sections = content.scan(/^.+?{$.*?^}$/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)
+        end
+      end
+
+      api
+    end
+
+    private
+
+    def parse_class(class_content)
+      name = class_content.match(/public class (\w+)/)[1]
+      cls = Class.new(name)
+      cls.parents = parse_parents(class_content)
+      cls.properties = parse_properties(class_content)
+      cls.functions = parse_functions(class_content)
+      cls
+    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
+    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!
+    end
+
+    def parse_enum(enum_content)
+      name = enum_content.match(/public enum (\w+)/)[1]
+      enum = Enum.new(name)
+      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
+    end
+
+    def parse_parents(content)
+      parents_match = content.match(/\A.+?: (.+?) \{$/)
+      return [] if parents_match.nil?
+      parents_match[1].split(",").map { |p| strip_packages(p.strip) }
+    end
+
+    def parse_properties(content)
+      property_regexp = /(public )?(?<static>static )?(?<varlet>var|let) (?<name>\w+): (?<type>[^\s]+)( {\s+(?<get>get)?\s+(?<set>set)?\s*})?/m
+      all_matches(content, property_regexp).map do |match|
+        Property.new(
+          name: match[:name],
+          type: strip_packages(match[:type]),
+          writable: (match[:varlet] == "var" && (match[:get] == nil || match[:set] != nil)),
+          static: !match[:static].nil?
+        )
+      end
+    end
+
+    def parse_functions(content)
+      method_regexp = /(?<signature>(?<static>static )?((func (?<name>[^\s\(]+))|(?<init>init))\s?\((?<params>.*)\).*?)(-> (?<return_type>.+))?$/
+      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]),
+          static: !match[:static].nil?,
+          constructor: (not match[:init].nil?)
+        )
+      end
+    end
+
+    def parse_enum_cases(content)
+      case_regexp = /case (?<name>.+)$/
+      all_matches(content, case_regexp).map do |match|
+        match[:name]
+      end
+    end
+
+    def strip_internal_parameter_names(signature)
+      signature.gsub(/(\w+)\s\w+:/, "\\1:")
+    end
+
+  end
+end

data/lib/api_diff/type.rb

@@ -0,0 +1,42 @@
+module ApiDiff
+  class Type
+    attr_reader :name
+    attr_accessor :parents, :functions, :properties
+
+    def initialize(name)
+      @name = name
+      @parents = []
+      @functions = []
+      @properties = []
+    end
+
+    def declaration
+      kind = self.class.name.split('::').last.downcase
+      result = "#{kind} #{name}"
+      result += " : #{parents.join(", ")}" if has_parents?
+      result
+    end
+
+    def has_parents?
+      not @parents.empty?
+    end
+
+    def sections
+      [
+        properties.sort,
+        functions.sort
+      ]
+    end
+
+    def to_s
+      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} {",
+        body.join("\n\n"),
+        "}"
+      ].join("\n")
+    end
+  end
+end

data/lib/api_diff/version.rb

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

data/test/kotlin_bcv_parser_test.rb

@@ -0,0 +1,215 @@
+require "test_helper"
+
+class KotlinBCVParserTest < Minitest::Test
+  def parser(strip: true, normalize: false)
+    ApiDiff::KotlinBCVParser.new "strip-packages": strip, normalize: normalize
+  end
+
+  def test_returns_api
+    assert_instance_of ApiDiff::Api, parser.parse("")
+  end
+
+  def test_classes
+    input = <<~EOF
+      public class First {
+      }
+      public final class com/abc/Second {
+      }
+      public abstract class com/a/b/c/Third {
+      }
+      public final class com/a/Fourth : com/a/Parent {
+      }
+      public final class com/a/Fifth : com/a/Parent, java/io/Serializable {
+      }
+    EOF
+
+    api = parser(strip: false).parse(input)
+    classes = api.classes
+    assert_equal 5, classes.size
+
+    first = classes[0]
+    assert_equal "First", first.name
+    assert_equal "class First", first.declaration
+
+    second = classes[1]
+    assert_equal "com.abc.Second", second.name
+    assert_equal "class com.abc.Second", second.declaration
+
+    third = classes[2]
+    assert_equal "com.a.b.c.Third", third.name
+    assert_equal "class com.a.b.c.Third", third.declaration
+
+    fourth = classes[3]
+    assert_equal "com.a.Fourth", fourth.name
+    assert_equal "class com.a.Fourth : com.a.Parent", fourth.declaration
+
+    fifth = classes[4]
+    assert_equal "com.a.Fifth", fifth.name
+    assert_equal "class com.a.Fifth : com.a.Parent, java.io.Serializable", fifth.declaration
+  end
+
+  def test_functions
+    input = <<~EOF
+      public class FirstClass {
+        public fun action ()V
+        public final fun finalAction ()V
+        public abstract fun abstractAction ()V
+        public fun hashCode ()I
+        public fun toString ()Ljava/lang/String;
+        public fun check (Ljava/lang/String;)Z
+        public fun <init> ()V
+        public synthetic fun <init> (ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+        public static synthetic fun hide$default (Lcom/a/Second;ILjava/lang/Object;)V
+      }
+    EOF
+
+    api = parser.parse(input)
+    functions = api.classes.first.functions
+    assert_equal 9, functions.size
+
+    action = functions[0]
+    assert_equal "action", action.name
+    assert_equal "fun action () -> Void", action.full_signature
+
+    final_action = functions[1]
+    assert_equal "finalAction", final_action.name
+    assert_equal "final fun finalAction () -> Void", final_action.full_signature
+
+    abstract_action = functions[2]
+    assert_equal "abstractAction", abstract_action.name
+    assert_equal "abstract fun abstractAction () -> Void", abstract_action.full_signature
+
+    hash_code = functions[3]
+    assert_equal "hashCode", hash_code.name
+    assert_equal "fun hashCode () -> Int", hash_code.full_signature
+
+    to_string = functions[4]
+    assert_equal "toString", to_string.name
+    assert_equal "fun toString () -> String", to_string.full_signature
+
+    check = functions[5]
+    assert_equal "check", check.name
+    assert_equal "fun check (String) -> Boolean", check.full_signature
+
+    init = functions[6]
+    assert_equal "init", init.name
+    assert_equal "fun <init> ()", init.full_signature
+
+    syn_init = functions[7]
+    assert_equal "init", syn_init.name
+    assert_equal "fun <init> (Int, DefaultConstructorMarker)", syn_init.full_signature
+  end
+
+  def test_omits_component_functions
+    input = <<~EOF
+      public class DataClass {
+        public final fun component1 ()Ljava/lang/String;
+        public final fun component2 ()Ljava/lang/String;
+        public final fun component3 ()Ljava/lang/String;
+        public final fun component4 ()Ljava/util/List;
+      }
+    EOF
+
+    api = parser.parse(input)
+    functions = api.classes.first.functions
+    assert_equal 0, functions.size
+  end
+
+  def test_properties
+    input = <<~EOF
+      public class Properties {
+        public fun getNumber ()I
+        public final fun getId ()Ljava/lang/String;
+        public final fun getName ()Ljava/lang/String;
+        public final fun setName (Ljava/lang/String;)V
+        public final fun getFQDN ()Ljava/lang/String;
+      }
+    EOF
+
+    api = parser.parse(input)
+    assert_equal 0, api.classes.first.functions.size
+    properties = api.classes.first.properties
+    assert_equal 4, properties.size
+
+    number = properties[0]
+    assert_equal "number", number.name
+    assert_equal "Int", number.type
+    assert !number.is_writable?
+
+    id = properties[1]
+    assert_equal "id", id.name
+    assert_equal "String", id.type
+    assert !id.is_writable?
+
+    name = properties[2]
+    assert_equal "name", name.name
+    assert_equal "String", name.type
+    assert name.is_writable?
+
+    fqdn = properties[3]
+    assert_equal "fqdn", fqdn.name
+  end
+
+  def test_companion_objects
+    # TypeCode
+    # Metadata
+  end
+
+  def test_enums
+    input = <<~EOF
+      public final class com/package/Reason : java/lang/Enum {
+        public static final field GOOD Lcom/package/Reason;
+        public static final field NOT_SO_GOOD Lcom/package/Reason;
+        public static final field BAD Lcom/package/Reason;
+        public static final field NONE Lcom/package/Reason;
+        public static final field BFG1000_THING Lcom/package/Reason;
+
+        public final fun getCode ()I;
+        public final fun getName ()Ljava/lang/String;
+        public static fun valueOf (Ljava/lang/String;)Lcom/package/Reason;
+        public static fun values ()[LLcom/package/Reason;
+      }
+    EOF
+
+    api = parser.parse(input)
+    enums = api.enums
+    assert_equal 1, enums.size
+
+    reason = enums[0]
+    assert_equal "Reason", reason.name
+    assert_equal ["GOOD", "NOT_SO_GOOD", "BAD", "NONE", "BFG1000_THING"], reason.cases
+    assert_equal 2, reason.functions.size
+    assert_equal "static fun valueOf (String) -> Reason", reason.functions[0].full_signature
+    assert_equal "static fun values () -> [Reason]", reason.functions[1].full_signature
+    assert_equal 2, reason.properties.size
+    assert_equal "val code: Int", reason.properties[0].to_s
+    assert_equal "val name: String", reason.properties[1].to_s
+  end
+
+  def test_normalization
+    input = <<~EOF
+      public class FirstClass {
+        public fun <init> ()V
+        public final fun finalAction ()V
+        public abstract fun abstractAction ()V
+      }
+
+      public final class com/package/Reason : java/lang/Enum {
+        public static final field GOOD Lcom/package/Reason;
+        public static final field NOT_SO_GOOD Lcom/package/Reason;
+        public static final field REALLY__UNCONVENTIONAL Lcom/package/Reason;
+      }
+    EOF
+
+    api = parser(normalize: true).parse(input)
+    
+    first_class = api.classes.first
+    assert_equal 3, first_class.functions.size
+    assert_equal "init()", first_class.functions[0].full_signature
+    assert_equal "func finalAction() -> Void", first_class.functions[1].full_signature
+    assert_equal "func abstractAction() -> Void", first_class.functions[2].full_signature
+
+    reason = api.enums.first
+    assert_equal ["good", "notSoGood", "really_Unconventional"], reason.cases
+  end
+end

data/test/swift_interface_parser_test.rb

@@ -0,0 +1,272 @@
+require "test_helper"
+
+class SwiftInterfaceParserTest < Minitest::Test
+  def parser
+    ApiDiff::SwiftInterfaceParser.new "strip-packages": true
+  end
+
+  def test_returns_api
+    assert_instance_of ApiDiff::Api, parser.parse("")
+  end
+
+  def test_classes
+    input = <<~EOF
+      public class First {
+      }
+      @_hasMissingDesignatedInitializers public class Second {
+      }
+      public class Third : Package.Parent {
+      }
+      public class Fourth : Swift.Codable, Swift.Hashable {
+      }
+    EOF
+    api = parser.parse(input)
+    classes = api.classes
+    assert_equal 4, classes.size
+
+    first = classes[0]
+    assert_equal "First", first.name
+    assert_equal "class First", first.declaration
+
+    second = classes[1]
+    assert_equal "Second", second.name
+    assert_equal "class Second", second.declaration
+
+    third = classes[2]
+    assert_equal "Third", third.name
+    assert_equal "class Third : Parent", third.declaration
+
+    fourth = classes[3]
+    assert_equal "Fourth", fourth.name
+    assert_equal "class Fourth : Codable, Hashable", fourth.declaration
+  end
+
+  def test_properties
+    input = <<~EOF
+      public class FirstClass {
+        public var name: Swift.String?
+        public let number: Swift.Int
+        public var data: Foundation.Data {
+          get
+        }
+        public var detailed: [Swift.String] {
+          get
+          set
+        }
+      }
+    EOF
+    api = parser.parse(input)
+    properties = api.classes.first.properties
+    assert_equal 4, properties.size
+    
+    name = properties[0]
+    assert_equal "name", name.name
+    assert_equal "String?", name.type
+    assert name.is_writable?
+
+    number = properties[1]
+    assert_equal "number", number.name
+    assert_equal "Int", number.type
+    assert !number.is_writable?
+
+    data = properties[2]
+    assert_equal "data", data.name
+    assert_equal "Data", data.type
+    assert !data.is_writable?
+
+    detailed = properties[3]
+    assert_equal "detailed", detailed.name
+    assert_equal "[String]", detailed.type
+    assert detailed.is_writable?
+  end
+
+  def test_functions
+    input = <<~EOF
+      public class FirstClass {
+        public func reset() -> PromiseKit.Promise<Swift.Void>
+        public func hash(into hasher: inout Swift.Hasher)
+        @available(iOS 13, *)
+        public func encode(to encoder: Swift.Encoder) throws
+        public init(identifier: Swift.String? = nil, name: Swift.String? = nil)
+        public static func == (lhs: Package.FirstClass, rhs: Package.FirstClass) -> Swift.Bool
+        public func collect(from source: Package.Source, progress progressHandler: ((Swift.Double) -> Swift.Void)?, completion completionHandler: @escaping (Swift.Error?) -> Swift.Void) -> Swift.Int
+      }
+    EOF
+
+    api = parser.parse(input)
+    functions = api.classes.first.functions
+    assert_equal 6, functions.size
+
+    reset = functions[0]
+    assert_equal "reset", reset.name
+    assert_equal "func reset() -> Promise<Void>", reset.full_signature
+
+    hash = functions[1]
+    assert_equal "hash", hash.name
+    assert_equal "func hash(into: inout Hasher)", hash.full_signature
+
+    encode = functions[2]
+    assert_equal "encode", encode.name
+    assert_equal "func encode(to: Encoder) throws", encode.full_signature
+
+    init = functions[3]
+    assert_equal "init", init.name
+    assert_equal "init(identifier: String? = nil, name: String? = nil)", init.full_signature
+
+    equals = functions[4]
+    assert_equal "==", equals.name
+    assert_equal "static func == (lhs: FirstClass, rhs: FirstClass) -> Bool", equals.full_signature
+
+    collect = functions[5]
+    assert_equal "collect", collect.name
+    assert_equal "func collect(from: Source, progress: ((Double) -> Void)?, completion: @escaping (Error?) -> Void) -> Int", collect.full_signature
+  end
+
+  def test_class_extensions
+    input = <<~EOF
+      public class ExtFunction {
+      }
+      extension ExtFunction {
+        public static func == (lhs: ExtFunction, rhs: ExtFunction) -> Swift.Bool
+        @available(iOS 13, *)
+        public func hash(into hasher: inout Swift.Hasher)
+      }
+      public class ExtProperty {
+      }
+      extension ExtProperty {
+        public var number: Swift.Int {
+          get
+        }
+      }
+      public class ExtParent {
+      }
+      extension ExtParent : Swift.Hashable {
+      }
+    EOF
+
+    api = parser.parse(input)
+    classes = api.classes
+    assert_equal 3, classes.size
+
+    ext_function = classes[0]
+    assert_equal 2, ext_function.functions.size
+    assert_equal "==", ext_function.functions[0].name
+    assert_equal "hash", ext_function.functions[1].name
+
+    ext_property = classes[1]
+    assert_equal 1, ext_property.properties.size
+    assert_equal "number", ext_property.properties[0].name
+    assert !ext_property.properties[0].is_writable?
+
+    ext_parent = classes[2]
+    assert_equal 1, ext_parent.parents.size
+    assert_equal "Hashable", ext_parent.parents[0]
+  end
+
+  def test_interfaces
+    input = <<~EOF
+      public protocol WithFunctions {
+        func action(name: Swift.String)
+        @available(iOS 13, *)
+        func query(_ query: Query) -> PromiseKit.Promise<[Document]>
+      }
+      public protocol WithProperties {
+        static var prop: [Self] { get }
+      }
+    EOF
+
+    api = parser.parse(input)
+    interfaces = api.interfaces
+    assert_equal 2, interfaces.size
+
+    with_functions = interfaces[0]
+    assert_equal 2, with_functions.functions.size
+    assert_equal "action", with_functions.functions[0].name
+    assert_equal "query", with_functions.functions[1].name
+
+    with_properties = interfaces[1]
+    assert_equal 1, with_properties.properties.size
+    prop = with_properties.properties[0]
+    assert_equal "prop", prop.name
+    assert_equal "[Self]", prop.type
+    assert prop.is_static?
+    assert !prop.is_writable?
+  end
+
+  def test_interface_extensions
+    input = <<~EOF
+      public protocol WithFunctions {
+      }
+      extension WithFunctions : Swift.Hashable {
+        public static func == (lhs: WithFunctions, rhs: WithFunctions) -> Swift.Bool
+        public func hash(into hasher: inout Swift.Hasher)
+      }
+      public protocol WithProperties {
+      }
+      extension WithProperties {
+        public var hashValue: Swift.Int {
+          get
+        }
+      }
+      public protocol Delegate : AnyObject {
+        func deactivate()
+      }
+      extension Delegate {
+        public func deactivate()
+      }
+    EOF
+
+    api = parser.parse(input)
+    interfaces = api.interfaces
+    assert_equal 3, interfaces.size
+
+    with_functions = interfaces[0]
+    assert_equal ["Hashable"], with_functions.parents
+    assert_equal 2, with_functions.functions.size
+    assert_equal "==", with_functions.functions[0].name
+    assert_equal "hash", with_functions.functions[1].name
+
+    with_properties = interfaces[1]
+    assert_equal 1, with_properties.properties.size
+    assert_equal "hashValue", with_properties.properties[0].name
+
+    delegate = interfaces[2]
+    assert_equal 1, delegate.functions.size
+    assert_equal "deactivate", delegate.functions[0].name
+  end
+
+  def test_enums
+    input = <<~EOF
+      public enum Alpha {
+        case a
+      }
+      @frozen public enum Beta {
+        case c
+        case d
+      }
+      @frozen public enum Gamma : Swift.String, Swift.CaseIterable {
+        case e
+        case f
+        case g
+      }
+    EOF
+
+    api = parser.parse(input)
+    enums = api.enums
+    assert_equal 3, enums.size
+
+    alpha = enums[0]
+    assert_equal "Alpha", alpha.name
+    assert_equal ["a"], alpha.cases
+
+    beta = enums[1]
+    assert_equal "Beta", beta.name
+    assert_equal ["c", "d"], beta.cases
+
+    gamma = enums[2]
+    assert_equal "Gamma", gamma.name
+    assert_equal 3, gamma.cases.size
+    assert_equal ["e", "f", "g"], gamma.cases
+    assert_equal ["String", "CaseIterable"], gamma.parents
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "api_diff"
+
+require "minitest/autorun"
+require "byebug"

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: api_diff
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Sebastian Ludwig
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+description:
+email:
+- sebastian@lurado.de
+executables:
+- api_diff
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- exe/api_diff
+- lib/api_diff.rb
+- lib/api_diff/api.rb
+- lib/api_diff/class.rb
+- lib/api_diff/cli.rb
+- lib/api_diff/enum.rb
+- lib/api_diff/function.rb
+- lib/api_diff/interface.rb
+- lib/api_diff/kotlin_bcv_parser.rb
+- lib/api_diff/parser.rb
+- lib/api_diff/property.rb
+- lib/api_diff/swift_interface_parser.rb
+- lib/api_diff/type.rb
+- lib/api_diff/version.rb
+- test/kotlin_bcv_parser_test.rb
+- test/swift_interface_parser_test.rb
+- test/test_helper.rb
+homepage: https://github.com/sebastianludwig/api-diff
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sebastianludwig/api-diff
+  source_code_uri: https://github.com/sebastianludwig/api_diff
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Bring APIs into an easily diff-able format
+test_files:
+- test/swift_interface_parser_test.rb
+- test/test_helper.rb
+- test/kotlin_bcv_parser_test.rb