Czy znasz jakikolwiek IDE, który może autouzupełnić ten rodzaj kodu?

Mam tutaj generator klasy JavaScript:

(function() {
    var core = {
        bind : function(method, scope) {
            if (!( method instanceof Function))
                throw new TypeError("Function needed as method.");
            if ( typeof (scope) != "object")
                throw new TypeError("Object needed as scope.");
            return function() {
                return method.apply(scope, arguments);
            };
        },
        require : function(source) {
            if ( typeof (source) != "object" || !source)
                throw new TypeError("Object needed as source.");
            for (var property in source)
                if (source.hasOwnProperty(property) && !this.prototype.hasOwnProperty(property))
                    this.prototype[property] = source[property];
        },
        override : function(source) {
            if ( typeof (source) != "object" || !source)
                throw new TypeError("Object needed as source.");
            for (var property in source)
                if (source.hasOwnProperty(property))
                    this.prototype[property] = source[property];
        },
        extend : function(source) {
            var superClass = this;
            var newClass = source.hasOwnProperty("constructor") ? source.constructor : function() {
                superClass.apply(this, arguments);
            };
            newClass.superClass = superClass;

            var superClone = function() {
            };
            superClone.prototype = superClass.prototype;
            newClass.prototype = new superClone();
            newClass.prototype.constructor = newClass;

            if (source)
                newClass.override(source);
            return newClass;
        }
    };

    core.require.call(Function, core);

    Function.create = function (source){
        var newClass = source.hasOwnProperty("constructor") ? source.constructor : function() {};
        newClass.override(source);
        return newClass;
    };
})(); 

Potrzebuję zakończenia kodu (napisałem w komentarzach) dla tych przykładowych klas:

//Function.prototype: bind, require, override, extend
//Function.create

var A = Function.create({ //offer Function.[create]
    test: function (){
        console.log("a");
    }
});

//A is a Function instance
//A.prototype: test

var B = A.extend({ //offer A.[extend]
    test: function (){
        console.log("b");
    },
    test2: function (){
        console.log("b2");
    }
});

//B is a Function instance
//B.prototype inherits from A.prototype
//B.prototype.test overrides A.prototype.test

var F = Function.create({ //offer Function.[create]
    getA: function (){
        return new A();
    },
    getB: function (){
        return new B();
    }
});
//F is a Function instance
//F.prototype getA, getB returns A and B instances

var f = new F(); //offer [F]
//f inherits from F.prototype
var a = f.getA(); //offer f.[getA]
//a inherits from A.prototype
var b = f.getB(); //offer f.[getB]
//b inhertis from B.prototype

a.test(); //offer a.[test]
b.test(); //offer b.[test]
b.test2(); //offer b.[test2]

Muszę więc pozwolić, by IDE w jakiś sposób wiedział, że funkcje te są istniejące w funkcji.Prototyp, a te funkcje tworzą instancje funkcyjne i piszą do prototypu tych przypadków. Jest to możliwe tylko z ręcznym indeksowaniem mojego kodu, jak JSDOC, ale to nie wystarczy, aby opisać na przykład dziedzictwo. Potrzebuję więc IDE, który może sobie poradzić przynajmniej JS dziedzictwo, a które mogę napisać wtyczkę, która automatycznie tworzy ten indeksowanie. (Może wtyczka może sobie poradzić z dziedzictwem, nie wiem, jak to indeksowanie działa dokładnie ...)

Który IDE jest w stanie tego zdolny (i jak)?

5
inf3rno 16 wrzesień 2012, 16:33

2 odpowiedzi

Najlepsza odpowiedź

rozwiązanie 1:

Odkryłem, że w Eclipse Indekser JavaScript jest częścią narzędzi do projektowania narzędzi internetowych / JavaScript. Kod źródłowy jest tutaj. Deweloperzy napisali, że podwyżka jest Łatwy przedłużony, dzięki czemu możesz napisać wtyczkę z Eclipse. W takim przypadku Ten blog jest naprawdę naprawdę przydatny. Ma świetne artykuły, jak rozszerzyć JSDT, a deweloperzy JSDT mogą też pomóc. Niestety nie mam dużo czasu na stworzenie czegoś takiego, jeśli istnieje inne rozwiązanie.

rozwiązanie 2:

Rozglądałem się i stwierdził, że prawdziwy problem polega na tym, że JSDoc 3 nie jest obsługiwany całkowicie ani w NetBeans, ani w Eclipse JSDT i Aptana. Jedynym IDE, który znalazłem przy wsparciu JSDOC 3, jest Webstorm JetBrainsa, więc użyję tego. (Nie przetestowało przetransproiania do studiów wizualnych, ale jest to produkt JetBrainsa, więc prawdopodobnie działa też.)

Oryginalny przykład z JSDOC 3 w Włókno WebStorm:

/** @class*/
var A = Function.create(//offer Function.[create] -> OK!
/** @lends A.prototype*/
{ 
    test: function (){
        console.log("a");
    },
    testA: function (){
        console.log("a2");
    }
});

/** @class*/
/** @extends A*/
var B = A.extend(//offer A.[extend] -> OK!
/** @lends B.prototype*/
{ 
    test: function (){
        console.log("b");
    },
    testB: function (){
        console.log("b2");
    }
});

/** @class*/
var F = Function.create(//offer Function.[create]  -> OK!
/** @lends F.prototype*/
{ 
    /** @returns A*/
    getA: function (){
        return new A();
    },
    /** @returns B*/
    getB: function (){
        return new B();
    }
});

var f = new F();
f.getA().test(); //offer f.[getA], offer f.getA().[test] -> OK
f.getA().testA(); //offer f.[getA], offer f.getA().[testA] -> OK
f.getB().test(); //offer f.[getB], offer f.getB().[test] -> OK
f.getB().testA(); //offer f.[getB], offer f.getB().[testA] -> OK
f.getB().testB(); //offer f.[getB], offer f.getB().[testB] -> OK
2
inf3rno 19 wrzesień 2012, 14:56

Można użyć czegoś takiego jak WebStorm lub Visualstudio z zainstalowaną Resharper 6 i buduje listę wszystkich prototypów wszystkich obiektów i można użyć tego .. nie jest szczególnie przydatne, ani nie polecam go ..

2
Baz1nga 16 wrzesień 2012, 15:31