objc2swift_assistant 0.3.0

data/lib/objc2swift_assistant/recognizers/implementation_recognizer.rb

@@ -0,0 +1,31 @@
+require "objc2swift_assistant/version"
+
+require "objc2swift_assistant/code_recognizer"
+
+module Objc2swiftAssistant
+
+  class ImplementationRecognizer < CodeRecognizer
+    def initialize( )
+      super( /^\s*@implementation/, ImplementationRegion, :implementation, true )
+    end
+  end
+
+
+  class ImplementationRegion < ClassRootRegion
+
+    def initialize(starting_line_number, is_root_entity )
+      super(starting_line_number, is_root_entity, CLASS_IMPLEMENTATION_KEY )
+    end
+
+    def extract_information( file_slice )
+      class_name_match = /^\s*(@implementation)\s+(?<class_name>\w*)/.match(file_slice[0])
+      unless class_name_match.nil?
+        @class_name = class_name_match["class_name"]
+      else
+        @configuation.log_warning( "Could not match class name in #{file_slice[0]}" )
+      end
+    end
+
+  end
+
+end

data/lib/objc2swift_assistant/recognizers/interface_recognizer.rb

@@ -0,0 +1,37 @@
+require "objc2swift_assistant/version"
+
+require "objc2swift_assistant/code_recognizer"
+
+module Objc2swiftAssistant
+
+  class InterfaceRecognizer < CodeRecognizer
+    def initialize( )
+      super( /^\s*@interface()/, ClassInterfaceRegion, :implementation, true, voiding_regex:/^\s*@interface\s*\w*\s*\(/)
+    end
+  end
+
+
+  class ClassInterfaceRegion < ClassRootRegion
+    attr_accessor :super_class
+    attr_accessor :implements
+
+    def initialize(starting_line_number, is_root_entity )
+      super(starting_line_number, is_root_entity, CLASS_INTERFACE_KEY )
+    end
+
+    def extract_information( file_slice )
+      m = /^\s*(@interface)\s+(?<class_name>\w*)\s*:\s*(?<super_class>\w*)?\s*(<(?<implements>.*)>)?/.match(file_slice[0])
+      unless m.nil?
+        @class_name = m["class_name"]
+        @super_class = m["super_class"]
+        implements_list = m["implements"]
+        @implements = implements_list.nil? ? [] : implements_list.split( /\s*,\s*/ )
+        @configuration.log_verbose( "class_name = #{@class_name} super_class = #{@super_class} implements = #{@implements}")
+      else
+        @configuration.log_warning( "WARNING: Could not match interface declaration in #{file_slice[0]}" )
+      end
+    end
+
+  end
+
+end

data/lib/objc2swift_assistant/recognizers/method_recognizer.rb

@@ -0,0 +1,190 @@
+require_relative "../version"
+
+require_relative "../code_recognizer"
+require_relative "../objc_variable_types"
+
+module Objc2swiftAssistant
+
+  class MethodRecognizer < CodeRecognizer
+    def initialize( )
+      super( /^\s*[-+]\s*\(/, MethodRegion, :implementation, false )
+    end
+  end
+
+
+  class MethodRegion < MigrationRegion
+    # ObjC methods do not have "names"
+    attr_accessor :objc_signature
+    attr_accessor :is_class_method
+    attr_accessor :return_type
+    attr_accessor :return_pointer_level
+    attr_accessor :return_nillable_qualifier
+    attr_accessor :raw_parameter_text
+    attr_accessor :parameters
+    attr_accessor :takes_arguments
+    attr_accessor :all_lines
+    attr_accessor :unmatched_lines
+
+    def initialize(starting_line_number, is_root_entity )
+      super(starting_line_number, is_root_entity, METHOD_INDETERMINATE_KEY )
+      @unmatched_lines = []
+      @all_lines = []
+    end
+
+    def extract_information( file_slice )
+      @all_lines = file_slice
+      method_text = file_slice.join( "\n" )
+      m = method_text.match( /^\s*(?<instance_or_class>[+-])\s*\((?<return_type>\w*)\s*(?<return_pointer>\*+)?\s*(?<nil_return_qualifier>(__nullable|__nonnull))?\s*\)(?<name_and_params>[^\{;]*)\s*(?<declaration_or_implementation>(\{|(;\s*\{)+|;))/m )
+      if m.nil?
+        @configuration.log_warning( "Could not match method (implemetation or declaration) in #{file_slice[0]}..." )
+      else
+        @is_class_method = m['instance_or_class'] == '+'
+        @return_nillable_qualifier = m[ 'nil_return_qualifier' ]
+        @return_type = m[ 'return_type' ]
+        @return_pointer_level = m[ 'return_pointer' ].nil? ? 0 : m[ 'return_pointer' ].length
+        @raw_parameter_text = m[ 'name_and_params' ]
+        @parameters, @takes_arguments = parse_parameters( @raw_parameter_text )
+        @objc_signature = make_signature
+        @unmatched_lines = m.post_match.lines
+        is_declaration = m['declaration_or_implementation'] == ';'
+        @region_type = is_declaration ? METHOD_DECLARATION_KEY : METHOD_IMPLEMENTATION_KEY
+        # log_verbose( description )
+      end
+    end
+
+    def parse_parameters( parameter_text )
+      takes_arguments = true
+      parameters = []
+      matches = []
+
+      # handle single mthod names
+      if parameter_text.include?( ':' )
+        # Split the arguments including (simple) block arguments
+        parameter_text.scan( /(?<label>\w*)\s*:\s*\((?<is_weak>__weak)?(?<value>[^:]*)\)\s*(?<arg>[^:\s]*)/ ){ matches << $~ }
+        if matches.length > 0
+          # puts( matches)
+          matches.each do |m|
+            param = ObjCMethodParameter.new()
+            param.param_label = m[ 'label' ].strip
+            param.param_name = m[ 'arg' ].strip
+            unless m[ 'is_weak' ].nil?
+              param.is_weak = true
+            end
+            value =  m[ 'value' ].strip
+            if value.include? '^'
+              param.is_block_type = true    # Its a block parameter
+              param.param_type = value
+            else
+              param.is_block_type = false
+              m = value.match( /(?<null_qualifier>(__nullable|__nonnull))?\s*(?<type>\w*)\s*(?<pointer>\*+)?/ )
+              if m.nil?
+                param.match_failure = "Could not match #{value} as a non-blocl parameter"
+              else
+                param.param_type = m[ 'type' ].strip
+                param.null_qualifier = m[ 'null_qualifier' ]
+                param.pointer_level = m[ 'pointer' ].nil? ? 0 : m[ 'pointer' ].length
+              end
+            end
+
+            if param.param_label.nil?
+              param.param_label = '/* Unknown */'
+            end
+
+            parameters << param
+            takes_arguments = true
+          end
+        end
+      else
+        param = ObjCMethodParameter.new()
+        param.param_label = parameter_text.strip    # No arguments to method: create a parameter with only a label
+        parameters << param
+        takes_arguments = false
+      end
+
+      return parameters, takes_arguments
+    end
+
+    # def extract_information( file_slice )
+    #   method_text = file_slice.join( "\n" )
+    #   m = method_text.match( /^\s*(?<instance_or_class>[+-])\s*\((?<return_type>\w*)\s*(?<return_pointer>\*+)?\)(?<name_and_params>[^\{;]*)\s*(?<declaration_or_implementation>(\{|(;\s*\{)+|;))/m )
+    #   if m.nil?
+    #     puts( "WARNING: Could not match method (implemetation or declaration) in #{file_slice[0]}..." )
+    #   else
+    #     @is_class_method = m['instance_or_class'] == '+'
+    #     @return_type = m[ 'return_type' ]
+    #     @return_pointer_level = m[ 'return_pointer' ].nil? ? 0 : m[ 'return_pointer' ].length
+    #     @raw_parameter_text = m[ 'name_and_params' ]
+    #     @parameters, @takes_arguments = parse_parameters( @raw_parameter_text )
+    #     @objc_signature = make_signature
+    #     @unmatched_lines = m.post_match.lines
+    #     is_declaration = m['declaration_or_implementation'] == ';'
+    #     @region_type = is_declaration ? METHOD_DECLARATION_KEY : METHOD_IMPLEMENTATION_KEY
+    #     puts( description )
+    #   end
+    # end
+    #
+    # def parse_parameters( parameter_text )
+    #   takes_arguments = true
+    #   parameters = []
+    #   matches = []
+    #   parameter_text.scan( /(?<label>\w*)\s*:\s*\(\s*(?<null_qualifier>(__nullable|__nonnull))?\s*(?<type>\w*)\s*(?<pointer>\*+)?\s*\)\s*(?<arg>\w*)/ ){ matches << $~ }
+    #   if matches.length > 0
+    #     puts( matches)
+    #     matches.each do |m|
+    #       param = MethodParameter.new()
+    #       param.param_label = m[ 'label' ]
+    #       param.param_name = m[ 'arg' ]
+    #       param.param_type = m[ 'type' ]
+    #       param.null_qualifier = m[ 'null_qualifier' ]
+    #       param.pointer_level = m[ 'pointer' ].nil? ? 0 : m[ 'pointer' ].length
+    #       parameters << param
+    #       takes_arguments = true
+    #     end
+    #   else
+    #     param = MethodParameter.new()
+    #     param.param_label = parameter_text    # No arguments to method: create a parameter with only a label
+    #     parameters << param
+    #     takes_arguments = false
+    #   end
+    #
+    #   return parameters, takes_arguments
+    # end
+
+
+    def make_signature()
+      signature = ''
+      if @takes_arguments
+        self.parameters.each do |param|
+          signature << "#{param.param_label}:"
+        end
+      else
+        signature = self.parameters[0].param_label
+      end
+
+      return signature.strip
+    end
+
+    def takes_arguments
+      return ! @parameters[0].param_name.nil?
+    end
+
+    def params_descr()
+      'NYI'
+    end
+
+    def description()
+        return generic_description( "#{'+' if @is_class_method} return_type:#{@return_type} name:#{@name} #{'declaration' if @is_declaration} #{"body_lines:#{@unmatched_lines.length}" if @unmatched_lines.length > 0}" )
+    end
+
+    def brief_description
+      # plus_minus = @is_class_method ? '+' : '-'
+      # pointerText = ""
+      # pointerText = " *****"[1..@pointer_level+1] unless @pointer_level.nil? || @pointer_level == 0
+      # return "#{plus_minus} (#{@return_type}#{pointerText}) #{@raw_parameter_text}"
+
+      return @objc_signature
+    end
+
+  end
+
+end

data/lib/objc2swift_assistant/recognizers/pragma_mark_recognizer.rb

@@ -0,0 +1,41 @@
+require "objc2swift_assistant/version"
+
+require "objc2swift_assistant/code_recognizer"
+
+module Objc2swiftAssistant
+
+  PRAGMA_MARK_REGEX = /^\s*((#pragma mark)|(\/\/\s*MARK\s*\:))(?<mark_text>.*)/
+
+  class PragmaMarkRecognizer < CodeRecognizer
+    def initialize( )
+      super( PRAGMA_MARK_REGEX, PragmaMarkRegion, :all_source_files, false )
+    end
+  end
+
+
+  class PragmaMarkRegion < MigrationRegion
+    attr_accessor :mark_text
+
+    def initialize( starting_line_number, is_root_entity )
+      super( starting_line_number, is_root_entity, PRAGMA_MARK_KEY, can_occur_in_class_decl:true )
+    end
+
+
+    def extract_information( file_slice )
+      m = PRAGMA_MARK_REGEX.match(file_slice[0])
+      unless m.nil?
+        @mark_text = m[ 'mark_text' ]
+      end
+    end
+  end
+
+  def description()
+    if @is_block_property
+      return generic_description( "Block Property: prop_name=#{@prop_name} block_return_type=#{@block_return_type} block_args=#{@block_args}" )
+    else
+      return generic_description( "type_name=#{@type_name} is_pointer=#{@is_pointer} prop_name=#{@prop_name}" )
+    end
+  end
+
+
+end

data/lib/objc2swift_assistant/recognizers/property_declaration_recognizer.rb

@@ -0,0 +1,78 @@
+require "objc2swift_assistant/version"
+
+require "objc2swift_assistant/code_recognizer"
+
+module Objc2swiftAssistant
+
+  class PropertyDeclarationRecognizer < CodeRecognizer
+    def initialize( )
+      super( /^\s*@property/, PropertyDeclarationRegion, :all_source_files, false )
+    end
+  end
+
+
+  class PropertyDeclarationRegion < MigrationRegion
+    attr_accessor :type_name
+    attr_accessor :is_pointer
+    attr_accessor :name
+    attr_accessor :modifiers
+
+    attr_accessor :is_block_property
+    attr_accessor :block_return_type
+    attr_accessor :block_args
+
+    def initialize(starting_line_number, is_root_entity )
+      super(starting_line_number, is_root_entity, PROPERTY_DECLARATION_KEY )
+    end
+
+    def extract_information( file_slice )
+      m = /^\s*(@property)\s*\((?<modifiers>.*)\)\s*(?<type>\w*)\s*(?<pointer>\*?)\s*(?<prop_name>\w*)/.match(file_slice[0])
+      unless m.nil?
+        @type_name = m["type"]
+        @is_pointer = m["pointer"] == '*'
+        @name = m["prop_name"]
+
+        #TODO: @modifiers = capture_modifiers( m["modifiers"] )
+        @modifiers = split_modifiers( m["modifiers"] )
+        if @type_name.nil? || @type_name.length == 0
+          # Test for Block declaration
+          m = /^\s*(@property)\s*\((?<modifiers>.*)\)\s*(?<return_type>\w*)\s*\(\^(?<name>\w*)\)\s*\((?<args>.*)\)/.match(file_slice[0])
+          unless m.nil?
+            @is_block_property = true
+
+            @block_return_type = m[ 'return_type' ]
+            @name = m[ 'name' ]
+            @block_args = m[ 'args' ]   # TODO: Split these
+
+            @configuration.log_verbose( "Matched: " + description )
+          else
+            @configuration.log_warning( "Could not match block property declaraion in #{file_slice[0]}" )
+          end
+        else
+          @configuration.log_verbose( description )
+        end
+      else
+        @configuration.log_warning( "Could not match property declaraion in #{file_slice[0]}" )
+      end
+    end
+
+    def split_modifiers( modifiers )
+      return if modifiers.nil?
+      @modifiers = modifiers.strip.split( /\s*,\s*/ )
+    end
+
+    def description()
+      if @is_block_property
+        return generic_description( "Block Property: prop_name=#{@prop_name} block_return_type=#{@block_return_type} block_args=#{@block_args}" )
+      else
+        return generic_description( "type_name=#{@type_name} is_pointer=#{@is_pointer} prop_name=#{@prop_name}" )
+      end
+    end
+
+    def brief_description
+      return "(#{@modifiers.join( ', ' )}) #{@type_name} #{'*' if @is_pointer} #{@name}"
+    end
+
+  end
+
+end

data/lib/objc2swift_assistant/recognizers/protocol_recognizer.rb

@@ -0,0 +1,40 @@
+require "objc2swift_assistant/version"
+
+require "objc2swift_assistant/code_recognizer"
+
+module Objc2swiftAssistant
+
+  class ProtocolRecognizer < CodeRecognizer
+    def initialize( )
+      super( /^\s*@protocol()/, ProtocolRegion, :implementation, true, voiding_regex:/^\s*@interface\s*\w*\s*\(/)
+    end
+  end
+
+
+  class ProtocolRegion < MigrationRegion
+    attr_accessor :protocol_name
+    attr_accessor :extends
+
+    def initialize(starting_line_number, is_root_entity )
+      super(starting_line_number, is_root_entity, PROTOCOL_DECLARATION_KEY )
+    end
+
+    def extract_information( file_slice )
+      m = /^\s*(@protocol)\s+(?<protocol_name>\w*)\s*(<(?<extends>.*)>)?/.match(file_slice[0])
+      unless m.nil?
+        @protocol_name = m["protocol_name"]
+        extends_list = m["extends"]
+        @extends = extends.nil? ? [] : extends_list.split( /\s*,\s*/ )
+        @configuration.log_verbose( "class_name = #{@protocol_name} extends = #{@extends}")
+      else
+        @configuration.log_warning( "Could not match protocol declaration in #{file_slice[0]}" )
+      end
+    end
+
+    def description()
+      generic_description( "Protocol: #{@protocol_name}" )
+    end
+
+  end
+
+end

data/lib/objc2swift_assistant/recognizers/recognizer_keys.rb

@@ -0,0 +1,26 @@
+require "objc2swift_assistant/version"
+
+module Objc2swiftAssistant
+
+  CLASS_INTERFACE_KEY           = :class_interface
+  CLASS_IMPLEMENTATION_KEY      = :class_implementation
+  ENUM_DECLARATION_KEY          = :enum_declaration
+  PROPERTY_DECLARATION_KEY      = :property_declaration
+
+  CAT_EXT_DECLARARATION_KEY     = :category_or_extension_declaration
+  EXTENSION_DECLARARATION_KEY   = :extension_declaration
+  CATEGORY_DECLARARATION_KEY    = :category_declaration
+  CATEGORY_IMPLEMENTATION_KEY   = :category_implementation
+
+  PROTOCOL_DECLARATION_KEY      = :protocol_declaration
+
+  PRAGMA_MARK_KEY               = :pragma_mark
+
+  AT_DIRECTIVE_KEY              = :at_directive
+
+  METHOD_INDETERMINATE_KEY      = :method_declatation_or_implementation
+  METHOD_DECLARATION_KEY        = :method_declaration
+  METHOD_IMPLEMENTATION_KEY     = :method_implementation
+
+end
+