lucene/solr/dev-tools/stub-analysis-factory-maker.pl

#!/usr/bin/perl
my $ASL = q{
/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

};

# $Id:$
# $URL:$
#
# What this script does...
#
# 1) reads a list of fully qualified package.ClassNames from STDIN
# 2) gets a list of src dirs from command line
# 3) crawl the source dirs, looking for .java files corrisponding to 
#    the ClassNames, if a match is found, creates a factory for it in
#    the current working directory using info about the constructor
#    in the orriginal .java file
#
# Note...
#  * any ClassNames not found will be logged to stdout
#  * script assumes generated factorories in "org.apache.solr.analysis package
#  * factories will be compilable only if orriginal class had no special
#    constructor args.  otherwise it will have an abstract init method that
#    needs filled in.

use strict;
use warnings;
use File::Find;


my $errors = 0;

my %classes = ();
while (<STDIN>) {
    chomp;
    # skip anonymous classes
    if (!/\$/) {
	$classes{$_} = 1;
    }
}

find({wanted => \&wanted,
      no_chdir => 1,
      }, 
     @ARGV);

sub wanted {

    my $file = $File::Find::name;
    
    return unless $file =~ m{/([^/]*)\.java$};
    my $class = $1;
    
    open(my $f, "<", $file) or die "can't open $file: $!";
    my $data;
    {
	local $/; # slurp
	$data = <$f>;
    }
    close $f;

    # skip abstract classes
    return if ($data =~ m{abstract\s+(\w+\s+)*class\s+$class});
    
    my $pack = "EMPTYPACKAGE";
    if ($data =~ m/package\s+(.*);/) {
	$pack = $1;
    }

    my $fullname = "${pack}.${class}";
    # only looking for certain classes
    return unless $classes{$fullname};

    print STDERR "$file\n";

    my @imports = $data =~ m/import\s+.*;/g;
    
    if ($data =~ m{public \s+ ((?:\w+\s+)*) $class \s*\(\s* ([^\)]*) \) }sx) {
	my $modifiers = $1;
	my $argline = $2;
	
	my $mainArgType;
	my $mainArg;
	my @orderedArgs;
	
	my %args = map { my ($v,$k) = split /\s+/;
			 push @orderedArgs, $k;
			 if ($v =~ m/^(Reader|TokenStream)/) {
			     $mainArgType=$v;
			     $mainArg=$k;
			 }
			 ($k, $v)
			 } split /\s*,\s*/, $argline;
	
	# wacky, doesn't use Reader or TokenStream ... skip (maybe a Sink?)
	unless (defined $mainArgType) {
	    warn "$class doesn't have a constructor with a Reader or TokenStream\n";
	    return;
	}

	my $type = ("Reader" eq $mainArgType) ? "Tokenizer" : "TokenFilter";

	my $facClass = "${class}Factory";
	my $facFile = "${facClass}.java";

	if (-e $facFile) {
	    warn "$facFile already exists (maybe the return type isn't specific?)";
	    $errors++;
	    return;
	}
	open my $o, ">", $facFile
	    or die "can't write to $facFile: $!";

	print $o "$ASL\n";
	print $o "package org.apache.solr.analysis;\n";
	print $o "import ${pack}.*;\n";
	print $o "$_\n" foreach @imports;
	print $o "import java.util.Map;\n";
	print $o "public class ${facClass} extends Base${type}Factory {\n";
	foreach my $arg (@orderedArgs) {
	    print $o "  private $args{$arg} $arg;\n" unless $arg eq $mainArg;
	}
	if (1 < @orderedArgs) {
	    # we need to init something, stub it out
	    print $o "  public abstract void init(Map<String, String> args) {\n";
	    print $o "    super.init(args);\n";
	    print $o "    // ABSTRACT BECAUSE IT'S A STUB .. FILL IT IN\n";
	    print $o "  }\n";
	}
	print $o "  public $class create($mainArgType $mainArg) {\n";
	print $o "    return new $class(", join(",", @orderedArgs), ");\n";
	print $o "  }\n";
	print $o "}\n\n";
	close $o;
	
	delete $classes{$fullname}; # we're done with this one
    } else {
	print STDERR "can't stub $class (no public constructor?)\n";
	$errors++;
    }
}
    
if (keys %classes) {
    print STDERR "Can't stub (or find java files) for...\n";
    foreach (keys %classes) {
	print STDERR "$_\n";
    }
    $errors++;
}
exit -1 if $errors;