swift-tools 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c28f4aeceef967541bfc5e16a19d2bcde80b73bf
+  data.tar.gz: f33bd65d76081c16bb726a49d48e1392a6a32229
+SHA512:
+  metadata.gz: 155ed59fd5357ec9c6fe1354c0e9f238a5026066666b5208d97115a4315446b2f70493a760f2816aa35558c5e6fe02a93f7b116c4d0492fb6ff5a7b6f7d1efa0
+  data.tar.gz: 359367669c2c4bbd84373f6fd10e74f82b682ca4f6797d6d77cca12caa799ac01f76b9e1576edc40119b166df2c4cafefd5486260a55eb096fd8c7bd942b31fd

data/bin/csharp2swift

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require 'methadone'
+require 'swift_tools'
+
+module SwiftTools
+  class Tool
+    include Methadone::Main
+    include Methadone::CLILogging
+    include Methadone::ExitNow
+
+    main do |cs_filename|
+      unless File.exist?(cs_filename)
+        exit_now! 127, "File #{cs_filename} does not exist"
+      end
+
+      cs_file = File.new(cs_filename, "r")
+      swift_filename = options[:swift_filename]
+
+      if swift_filename.nil?
+        swift_file = STDOUT
+      else
+        swift_file = File.new(swift_filename, 'w+')
+      end
+
+      tool = Csharp2Swift.new
+      tool.execute(cs_file, swift_file, options)
+
+      info "\"#{cs_filename}\" -> \"#{swift_filename}\""
+
+      tool.renamed_vars.each {|k,v| puts k + ' -> ' + v}
+      tool.renamed_methods.each {|k,v| puts k + '() -> ' + v + '()'}
+    end
+
+    version SwiftTools::VERSION
+    description %Q(This tool does a rough conversion of C# source code to Swift.  The goal of the tool
+is to do most of the easy stuff that simply requires a lot of typing effort, and allow you
+to concentrate on the more difficult aspects of the conversion, such as library and
+framework usage.
+)
+    arg :cs_filename, :required
+    on("-o", "--output-file SWIFT_FILENAME", "The Swift output file.")
+
+    go!
+  end
+end

data/bin/objc2swift

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler'
+require 'methadone'
+require 'objc_2_swift'
+require 'swift_tools'
+
+module SwiftTools
+  class Tool
+    include Methadone::Main
+    include Methadone::CLILogging
+
+    main do |h_filename, m_filename|
+      unless File.extname(h_filename) == '.h'
+        exit_now! 127, "Header file must end in .h"
+      end
+
+      unless File.exist?(h_filename)
+        exit_now! 127, "File '#{h_filename}' does not exist"
+      end
+
+      unless m_filename.nil?
+        unless File.extname(m_filename) == '.m'
+          exit_now! 127, "Implementation file must end in .m"
+        end
+
+        unless File.exists?(m_filename)
+          exit_now! 127, "File '#{m_filename}' does not exist"
+        end
+      end
+
+      h_file = File.new(h_filename, "r")
+      m_file = m_filename.nil? ? nil : File.new(m_filename, "r")
+      swift_filename = options[:o]
+
+      if swift_filename.nil?
+        swift_file = STDOUT
+        swift_filename = "STDOUT"
+      else
+        swift_file = File.new(swift_filename, 'w+')
+      end
+
+      tool = ObjC2Swift.new
+      tool.execute(h_file, m_file, swift_file, options)
+
+      info "\"#{h_filename}\"" + (m_filename.nil? ? '' : " + \"#{m_filename}\"") + " -> \"#{swift_filename}\""
+   end
+
+    version SwiftTools::VERSION
+    description %Q(This tool does a rough conversion of Objective-C source code to Swift.  The goal of the tool
+is to do most of the stuff that simply requires a lot of typing effort, and allow you
+to concentrate on the more difficult aspects of the conversion, such as library and
+framework usage, use of let vs. var, etc.
+)
+    arg :h_file, :required
+    arg :m_file
+    on("-o", "--output-file SWIFT_FILENAME", "The Swift output file.")
+
+    go!
+  end
+end

