objc2swift_assistant 0.3.0

data/lib/objc2swift_assistant/objc_2_swift_block_conversion.rb

@@ -0,0 +1,106 @@
+require_relative 'version'
+require_relative 'objc_2_swift_type_mapping'
+require_relative 'objc_variable_types'
+
+module Objc2swiftAssistant
+
+  class Objc2SwiftBlockConverter
+    attr_accessor :type_converter
+
+    def initialize( type_converter )
+      @type_converter = type_converter
+    end
+
+    def block_sig_for_method_arg( arg_type_str )
+      sig = Objc2SwiftBlockSignature.new( self )
+      sig.from_argument_type( arg_type_str)
+      sig
+    end
+
+    def block_sig_for_property( arg_type_str )
+      sig = Objc2SwiftBlockSignature.new( self )
+      sig.from_property_type( arg_type_str)
+      sig
+    end
+
+    def block_sig_for_components( return_type_str, *arg_strings )
+      sig = Objc2SwiftBlockSignature.new( self )
+      sig.from_components( return_type_str, arg_strings )
+      sig
+    end
+  end
+
+  class Objc2SwiftBlockSignature
+    attr_accessor :block_converter
+    attr_accessor :return_type
+    attr_accessor :arguments
+
+    def initialize( block_converter )
+      @block_converter = block_converter
+    end
+
+    def from_components( return_type_str, arg_strings )
+      @return_type = @block_converter.type_converter.swift_type_for_objc_type( return_type_str )
+
+      @arguments = arg_strings.map do |arg_str|
+        arg_for_objc_str( arg_str.strip )
+      end
+    end
+
+    def from_argument_type( arg_type )
+      if arg_type.count('^') > 1
+        failure = "Cannot convert nested Block: #{arg_type}"
+        return "String /*#{failure}*/", failure
+      else
+        m = arg_type.match( /(?<return_type>[^\(]*)\s*\(\s*\^\s*\)\s*\((?<arg_string>.*)\)/ )
+        if m.nil?
+          failure = "Cannot match block: #{arg_type}"
+          return "String /*#{failure}*/", failure
+        else
+          objc_return_type = m[ 'return_type' ].strip!
+          @return_type = @block_converter.type_converter.swift_type_for_objc_type( objc_return_type )
+
+          arg_string = m[ 'arg_string' ]
+          arg_strings = arg_string.nil? ? [] : arg_string.split( ',' )
+
+          @arguments = arg_strings.map do |arg_str|
+            arg_for_objc_str( arg_str.strip )
+          end
+        end
+      end
+    end
+
+    def swift_declaration( full=true )
+      swift_args = @arguments.map do |arg|
+        if arg.param_name.nil?
+          str = "#{arg.param_type}"
+        else
+          str = "#{arg.param_name}: #{arg.param_type}"
+        end
+        str
+      end
+
+      sig = "(( #{swift_args.join( ', ' )} )"
+      if full || !return_type.nil?
+        if return_type.nil?
+          sig += " -> ())" if return_type.nil?
+        else
+          sig += " -> #{return_type})"
+        end
+      else
+        sig += " -> #{return_type})" unless return_type.nil?
+      end
+      sig
+    end
+
+    def from_property_type( prop_type )
+
+    end
+
+    def arg_for_objc_str( arg_str )
+      argument = ObjCBlockParameter.new()
+      argument.from_declaration( arg_str )
+      argument
+    end
+  end
+end

data/lib/objc2swift_assistant/objc_2_swift_configuration.rb

@@ -0,0 +1,108 @@
+require_relative "version"
+require_relative "file_hierarchical_config"
+require_relative "objc_2_swift_type_mapping"
+require_relative "objc_2_swift_block_conversion"
+
+module Objc2swiftAssistant
+
+  LOG_LEVEL_NONE        = 0
+  LOG_LEVEL_ERRORS      = 1
+  LOG_LEVEL_WARNINGS    = 2
+  LOG_LEVEL_VERBOSE     = 3
+  LOG_LEVEL_DEBUG       = 4
+
+  LOG_LEVELS_BY_NAME = {
+      "error" => LOG_LEVEL_ERRORS,
+      "warning" => LOG_LEVEL_WARNINGS ,
+      "verbose" => LOG_LEVEL_VERBOSE ,
+      "debug" => LOG_LEVEL_DEBUG,
+      "none" => LOG_LEVEL_NONE
+  }
+
+
+  COMPANY_NAME_KEY                = 'company_name'
+  OMIT_FILE_KEY                   = 'omit_file'
+  EMIT_ORIGINAL_SIGNATURES_KEY    = 'emit_original_signatures'
+  EMIT_ORIGINAL_BODIES_KEY        = 'emit_original_bodies'
+  EMIT_UNCONVERTED_CONTENT_KEY    = 'emit_unconverted_content'
+
+  ALL_CONFIG_KEYS = [
+      COMPANY_NAME_KEY,
+      OMIT_FILE_KEY,
+      EMIT_ORIGINAL_SIGNATURES_KEY,
+      EMIT_ORIGINAL_BODIES_KEY,
+      EMIT_UNCONVERTED_CONTENT_KEY
+  ]
+
+  class ObjC2SwiftConfiguration < FileHierarchicalConfig
+    attr_accessor :type_mapper
+    attr_accessor :block_converter
+    attr_accessor :structure_option
+
+    attr_accessor :log_level
+
+
+    def initialize( config_hash, log_level_name, structure_option )
+      super( config_hash, ALL_CONFIG_KEYS )
+      @node_class = ObjC2SwiftConfigNode
+      @type_mapper = Objc2SwiftTypeMapper.new()
+      @block_converter = Objc2SwiftBlockConverter.new( @type_mapper )
+      @log_level = LOG_LEVELS_BY_NAME[ log_level_name ]
+      @structure_option = structure_option
+    end
+
+    def omit_file( file_path )
+      # val = config_value(file_path, OMIT_FILE_KEY)
+      # puts( "Omit File: #{file_path} #{val ? 'true' : 'false' }" )  # nil will evaluate to false
+      config_value( file_path, OMIT_FILE_KEY )
+
+    end
+
+    def company_name( file_path )
+      config_value( file_path, COMPANY_NAME_KEY )
+    end
+
+    def emit_original_signatures( file_path )
+      config_value_defaulted( file_path, EMIT_ORIGINAL_SIGNATURES_KEY, true )
+    end
+
+    def emit_original_bodies( file_path )
+      config_value_defaulted( file_path, EMIT_ORIGINAL_BODIES_KEY, true )
+    end
+
+    def emit_unconverted_content( file_path )
+      config_value_defaulted( file_path, EMIT_UNCONVERTED_CONTENT_KEY, true )
+    end
+
+    # Logging
+    def log_verbose( str )
+      puts( str ) if @log_level >= LOG_LEVEL_VERBOSE
+    end
+
+    def log_warning( str )
+      puts( "WARNING: " + str ) if @log_level >= LOG_LEVEL_WARNINGS
+    end
+
+    def dump_source
+      [ 'all', 'errors' ].include?( @structure_option )
+    end
+
+    def dump_only_errors
+      @structure_option == 'errors'
+    end
+
+  end
+
+  class ObjC2SwiftConfigNode <  FileHierarchicalConfigNode
+
+    def post_process_config ()
+      ignore_file_paths = @configuration_hash[ "ignore" ] || []
+      ignore_file_hash = { OMIT_FILE_KEY => true }
+      ignore_file_paths.each do | path_str |
+        make_child_node( path_str, ignore_file_hash )
+      end
+    end
+
+  end
+
+end

data/lib/objc2swift_assistant/objc_2_swift_type_mapping.rb

@@ -0,0 +1,64 @@
+require_relative "version"
+
+module Objc2swiftAssistant
+
+  class Objc2SwiftTypeMapper
+
+    attr_accessor :mappings_by_swift_type
+    attr_accessor :mappings_by_objc_type
+
+    def initialize( )
+      @mappings_by_swift_type = {}
+      @mappings_by_objc_type = {}
+
+      #initialize default mappings
+      map_types( :BOOL,          :Bool,         'false' )
+      map_types( :int,           :Int,          '0' )
+      map_types( :NSUInteger,    :UInt,         '0')
+      map_types( :CGFloat,       :Float,        '0.0' )
+      map_types( :id,            :AnyObject?,   '0.0' )
+      map_types( :void,          nil,       nil )
+    end
+
+    def map_types( objc_type_symbol, swift_type_symbol, swift_default_value )
+      mapping = Objc2SwiftTypeMapping.new( objc_type_symbol, swift_type_symbol, swift_default_value)
+      set_mapping( mapping )
+      mapping
+    end
+
+    def set_mapping( mapping )
+      @mappings_by_swift_type[ mapping.swift_type_symbol ] = mapping
+      @mappings_by_objc_type[ mapping.objc_type_symbol ] = mapping
+    end
+
+    def mapping_for_objc_type( objc_type_string )
+      @mappings_by_objc_type[ objc_type_string.to_sym ]
+    end
+
+    def swift_type_for_objc_type( objc_type_str )
+      mapping = mapping_for_objc_type( objc_type_str )
+      mapping.nil? ? objc_type_str : mapping.swift_type_string
+    end
+  end
+
+
+  class Objc2SwiftTypeMapping
+    attr_accessor :objc_type_symbol
+    attr_accessor :swift_type_symbol
+    attr_accessor :swift_default_value
+
+    def initialize( objc_type_symbol, swift_type_symbol, swift_default_value )
+      @objc_type_symbol = objc_type_symbol
+      @swift_type_symbol = swift_type_symbol
+      @swift_default_value = swift_default_value
+    end
+
+    def swift_type_string
+      @swift_type_symbol.nil? ? nil : @swift_type_symbol.to_s
+    end
+
+  end
+
+  @@type_mapping = Objc2SwiftTypeMapper.new()
+
+end

data/lib/objc2swift_assistant/objc_variable_types.rb

@@ -0,0 +1,76 @@
+require_relative "version"
+
+module Objc2swiftAssistant
+
+  class ObjCAbstractParameter
+    attr_accessor :param_type
+    attr_accessor :pointer_level    # 0 -> not a pointer; 1 -> *; 2 -> **, ...
+    attr_accessor :is_block_type
+    attr_accessor :match_failure
+    attr_accessor :is_weak
+
+    def initialize
+      @pointer_level = 0
+      @param_type = nil
+      @is_weak = false
+    end
+
+    def match_failed
+      return ! @match_failure.nil?
+    end
+
+    def process_pointer_str( pointer_str )
+      if pointer_str.nil?
+        @pointer_level = 0
+      else
+        @pointer_level = pointer_str.length
+      end
+    end
+  end
+
+
+
+  class ObjCProperty < ObjCAbstractParameter
+    #TODO: Use this class for properties
+  end
+
+  class ObjCReturnType < ObjCAbstractParameter
+    #TODO: Use this class for return types
+  end
+
+
+  class ObjCMethodParameter < ObjCAbstractParameter
+    attr_accessor :param_name
+    attr_accessor :param_label      # May be empty for 1st param
+    attr_accessor :null_qualifier
+
+    def initialize
+      super()
+    end
+
+    def from_declaration( declaration_str )
+
+    end
+
+  end
+
+  class ObjCBlockParameter < ObjCAbstractParameter
+    attr_accessor :param_name
+    attr_accessor :null_qualifier
+
+    def from_declaration( declaration_str )
+      # TODO: nillabel qulaifiers
+      m = declaration_str.match( /^(?<type>\w*)\s*(?<pointer_values>[\*&]*)?\s*(?<name>\w*)/ )
+      if m.nil?
+        match_failure = "Could not parse block agument: #{declaration_str }"
+      else
+        process_pointer_str( m[ 'pointer_values' ] )
+        @is_block_type = false
+        @param_type = m[ 'type' ]
+        @param_name = m[ 'name' ]
+      end
+    end
+  end
+
+end
+

data/lib/objc2swift_assistant/processing_element.rb

@@ -0,0 +1,32 @@
+require_relative 'version'
+
+# require_relative 'file_sets'
+# require_relative 'recognizers/recognizer_keys'
+# require_relative 'objc_2_swift_type_mapping'
+# require_relative 'objc_2_swift_block_conversion'
+
+module Objc2swiftAssistant
+
+  class FailableProcessingElement
+    attr_accessor :error_messages
+
+    def initiailize
+      @warning_messages = []
+      @error_messages = []
+    end
+
+    def has_errors
+      return error_messages.length > 0
+    end
+
+    def add_error( error_message )
+      @error_messages << error_message
+    end
+
+    def add_warning( warning_message )
+      @warning_messages << warning_message
+    end
+
+  end
+
+end

data/lib/objc2swift_assistant/recognizers/at_sign_directives_recognizer.rb

@@ -0,0 +1,41 @@
+require "objc2swift_assistant/version"
+
+require "objc2swift_assistant/code_recognizer"
+
+module Objc2swiftAssistant
+
+  DIRECTIVE_REGEX = /^\s*@(?<directive>((required)|(optional)|(public)|(private)|(protected)))/
+
+  class AtDirectiveRecognizer < CodeRecognizer
+    def initialize( )
+      super( DIRECTIVE_REGEX, AtDirectiveRegion, :all_source_files, false )
+    end
+  end
+
+
+  class AtDirectiveRegion < MigrationRegion
+    attr_accessor :directive_symbol
+
+    def initialize(starting_line_number, is_root_entity )
+      super(starting_line_number, is_root_entity, AT_DIRECTIVE_KEY, can_occur_in_class_decl:true )
+      @is_single_line = true
+      @directive_symbol = nil
+    end
+
+    def extract_information( file_slice )
+      m = DIRECTIVE_REGEX.match(file_slice[0])
+      unless m.nil?
+        @directive_symbol = m[ 'directive' ].to_sym
+      end
+    end
+
+    def brief_description()
+      return "@#{@directive_symbol.to_s}"
+    end
+
+    def description()
+      generic_description( "Objective-C directive @#{@directive_symbol.to_s}" )
+    end
+  end
+
+end

data/lib/objc2swift_assistant/recognizers/category_recognizer.rb

@@ -0,0 +1,72 @@
+require "objc2swift_assistant/version"
+
+require "objc2swift_assistant/code_recognizer"
+
+
+module Objc2swiftAssistant
+
+  CATEGORY_DECLARATION_REGEX = /^\s*(@interface)\s*(?<class_name>\w*)\s*\((?<category_name>\w*)\)/
+  CATEGORY_IMPLEMENTATION_REGEX = /^\s*(@implementation)\s*(?<class_name>\w*)\s*\((?<category_name>\w*)\)/
+
+  class CategoryDeclarationRecognizer < CodeRecognizer
+
+    def initialize( )
+      super( CATEGORY_DECLARATION_REGEX, CategoryDeclarationRegion, :implementation, true )
+    end
+  end
+
+
+  class CategoryImplRecognizer < CodeRecognizer
+
+    def initialize( )
+      super( CATEGORY_IMPLEMENTATION_REGEX, CategoryImplementationRegion, :implementation, true )
+    end
+  end
+
+
+  class AbstractCategoryRegion < ClassRootRegion
+    attr_accessor :category_name
+
+    def brief_description()
+      "#{@class_name} (#{(@category_name || "").strip})"
+    end
+  end
+
+
+  class CategoryDeclarationRegion < AbstractCategoryRegion
+    def initialize(starting_line_number, is_root_entity )
+      super(starting_line_number, is_root_entity, CAT_EXT_DECLARARATION_KEY )
+    end
+
+    def extract_information( file_slice )
+      m = CATEGORY_DECLARATION_REGEX.match(file_slice[0])
+      if m.nil?
+        @configuration.log_warning( "WARNING: Could not match category info in #{file_slice[0]}" )
+      else
+        @class_name = m[ 'class_name' ]
+        @category_name = m[ 'category_name' ]
+        @region_type = @category_name.nil? || @category_name.length == 0 ? EXTENSION_DECLARARATION_KEY : CATEGORY_DECLARARATION_KEY
+        @configuration.log_verbose( "category_name = #{@category_name} @class_name = #{@class_name}")
+      end
+    end
+  end
+
+
+  class CategoryImplementationRegion < AbstractCategoryRegion
+    def initialize(starting_line_number, is_root_entity )
+      super(starting_line_number, is_root_entity, CATEGORY_IMPLEMENTATION_KEY )
+    end
+
+    def extract_information( file_slice )
+      m = CATEGORY_IMPLEMENTATION_REGEX.match(file_slice[0])
+      if m.nil?
+        @configuration.log_warning( "Could not match category info in #{file_slice[0]}" )
+      else
+        @class_name = m[ 'class_name' ]
+        @category_name = m[ 'category_name' ]
+        @configuration.log_verbose( "Matched category = #{@category_name} @class_name = #{@class_name}")
+      end
+    end
+  end
+
+end