javaclass 0.0.3 → 0.0.4

data/lib/javaclass/java_name.rb

@@ -1,90 +1,364 @@
+require 'javaclass/java_language'
+require 'javaclass/delegate_directive'
+
 module JavaClass
-  
-  # Special string with methods to work with Java class or package names.
+
+  # Mixin with logic to work with Java package names. The "mixer" needs to declare a String field @package.
   # Author::          Peter Kofler
-  class JavaName < String
-    
-    # Return the package name of a classname or the superpackage of a package. Return an empty String if default package.
-    attr_reader :package
-    
-    # Return the simple name of this class or package.
-    attr_reader :simple_name
-    # Full normalized class name of this class.
-    attr_reader :full_name
-    
-    def initialize(string)
-      super string
-      @full_name = string.gsub(/\/|\\/,'.').sub(/\.(class|java|".*|<.*)?$/, '')
-      
-      matches = @full_name.scan(/^(.+)\.([A-Z][^.]*)$/)[0]
-      if matches
-        @package = matches[0].to_javaname
-        @simple_name = matches[1].to_javaname
-      elsif @full_name =~ /^[A-Z][^.]*$/
-        # simple name
-        @package = ''
-        @simple_name = self
-      else
-        # only package
-        @package = self
-        @simple_name = ''
-      end
+  module PackageLogic
+
+    # Return the package name of a classname or the name of the package. Return an empty String if default package.
+    # This returns just the plain String.
+    def package
+      @package
     end
-    
+
     # Return +true+ if this class is in same or in a subpackage of the given Java _packages_ or
     # if this package is same or a subpackage (with .).
     def same_or_subpackage_of?(packages)
       packages.find {|pkg| @package == pkg } != nil || subpackage_of?(packages)
     end
-    
+
     # Return +true+ if this class is in a subpackage of the given Java _packages_ .
     def subpackage_of?(packages)
-      packages.find {|pkg| @package =~ /^#{Regexp.escape(pkg)}\./ } != nil
+      packages.find {|pkg| @package =~ /^#{Regexp.escape(pkg)}#{JavaLanguage::SEPARATOR_REGEX}/ } != nil
     end
-    
+
+    # Is this package or class in the JDK? Return the first JDK package this is inside or +nil+.
+    def in_jdk?
+      if @package && @package != ''
+        package_dot = @package + JavaLanguage::SEPARATOR
+        JavaLanguage::JDK_PACKAGES_REGEX.find { |package| package_dot =~ package }
+      else
+        # default package is never in JDK
+        false
+      end
+    end
+
+    private
+
+    def package_remove_trailing_dot!
+      @package = @package[0..-2] if @package.size > 0 && @package[-1..-1] == JavaLanguage::SEPARATOR
+    end
+
+  end
+
+  # Mixin with logic to work with Java simple names. The "mixer" needs to declare a String field @simple_name.
+  # Author::          Peter Kofler
+  module SimpleNameLogic
+
+    # Return the simple name of this class or package.
+    # This returns just the plain String.
+    def simple_name
+      @simple_name
+    end
+
+    # Split the simple name at the camel case boundary _pos_ and return two parts. _pos_ may be < 0 for counting backwards.
+    def split_simple_name(pos)
+      parts = @simple_name.scan(/([A-Z][^A-Z]+)/).flatten
+      pos = parts.size + pos +1 if pos < 0
+      return ['', @simple_name] if pos <= 0
+      return [@simple_name, ''] if pos >= parts.size
+      [parts[0...pos].join, parts[pos..-1].join]
+    end
+
+  end
+  
+  # A full qualified package name. That is like <code>a.b.c</code>.
+  # Author::          Peter Kofler
+  class JavaPackageName < String
+    include PackageLogic
+
+    VALID_REGEX = /^   (?:   #{JavaLanguage::IDENTIFIER_REGEX}#{JavaLanguage::SEPARATOR_REGEX}   )*
+                       #{JavaLanguage::LOWER_IDENTIFIER_REGEX}#{JavaLanguage::SEPARATOR_REGEX}?   $/x
+
+    # Is _string_ a valid package name?               
+    def self.valid?(string)
+      string =~ VALID_REGEX
+    end
+
+    # Create a new package name _string_.               
+    def initialize(string)
+      super string
+      if string =~ VALID_REGEX
+        @package = string
+      else
+        raise ArgumentError, "#{string} is no valid package name"
+      end
+      package_remove_trailing_dot!
+    end
+
+    def to_javaname
+      self
+    end
+
+  end
+
+  # A full qualified class name. That is like <code>a.b.C</code>. Care has to be taken
+  # if this is used as hash key. String is treated special and the additional fields are lost
+  # when the key is retrieved from the Hash (because it is frozen). 
+  # Author::          Peter Kofler
+  class JavaQualifiedName < String
+    include PackageLogic
+    include SimpleNameLogic
+
+    VALID_REGEX = /^   (    (?:  #{JavaLanguage::IDENTIFIER_REGEX}#{JavaLanguage::SEPARATOR_REGEX}   )*   )
+                       (   #{JavaLanguage::IDENTIFIER_REGEX}    )   $/x
+
+    # Is _string_ a valid qualified name?               
+    def self.valid?(string)
+      string =~ VALID_REGEX
+    end
+
+    # Create a new qualified name _string_ with optional _jvmname_ and _classname_ classes which may be available.               
+    def initialize(string, jvmname=nil, classname=nil)
+      super string
+      if string =~ VALID_REGEX
+        @package = $1 || ''
+        @simple_name = $2
+        @full_name = string
+      else
+        # TODO Implement qualified name logic for inner classes (e.g. CollectionUtils$IChecker)
+        raise ArgumentError, "#{string} is no valid qualified name"
+      end
+      package_remove_trailing_dot!
+      
+      @jvm_name = jvmname
+      @class_name = classname
+    end
+
+    # Full normalized class name of this class. This returns just the plain String.
+    def full_name
+      @full_name
+    end
+
     def to_javaname
       self
     end
 
     # Return the full classname of this class, e.g. <code>java.lang.Object</code>.
     def to_classname
-      @full_name.to_javaname
+      self
     end
-    
+
     # Return the VM name of this class, e.g. <code>java/lang/Object</code>.
     def to_jvmname
-      (@full_name.gsub(/\./, '/')).to_javaname
+      return @jvm_name if @jvm_name
+      new_val = JavaVMName.new(@full_name.gsub(JavaLanguage::SEPARATOR, JavaVMName::SEPARATOR), self)
+      if frozen?
+        new_val
+      else
+        @jvm_name = new_val
+      end
     end
-    
-    # Return the Java source file name of this class, e.g. <code>java/lang/Object.java</code>.
+
+    # Return the Java source file name of this class, e.g. <code>java/lang/Object.java</code>. This is a plain String.
     def to_java_file
-      (to_jvmname + '.java').to_javaname
+      @full_name.gsub(JavaLanguage::SEPARATOR, JavaClassFileName::SEPARATOR) + JavaLanguage::SOURCE
     end
-    
+
     # Return the Java class file name of this class, e.g. <code>java/lang/Object.class</code>.
     def to_class_file
-      (to_jvmname + '.class').to_javaname
+      return @class_name if @class_name
+      new_val = JavaClassFileName.new(@full_name.gsub(JavaLanguage::SEPARATOR, JavaClassFileName::SEPARATOR) + JavaLanguage::CLASS, self)
+      if frozen?
+        new_val
+      else 
+        @class_name = new_val
+      end 
+    end
+
+  end
+
+  # Delegation of JavaQualifiedName's methods. The "mixer" needs to define a method
+  # _to_classname_ which returns a JavaQualifiedName.
+  # Author::          Peter Kofler
+  module JavaQualifiedNameDelegation # :nodoc:
+    extend DelegateDirective
+
+    def to_javaname
+      self
+    end
+
+    delegate :package, :to_classname
+    delegate :simple_name, :to_classname
+    delegate :full_name, :to_classname
+    delegate :same_or_subpackage_of?, :to_classname
+    delegate :subpackage_of?, :to_classname
+    delegate :split_simple_name, :to_classname
+    delegate :in_jdk?, :to_classname
+  end
+
+  # A class name from the JVM. That is <code>a/b/C</code>. These names are read from the constant pool.
+  # Atoms and arrays are expressed as JVM names as well.
+  # Author::          Peter Kofler
+  class JavaVMName < String
+    include JavaQualifiedNameDelegation
+
+    SEPARATOR = '/'
+    SEPARATOR_REGEX = Regexp::escape(SEPARATOR)
+    ARRAY_REGEX = /^\[+L(.+);$|^\[+([A-Z])$/
+    VALID_REGEX = /^   (?:   #{JavaLanguage::IDENTIFIER_REGEX}#{SEPARATOR_REGEX}   )*
+                       #{JavaLanguage::IDENTIFIER_REGEX}   $/x
+    # Mapping of atoms to wrappers.
+    ATOMS = { 'B' => 'java/lang/Byte', 'S' => 'java/lang/Short', 'I' => 'java/lang/Integer', 'J' => 'java/lang/Long',
+              'F' => 'java/lang/Float', 'D' => 'java/lang/Double', 'Z' => 'java/lang/Booleam', 'C' => 'java/lang/Character' }
+
+    # Is _string_ a valid JVM name?               
+    def self.valid?(string)
+      string =~ ARRAY_REGEX || string =~ VALID_REGEX
+    end
+
+    # Create a new JVM name _string_ with optional _qualified_ class which may be available.               
+    def initialize(string, qualified=nil)
+      super string
+
+      if string =~ ARRAY_REGEX
+        @is_array = string[/^\[+/].length
+        string = string.sub(ARRAY_REGEX, '\1\2')
+
+        if string =~ /^[BSIJFDZC]$/
+          @is_atom = string
+          string = ATOMS[string]
+        else
+          @is_atom = false
+        end
+      
+      else
+        @is_array = false
+      end
+
+      if string =~ VALID_REGEX
+        @jvm_name = string
+      else
+        raise ArgumentError, "#{string} is no valid JVM name"
+      end
+      @qualified_name = qualified
+      @class_name = nil      
+    end
+
+    # Is this a bytecode array, e.g. represented by <code>[B</code>.
+    def array?
+      @is_array
+    end
+
+    def to_classname
+      return @qualified_name if @qualified_name
+      new_val = JavaQualifiedName.new(@jvm_name.gsub(SEPARATOR, JavaLanguage::SEPARATOR), self, nil)
+      if frozen?
+        new_val
+      else 
+        @qualified_name = new_val
+      end 
+    end
+
+    def to_jvmname
+      self
+    end
+
+    def to_java_file
+      @jvm_name + JavaLanguage::SOURCE
     end
     
-    # Split the simple name at the camel case boundary _pos_ and return two parts. _pos_ may
-    # be < 0 for counting backwards.
-    def split_simple_name(pos)
-      parts = @simple_name.scan(/([A-Z][^A-Z]+)/).flatten
-      pos = parts.size + pos +1 if pos < 0
-      return ['', @simple_name] if pos <= 0
-      return [@simple_name, ''] if pos >= parts.size
-      [parts[0...pos].join, parts[pos..-1].join]
+    def to_class_file
+      return @class_name if @class_name
+      new_val = JavaClassFileName.new(@jvm_name + JavaLanguage::CLASS, @qualified_name)
+      if frozen?
+        new_val
+      else 
+        @class_name = new_val
+      end 
     end
+
   end
-  
+
+  # A Java class file name from the file system. That is <code>a/b/C.class</code>. 
+  # These names are read from the FolderClasspath.
+  # Author::          Peter Kofler
+  class JavaClassFileName < String
+    include JavaQualifiedNameDelegation
+
+    SEPARATOR = '/'
+    SEPARATOR_REGEX = /\/|\\/
+    VALID_REGEX = /^   (?:   #{JavaLanguage::IDENTIFIER_REGEX}#{SEPARATOR_REGEX}   )*
+                       #{JavaLanguage::IDENTIFIER_REGEX}
+                       #{JavaLanguage::CLASS_REGEX}   /x
+
+    # Is _string_ a valid class file name?               
+    def self.valid?(string)
+      string =~ VALID_REGEX
+    end
+
+    # The plain file name of this class file.
+    attr_reader :file_name
+    
+    # Create a new class file name _string_ with optional _qualified_ class which may be available.               
+    def initialize(string, qualified=nil)
+      super string
+      if string =~ VALID_REGEX
+        @file_name = string.gsub(SEPARATOR_REGEX, SEPARATOR)
+      else
+        raise ArgumentError, "#{string} is no valid class file name"
+      end
+      @qualified_name = qualified
+      @jvm_name = nil
+    end
+
+    def to_classname
+      return @qualified_name if @qualified_name
+      new_val = JavaQualifiedName.new(
+                    @file_name.gsub(SEPARATOR_REGEX, JavaLanguage::SEPARATOR).sub(JavaLanguage::CLASS_REGEX, ''),
+                      nil, self)
+      if frozen?
+        new_val
+      else 
+        @qualified_name = new_val
+      end 
+    end
+
+    def to_jvmname
+      return @jvm_name if @jvm_name
+      new_val = JavaVMName.new(@file_name.sub(JavaLanguage::CLASS_REGEX, ''), @qualified_name)
+      if frozen?
+        new_val
+      else
+        @jvm_name = new_val
+      end
+    end
+
+    def to_java_file
+      @file_name.sub(JavaLanguage::CLASS_REGEX, JavaLanguage::SOURCE)
+    end
+    
+    def to_class_file
+      self
+    end
+
+  end
+
 end
 
 class String
-  
-  # Convert a Java classname or Java class filename to JavaClass::JavaName instance. 
-  # If it's a pathname then it must be relative to the classpath.
+
+  TYPES = [JavaClass::JavaClassFileName, JavaClass::JavaVMName, JavaClass::JavaPackageName, JavaClass::JavaQualifiedName]
+
+  # Convert a Java classname or Java class filename to special String with methods to work with Java 
+  # class or package names. If it's a pathname then it must be relative to the classpath. 
+  # Source extension and additional JVM method declarations are dropped.
   def to_javaname
-    JavaClass::JavaName.new(self)
+
+    match = TYPES.find { |type| type.valid?(self) }
+    if match
+      return match.new(self)
+    end
+
+    plain_name = self.sub(/#{JavaClass::JavaLanguage::SOURCE_REGEX}|".*$|\.<.*$/, '').gsub(/\\/, '/')
+    match = TYPES.find { |type| type.valid?(plain_name) }
+    if match
+      match.new(plain_name)
+    else
+      raise ArgumentError, "unknown Java name #{self}"
+    end
   end
-  
+
 end

data/lib/javaclass/java_name_scanner.rb

@@ -0,0 +1,95 @@
+require 'javaclass/java_name'
+
+module JavaClass
+
+  # TODO Implement hard coded class searching in ClassHeader as well
+  # 1) extract common usage classes from here, to be used from 2 places
+  # 2) make nice convenience methods here, which get mixed into the DSL, so it's easy
+  # 3) add logic to ImportedTypes, which returnes the hardcoded_types, and hardcoded_3rd_party_types
+  #    wich scans Java String constants of classes to find Class.Forname
+  #    will use the JavaNameScanner module as private inclusion!
+  #    ImportedTypes new method all_types = is the old one so calling code stays the same
+  #    and a new one is declared_types and hardcoded ,   
+  # 4) add 2 methods to Dependencies, so it's also with all hardcoded types possible - automatically, no extra method
+  #    will use the JavaNameScanner module as private inclusion!  
+
+  # Mixin with logic to scan for hard coded class names.
+  # Author::          Peter Kofler
+  module JavaNameScanner
+
+    def scan_config_for_3rd_party_class_names(path)
+      scan_config_for_class_names(path).reject { |name| name.in_jdk? }
+      # need abstraction for - .reject { |name| name.in_jdk? } - have it three times
+      # maybe a mixin for enumerables containing JavaTypes
+      #JavaNameEnumerable with - .reject { |name| name.in_jdk? } - und anderen? reject_in_jdk = 3rd Party
+      # and find_all { |n| n.same_or_subpackage_of?(x) } -- also very often  = in_package()
+    end
+
+    # Find all possible class names in all XML and property files under _path_
+    def scan_config_for_class_names(path)
+      return unless File.exist? path
+      if File.file?(path) 
+        if path =~ /\.xml$|\.properties$|MANIFEST.MF$/
+          scan_text_for_class_names(IO.readlines(path).join)
+        else
+          []
+        end
+      else
+        Dir.entries(path).reject { |n| n=~/^\./ }.map { |n| scan_config_for_class_names(File.join(path, n)) }.flatten.sort
+      end
+    end
+
+    TEXT_REGEX = /
+      (?:^|>|"|'|=|:)
+      \s*
+      (   (?:#{JavaLanguage::IDENTIFIER_REGEX}#{JavaLanguage::SEPARATOR_REGEX})+#{JavaLanguage::TYPE_REGEX}   )
+      \s*
+      (?:$|<|"|'|:)
+    /x
+
+    # Extract the list of possible class names from the given _string_ . This will only find
+    # names with at least one package name.
+    def scan_text_for_class_names(string)
+      string.scan(TEXT_REGEX).flatten.map { |match| JavaQualifiedName.new(match) }
+    end
+
+  end
+
+#      -- Class Scanner
+#      init
+#        @hardcoded_types = scan_config_for_class_names
+#
+#      # Determine the imported types of this class and return their names. This does not contain the name if this class itself.
+#      def hardcoded_types
+#        @hardcoded_types 
+#      end
+#
+#      # Determine the imported types of this class which are not from the JDK. This are all hardcoded_types - all jdk types.
+#      def hardcoded_3rd_party_types
+#        hardcoded_types.reject { |name| name.in_jdk? }
+#      end
+
+#      -- Analyse - add to Dependencies (automatically, no extra method)
+#      # Determine all imported types from all classes in this classpath together with count of imports.
+#      # An additional block is used as _filter_ on class names.
+#      def hardcoded_types(&filter)
+#        type_map = Hash.new(0) # class_name (JavaQualifiedName) => cnt
+#        hardcoded_3rd_party_types.each do |type|
+#          # hash keys need to be frozen to keep state
+#          if !type_map.include?(type)
+#            type = type.freeze 
+#          end
+#
+#          type_map[type] += 1
+#        end
+#        type_map
+#      end
+#
+#      # Determine all hardcoded types from all classes in this classpath.
+#      # An additional block is used as _filter_ on class names.
+#      def external_types(&filter)
+#        used_types(&filter).keys.sort
+#      end
+
+end
+