data/lib/core_ext.rb

@@ -0,0 +1,40 @@
+class String
+  def camelcase(*separators)
+    case separators.first
+      when Symbol, TrueClass, FalseClass, NilClass
+        first_letter = separators.shift
+    end
+
+    separators = ['_'] if separators.empty?
+
+    str = self.dup
+
+    separators.each do |s|
+      str = str.gsub(/(?:#{s}+)([a-z])/){ $1.upcase }
+    end
+
+    case first_letter
+      when :upper, true
+        str = str.gsub(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+      when :lower, false
+        str = str.gsub(/(\A|\s)([A-Z])/){ $1 + $2.downcase }
+    end
+
+    str
+  end
+
+  def upper_camelcase(*separators)
+    camelcase(:upper, *separators)
+  end
+
+  def lower_camelcase(*separators)
+    camelcase(:lower, *separators)
+  end
+
+end
+
+class Range
+  def self.make(a, exclude_end)
+    return Range.new(a[0], a[1], exclude_end)
+  end
+end

data/lib/csharp_2_swift.rb

@@ -0,0 +1,276 @@
+require_relative './core_ext.rb'
+
+module SwiftTools
+  class Csharp2Swift
+
+    attr_reader :renamed_vars
+    attr_reader :renamed_methods
+
+    def initialize
+      @renamed_methods = {}
+      @renamed_vars = {}
+    end
+
+    def execute(cs_file, swift_file, options)
+      content = cs_file.read()
+
+      # Things that clean up the code and make other regex's easier
+      remove_eol_semicolons(content)
+      join_open_brace_to_last_line(content)
+      remove_region(content)
+      remove_endregion(content)
+      remove_namespace_using(content)
+      convert_this_to_self(content)
+      convert_int_type(content)
+      convert_string_type(content)
+      convert_bool_type(content)
+      convert_float_type(content)
+      convert_double_type(content)
+      convert_list_list_type(content)
+      convert_list_array_type(content)
+      convert_list_type(content)
+      convert_debug_assert(content)
+      remove_new(content)
+      insert_import(content)
+
+      # Slightly more complicated stuff
+      remove_namespace(content)
+      convert_property(content)
+      remove_get_set(content)
+      convert_const_field(content)
+      convert_field(content)
+      constructors_to_inits(content)
+      convert_method_decl_to_func_decl(content)
+      convert_locals(content)
+      convert_if(content)
+      convert_next_line_else(content)
+      convert_simple_range_for_loop(content)
+
+      # Global search/replace
+      @renamed_vars.each { |v, nv|
+        content.gsub!(Regexp.new("\\." + v + "\\b"), '.' + nv)
+      }
+      @renamed_methods.each { |m, nm|
+        content.gsub!(Regexp.new('\\b' + m + '\\('), nm + '(')
+      }
+
+      swift_file.write(content)
+    end
+
+    def remove_eol_semicolons(content)
+      content.gsub!(/; *$/m, '')
+    end
+
+    def join_open_brace_to_last_line(content)
+      re = / *\{$/m
+      m = re.match(content)
+      s = ' {'
+
+      while m != nil do
+        offset = m.offset(0)
+        start = offset[0]
+        content.slice!(offset[0]..offset[1])
+        content.insert(start - 1, s)
+        m = re.match(content, start - 1 + s.length)
+      end
+    end
+
+    def convert_this_to_self(content)
+      content.gsub!(/this\./, 'self.')
+    end
+
+    def remove_region(content)
+      content.gsub!(/ *#region.*\n/, '')
+    end
+
+    def remove_endregion(content)
+      content.gsub!(/ *#endregion.*\n/, '')
+    end
+
+    def remove_namespace_using(content)
+      content.gsub!(/ *using (?!\().*\n/, '')
+    end
+
+    def convert_int_type(content)
+      content.gsub!(/\bint\b/, 'Int')
+    end
+
+    def convert_string_type(content)
+      content.gsub!(/\bstring\b/, 'Int')
+    end
+
+    def convert_bool_type(content)
+      content.gsub!(/\bbool\b/, 'Bool')
+    end
+
+    def convert_float_type(content)
+      content.gsub!(/\bfloat\b/, 'Float')
+    end
+
+    def convert_double_type(content)
+      content.gsub!(/\bdouble\b/, 'Double')
+    end
+
+    def convert_list_type(content)
+      content.gsub!(/(?:List|IList)<(\w+)>/, '[\\1]')
+    end
+
+    def convert_list_list_type(content)
+      content.gsub!(/(?:List|IList)<(?:List|IList)<(\w+)>>/, '[[\\1]]')
+    end
+
+    def convert_list_array_type(content)
+      content.gsub!(/(?:List|IList)<(\w+)>\[\]/, '[[\\1]]')
+    end
+
+    def convert_debug_assert(content)
+      content.gsub!(/Debug\.Assert\(/, 'assert(')
+    end
+
+    def remove_new(content)
+      content.gsub!(/new /, '')
+    end
+
+    def insert_import(content)
+      content.insert(0, "import Foundation\n")
+    end
+
+    def remove_namespace(content)
+      re = / *namespace +.+ *\{$/
+      m = re.match(content)
+
+      if m == nil
+        return
+      end
+
+      i = m.end(0)
+      n = 1
+      bol = (content[i] == "\n")
+      while i < content.length do
+        c = content[i]
+
+        if bol and c == " " and i + 3 < content.length
+          content.slice!(i..(i + 3))
+          c = content[i]
+        end
+
+        case c
+          when "{"
+            n += 1
+          when "}"
+            n -= 1
+            if n == 0
+              content.slice!(i) # Take out the end curly
+              content.slice!(m.begin(0)..m.end(0)) # Take out the original namespace
+              break
+            end
+          when "\n"
+            bol = true
+          else
+            bol = false
+        end
+        i += 1
+      end
+    end
+
+    def convert_const_field(content)
+      content.gsub!(/(^ *)(?:public|private|internal) +const +(.+?) +(.+?)( *= *.*?|)$/) { |m|
+        v = $3
+        nv = v.lower_camelcase
+        @renamed_vars[v] = nv
+        $1 + 'let ' + nv + ': ' + $2 + $4
+      }
+    end
+
+    def convert_field(content)
+      content.gsub!(/(^ *)(?:public|private|internal) +(\w+) +(\w+)( *= *.*?|)$/) { |m|
+        $1 + 'private var ' + $3 + ': ' + $2 + $4
+      }
+    end
+
+    def convert_property(content)
+      content.gsub!(/(^ *)(?:public|private|internal) +(?!class)([A-Za-z0-9_\[\]<>]+) +(\w+)(?: *\{)/) { |m|
+        v = $3
+        nv = v.lower_camelcase
+        @renamed_vars[v] = nv
+        $1 + 'var ' + nv + ': ' + $2 + ' {'
+      }
+    end
+
+    def remove_get_set(content)
+      content.gsub!(/{ *get; *set; *}$/, '')
+    end
+
+    def constructors_to_inits(content)
+      re = /(?:(?:public|internal|private) +|)class +(\w+)/
+      m = re.match(content)
+      while m != nil do
+        content.gsub!(Regexp.new('(?:(?:public|internal) +|)' + m.captures[0] + " *\\("), 'init(')
+        m = re.match(content, m.end(0))
+      end
+
+      content.gsub!(/init\((.*)\)/) { |m|
+        'init(' + swap_args($1) + ')'
+      }
+    end
+
+    def convert_method_decl_to_func_decl(content)
+      # TODO: Override should be captured and re-inserted
+      content.gsub!(/(?:(?:public|internal|private) +)(?:override +|)(.+) +(.*)\((.*)\) *\{/) { |m|
+        f = $2
+        nf = f.lower_camelcase
+        @renamed_methods[f] = nf
+        if $1 == "void"
+          'func ' + nf + '(' + swap_args($3) + ') {'
+        else
+          'func ' + nf + '(' + swap_args($3) + ') -> ' + $1 + ' {'
+        end
+      }
+    end
+
+    def convert_locals(content)
+      content.gsub!(/^( *)(?!return|import)([A-Za-z0-9_\[\]<>]+) +(\w+)(?:( *= *.+)|)$/, '\\1let \\3\\4')
+    end
+
+    def convert_if(content)
+      content.gsub!(/if *\((.*)\) +\{/, 'if \\1 {')
+      content.gsub!(/if *\((.*?)\)\n( +)(.*?)\n/m) { |m|
+        s = $2.length > 4 ? $2[0...-4] : s
+        'if ' + $1 + " {\n" + $2 + $3 + "\n" + s + "}\n"
+      }
+    end
+
+    def convert_next_line_else(content)
+      content.gsub!(/\}\n +else \{/m, '} else {')
+    end
+
+    def convert_simple_range_for_loop(content)
+      content.gsub!(/for \(.+ +(\w+) = (.+); \1 < (.*); \1\+\+\)/, 'for \\1 in \\2..<\\3')
+      content.gsub!(/for \(.+ +(\w+) = (.+); \1 >= (.*); \1\-\-\)/, 'for \\1 in (\\3...\\2).reverse()')
+    end
+
+    def swap_args(arg_string)
+      args = arg_string.split(/, */)
+      args.collect! { |arg|
+        a = arg.split(' ')
+        a[1] + ': ' + a[0]
+      }
+      args.join(', ')
+    end
+
+    def read_file(filename)
+      content = nil
+      File.open(filename, 'rb') { |f| content = f.read() }
+      content
+    end
+
+    def write_file(filename, content)
+      File.open(filename, 'w') { |f| f.write(content) }
+    end
+
+    def error(msg)
+      STDERR.puts "error: #{msg}".red
+    end
+
+  end
+end

data/lib/objc_2_swift.rb

@@ -0,0 +1,519 @@
+module SwiftTools
+  class ObjC2Swift
+
+    INDENT = '    '
+
+    def initialize
+    end
+
+    def execute(h_file, m_file, swift_file, options)
+      hdr_content = h_file.read()
+      h_filename = File.basename(h_file.to_path)
+
+      imports = capture_imports(h_filename, hdr_content)
+      statics = capture_statics(hdr_content)
+      interfaces = capture_interfaces(hdr_content, in_hdr = true)
+      copyright = capture_copyright(hdr_content)
+
+      unless m_file.nil?
+        impl_content = m_file.read()
+        implementations = capture_implementation(impl_content)
+        impl_imports = capture_imports(h_filename, impl_content)
+        impl_interfaces = capture_interfaces(impl_content, in_hdr = false)
+      end
+
+      # Add copyright
+      unless copyright.nil?
+        swift_file.write("//\n#{copyright}\n//\n\n")
+      end
+
+      # Combine all the imports
+      swift_file.write(imports[:at_imports])
+      swift_file.write(impl_imports[:at_imports]) unless impl_imports.nil?
+      swift_file.write(imports[:hash_imports])
+      swift_file.write(impl_imports[:hash_imports]) unless impl_imports.nil?
+      swift_file.write("\n")
+
+      # Write statics
+      swift_file.write(statics)
+      swift_file.write("\n")
+
+      # Combine interfaces
+      unless impl_interfaces.nil?
+        impl_interfaces.each { |name, data|
+          hdr_has_interface = interfaces.include?(name)
+          interfaces[name][:properties].merge!(data[:properties]) if hdr_has_interface
+          interfaces[name][:methods].merge!(data[:methods]) { |key, v1, v2|
+            {
+                :scope => v2[:scope],
+                :return_type => v2[:return_type],
+                :visibility => v1[:visibility]
+            }
+          } if hdr_has_interface
+        }
+      end
+
+      # Combine implementations
+      unless implementations.nil?
+        implementations.each { |name, data|
+          have_interface = interfaces.include?(name)
+          interfaces[name][:methods].merge!(data[:methods]) { |key, v1, v2|
+            {
+                :scope => v1[:scope] || v2[:scope],
+                :return_type => v1[:return_type],
+                :visibility => v1[:visibility],
+                :body => v2[:body]
+            }
+          } if have_interface
+        }
+      end
+
+      # Output classes or extensions from interfaces
+      interfaces.each {|interface_name, interface_data|
+        swift_file.write("@objc class #{interface_name}")
+        if interface_data[:base] != nil
+          swift_file.write(": #{interface_data[:base]}")
+        end
+        if interface_data[:protocols] != nil
+          swift_file.write(", #{interface_data[:protocols]}")
+        end
+        swift_file.write("{\n")
+
+        # Create Swift singletons
+        if interface_data[:methods].include?('sharedInstance')
+          interface_data[:methods].delete('sharedInstance')
+          interface_data[:properties]['sharedInstance'] = {
+              :const => true,
+              :visibility => :public,
+              :scope => :static,
+              :initializer => "#{interface_name}()"
+          }
+          interface_data[:inits].push({
+              body: '',
+              :visibility => :private
+          })
+        end
+
+        # Add getter props
+        new_properties = {}
+        interface_data[:properties].each {|prop_name, prop_data|
+          if prop_data[:getter]
+            new_properties[prop_data[:getter]] = {
+                :visibility => :public,
+                :type => 'Bool',
+                :scope => prop_data[:scope],
+                :body => "return #{prop_name}"
+            }
+
+            # Remove :readonly if set and make private
+            prop_data.delete(:readonly)
+            prop_data[:visibility] = :private
+          end
+        }
+        interface_data[:properties].merge!(new_properties)
+
+        # line2 = INDENT + "public var #{prop_data[:getter]}: #{prop_data[:type]} { return #{prop_name} }\n"
+        # if prop_data[:getter]
+        #   line1 = INDENT + "private "
+
+        # Write properties
+        interface_data[:properties].each {|prop_name, prop_data|
+          line = INDENT
+          if prop_data[:readonly]
+            line += "private(set) public "
+          elsif prop_data[:visibility] == :private
+            line += 'private '
+          end
+
+          if prop_data[:scope] == :static
+            line += "static "
+          end
+
+          if prop_data[:weak]
+            line += 'weak '
+          end
+
+          if prop_data[:const]
+            line += 'let '
+          else
+            line += 'var '
+          end
+
+          line += "#{prop_name}"
+
+          if prop_data[:type]
+            line += ": #{prop_data[:type]}"
+          end
+
+          if prop_data[:initializer]
+            line += " = #{prop_data[:initializer]}"
+          end
+
+          if prop_data[:body]
+            line += " {\n" + INDENT + INDENT + prop_data[:body] + "\n" + INDENT + "}"
+          end
+
+          line += "\n"
+
+          swift_file.write(line)
+        }
+
+        # Write inits
+        interface_data[:inits].each {|init_data|
+          line = "\n" + INDENT
+
+          if init_data[:visibility] == :private
+            line += 'private '
+          end
+
+          line += "init() {"
+
+          if init_data[:body].length > 0
+            line += "\n" + body + "\n"
+          end
+
+          line += "}\n"
+          swift_file.write(line)
+        }
+
+        # Write methods
+        interface_data[:methods].each {|method_name, method_data|
+          line = "\n" + INDENT
+
+          if method_data[:visibility] == :private
+            line += 'private '
+          end
+
+          line += "func #{method_name}()"
+          if method_data[:return_type] and method_data[:return_type] != 'Void'
+            line += " -> #{method_data[:return_type]}"
+          end
+
+          line += ' {'
+
+          if method_data[:body].strip.length == 0
+            line += "}\n"
+          else
+            body = method_data[:body]
+            convert_var_decls(body)
+            remove_eol_semicolons(body)
+            convert_to_dot_syntax(body)
+            convert_underscore_props(body, interface_data[:properties])
+            convert_block_to_closure(body)
+            fix_if_statements(body)
+            fix_switch_statements(body)
+            fix_yes_no(body)
+            fix_null(body)
+            fix_at_string(body)
+            fix_broken_else(body)
+            line += body + INDENT + "}\n"
+          end
+
+          swift_file.write(line)
+        }
+
+        swift_file.write("}\n")
+      }
+    end
+
+    def capture_copyright(content)
+      copyright = nil
+      content.match(/^\s*\/\/.*Copyright.*$/) {|m|
+        copyright = m[0]
+      }
+      copyright
+    end
+
+    def capture_imports(h_filename, content)
+      r1 = ''
+      r2 = ''
+      content.scan(/[@#]import\s*"?[\.a-zA-Z0-9_]+"?\s*;?\s*\n?/m).each {|m|
+        s = m.strip
+        if s.start_with?("#")
+          if s.index(h_filename).nil?
+            r2 += "// TODO: Add '#{s}' to bridging header\n"
+          end
+        else
+          r1 += remove_eol_semicolons(s) + "\n"
+        end
+      }
+      {:at_imports => r1, :hash_imports => r2}
+    end
+
+    def capture_interfaces(content, in_hdr)
+      interfaces = {}
+      content.scan(/^\s*@interface\s*([a-zA-Z0-9_]+)(?:\s*:\s*([a-zA-Z0-9_]+)\s*)?(?:\s*\(([a-zA-Z0-9_, ]*)\))?(?:\s*<(.+)>)?((?:.|\n)*?)@end *\n$/m).each {|m|
+        body = m[4]
+        properties = extract_properties(body, in_hdr)
+        methods = extract_methods(body, in_hdr)
+
+        interfaces[m[0]] = {
+          :base => m[1],
+          :categories => m[2] == '' ? nil : m[2],
+          :protocols => m[3],
+          :properties => properties,
+          :methods => methods,
+          :inits => []
+        }
+      }
+      interfaces
+    end
+
+    def extract_properties(content, in_hdr)
+      properties = {}
+      content.scan(/^\s*@property\s*\(([a-zA-Z0-9_=, ]*)\)\s*([a-zA-Z0-9_\*]+)\s*([a-zA-Z0-9_\*]+)\s*/m) {|m|
+        name = $3
+        type = map_type(remove_ptr($2))
+        options = Hash[$1.split(',').map(&:strip).collect {|s|
+          a = s.split('=')
+          if a.length > 1
+            [a[0].to_sym, a[1]]
+          else
+            [a[0].to_sym, true]
+          end
+        }]
+        properties[remove_ptr(name)] = {
+            :type => type,
+            :visibility => in_hdr ? :public : :private,
+            :scope => :instance
+        }.merge(options)
+      }
+      properties
+    end
+
+    def extract_methods(content, in_hdr)
+      methods = {}
+      content.to_enum(:scan, /^ *(\+|-)? *\(([a-zA-Z0-9_]+)\) *([a-zA-Z0-9_]+)(?:[ \n]*\{)?/m).map { Regexp.last_match }.each {|m|
+        if in_hdr
+          body = ''
+        else
+          body_start_offset = m.offset(0)[1]
+          body_end_offset = find_close_char_offset(content, body_start_offset, '{', '}') - 1
+          body = indent_lines(content[body_start_offset..body_end_offset])
+        end
+        methods[m[3]] = {
+          :scope => (m[1] == '+' ? :static : :instance),
+          :return_type => map_type(remove_ptr(m[2])),
+          :visibility => in_hdr ? :public : :private,
+          :body => body
+        }
+      }
+      methods
+    end
+
+    def capture_implementation(content)
+      implementations = {}
+      content.scan(/^\s*@implementation *([a-zA-Z0-9_]+)((?:.|\n)*?)@end *\n$/m).each {|m|
+        body = m[1]
+        methods = extract_methods(body, in_hdr = false)
+
+        implementations[m[0]] = {
+            :methods => methods,
+            :inits => []
+        }
+      }
+      implementations
+    end
+
+    def capture_statics(content)
+      statics = ''
+      content.scan(/static *(.*?);/m) {|m|
+        decl = m[0]
+        decl.gsub!('const', '')
+        decl.gsub!('*', '')
+        decl.gsub!('@"', '"')
+        decl.scan(/([a-zA-Z0-9_\*]+) +([a-zA-Z0-9_\*]+)(?: *= *(.*))?/m) {|mm|
+          statics += "@objc let #{mm[1]}: #{map_type(mm[0])}"
+          if mm[2]
+            statics += " = #{mm[2]}"
+          end
+          statics += "\n"
+        }
+      }
+      statics
+    end
+
+    def convert_to_dot_syntax(content)
+      # Repeatedly find a [] syntax method call that does not have a nested [] call
+      # and convert it until done.
+      while m = content.match(/\[([^\[\]]+?)\]/) do
+        # Parse m[0], convert to . syntax and substitute into 'content'
+        body = m[1].strip
+        params = []
+
+        # Get the object name
+        obj_match = body.match(/^([a-zA-Z0-9_\.\(\)]+)/)
+        obj_name = obj_match[1]
+
+        # Search for label with empty parameter list
+        label_match = body.match(/(?:\n| )([a-zA-Z0-9_]+)/, obj_match.offset(0)[1])
+
+        if label_match and label_match.offset(0)[1] >= body.length
+          # There are no parameters
+          params.push({:name => label_match[1], :value => nil})
+        else
+          # There are labelled parameters, start parsing them by searching for the labels
+          param_label_re = /(?:\n| )+([a-zA-Z0-9_]+) *:/
+          label_match = body.match(param_label_re, obj_match.offset(0)[1])
+
+          begin
+            arg = { :name => label_match[1]}
+
+            if block_match = body.match(/ *(?:\(.*?\))?(?: |\n)\{/, label_match.offset(0)[1])
+              end_of_param = find_close_char_offset(body, block_match.offset(0)[1], '{', '}')
+            else
+              # Find the next arg label or the end of the string
+              next_label_match = body.match(param_label_re, label_match.offset(0)[1])
+              if next_label_match.nil?
+                end_of_param = body.length
+              else
+                end_of_param = next_label_match.offset(0)[0]
+              end
+            end
+            arg[:value] = body[label_match.offset(0)[1]...end_of_param]
+            params.push(arg)
+            label_match = next_label_match
+          end until label_match.nil?
+        end
+
+        new_call = "#{obj_name}."
+        params.each_index {|i|
+          if i == 0
+            new_call += params[i][:name] + '(' + (params[i][:value] || '')
+          else
+            new_call += ", #{params[i][:name]}: #{params[i][:value]}"
+          end
+        }
+        new_call += ')'
+
+        # Replace the orginal method call
+        content[Range.make(m.offset(0), true)] = new_call
+      end
+    end
+
+    def convert_var_decls(content)
+      # Note, this must be done _before_ removing EOL semicolons
+      content.gsub!(/^( *)([a-zA-Z0-9_\*]+) +([a-zA-Z0-9_\*]+)(?: *= *(.*?))? *;/m) {|m|
+        decl = "#{$1}var #{$3}: #{map_type(remove_ptr($2))}"
+        if $4
+          decl += " = #{$4}"
+        end
+        decl
+      }
+    end
+
+    def convert_underscore_props(content, properties)
+      properties.each {|prop_name, prop_data|
+          content.gsub!(Regexp.new('\b_' + prop_name + '\b'), "self.#{prop_name}")
+      }
+    end
+
+    def convert_block_to_closure(content)
+      content.gsub!(/\^(?:\(([a-zA-Z0-9_,\* ]+)\))?(?: |\n)*\{/m) {|m|
+        if $1
+          '{ ' + convert_param_list($1) + ' in '
+        else
+          '{\n'
+        end
+      }
+    end
+
+    def convert_param_list(content)
+      params = ''
+      content.split(/ *, */).each {|param|
+        pair = param.split(' ')
+        if params.length > 0
+          params += ', '
+        end
+        params += "#{remove_ptr(pair[1])}: #{map_type(remove_ptr(pair[0]))}"
+      }
+      '(' + params + ')'
+    end
+
+    def fix_if_statements(content)
+      content.gsub!(/if *\((.+?)\)(?: |\n)*{/m) {|m|
+        "if #{$1} {"
+      }
+    end
+
+    def fix_switch_statements(content)
+      content.gsub!(/switch *\((.+?)\)(?: |\n)*{/m) {|m|
+        "switch #{$1} {"
+      }
+      content.gsub!(/^ *break *\n/m) {|m|
+        ''
+      }
+    end
+
+    def fix_yes_no(content)
+      content.gsub!(/\b(YES|NO)\b/) {|m|
+        m == 'YES' ? 'true' : 'false'
+      }
+    end
+
+    def fix_null(content)
+      content.gsub!(/\bNULL\b/, 'nil')
+    end
+
+    def fix_broken_else(content)
+      content.gsub!(/\}(?: |\n)*else(?: |\n)*\{/, '} else {')
+    end
+
+    def fix_at_string(content)
+      content.gsub!(/@"/, '"')
+    end
+
+    def remove_eol_semicolons(content)
+      content.gsub!(/; *$/m, '')
+    end
+
+    def find_close_char_offset(content, offset, open_char, close_char)
+      count = 1
+      loop do
+        if offset >= content.length
+          raise "Ran out of content looking for #{close_char}"
+        elsif content[offset] == close_char
+          count -= 1
+          if count == 0
+            break
+          end
+        elsif content[offset] == open_char
+          count += 1
+        end
+        offset += 1
+      end
+      offset
+    end
+
+    def indent_lines(content)
+      s = ''
+      content.each_line {|line|
+        s += INDENT + line
+      }
+      s
+    end
+
+    def remove_ptr(content)
+      content.gsub('*', '')
+    end
+
+    def map_type(content)
+      case content
+      when 'BOOL'
+        'Bool'
+      when 'int'
+        'Int'
+      when 'uint'
+        'UInt'
+      when 'long'
+        'Long'
+      when 'void'
+        'Void'
+      when /(.*)\*/
+        $1
+      else
+        content
+      end
+    end
+  end
+end

data/lib/swift_tools.rb

@@ -0,0 +1,6 @@
+require 'csharp_2_swift'
+require 'objc_2_swift'
+
+module SwiftTools
+  VERSION = "3.0.0"
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: swift-tools
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- John Lyon-smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: methadone
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: code-tools
+  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'
+description: ''
+email: john@jamoki.com
+executables:
+- csharp2swift
+- objc2swift
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/csharp2swift
+- bin/objc2swift
+- lib/core_ext.rb
+- lib/csharp_2_swift.rb
+- lib/objc_2_swift.rb
+- lib/swift_tools.rb
+homepage: http://rubygems.org/gems/swift-tools
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Tools for managing Swift source code
+test_files: []