예제 #1
0
        public ExtractMethodResult GetExtractionResult()
        {
            bool   isStaticMethod = false, isClassMethod = false;
            var    parameters = new List <Parameter>();
            string selfParam  = null;

            if (_targetScope is ClassDefinition)
            {
                var fromScope = _scopes[_scopes.Length - 1] as FunctionDefinition;
                Debug.Assert(fromScope != null);  // we don't allow extracting from classes, so we have to be coming from a function
                if (fromScope != null)
                {
                    if (fromScope.Decorators != null)
                    {
                        foreach (var decorator in fromScope.Decorators.Decorators)
                        {
                            NameExpression name = decorator as NameExpression;
                            if (name != null)
                            {
                                if (name.Name == "staticmethod")
                                {
                                    isStaticMethod = true;
                                }
                                else if (name.Name == "classmethod")
                                {
                                    isClassMethod = true;
                                }
                            }
                        }
                    }

                    if (!isStaticMethod)
                    {
                        if (fromScope.Parameters.Count > 0)
                        {
                            selfParam = fromScope.Parameters[0].Name;
                            parameters.Add(new Parameter(selfParam, ParameterKind.Normal));
                        }
                    }
                }
            }

            foreach (var param in _parameters)
            {
                var newParam = new Parameter(param, ParameterKind.Normal);
                if (parameters.Count > 0)
                {
                    newParam.AddPreceedingWhiteSpace(_ast, " ");
                }
                parameters.Add(newParam);
            }

            // include any non-closed over parameters as well...
            foreach (var input in _inputVars)
            {
                var variableScope = input.Scope;
                var parentScope   = _targetScope;

                // are these variables a child of the target scope so we can close over them?
                while (parentScope != null && parentScope != variableScope)
                {
                    parentScope = parentScope.Parent;
                }

                if (parentScope == null && input.Name != selfParam)
                {
                    // we can either close over or pass these in as parameters, add them to the list
                    var newParam = new Parameter(input.Name, ParameterKind.Normal);
                    if (parameters.Count > 0)
                    {
                        newParam.AddPreceedingWhiteSpace(_ast, " ");
                    }
                    parameters.Add(newParam);
                }
            }

            var body        = _target.GetBody(_ast);
            var isCoroutine = IsCoroutine(body);

            // reset leading indentation to single newline + indentation, this
            // strips out any proceeding comments which we don't extract
            var leading = _newline + body.GetIndentationLevel(_ast);

            body.SetLeadingWhiteSpace(_ast, leading);

            if (_outputVars.Count > 0)
            {
                // need to add a return statement
                Expression   retValue;
                Expression[] names       = new Expression[_outputVars.Count];
                int          outputIndex = 0;
                foreach (var name in _outputVars)
                {
                    var nameExpr = new NameExpression(name.Name);
                    nameExpr.AddPreceedingWhiteSpace(_ast, " ");
                    names[outputIndex++] = nameExpr;
                }
                var tuple = new TupleExpression(false, names);
                tuple.RoundTripHasNoParenthesis(_ast);
                retValue = tuple;

                var retStmt = new ReturnStatement(retValue);
                retStmt.SetLeadingWhiteSpace(_ast, leading);

                body = new SuiteStatement(
                    new Statement[] {
                    body,
                    retStmt
                }
                    );
            }
            else
            {
                // we need a SuiteStatement to give us our colon
                body = new SuiteStatement(new Statement[] { body });
            }

            DecoratorStatement decorators = null;

            if (isStaticMethod)
            {
                decorators = new DecoratorStatement(new[] { new NameExpression("staticmethod") });
            }
            else if (isClassMethod)
            {
                decorators = new DecoratorStatement(new[] { new NameExpression("classmethod") });
            }

            var res = new FunctionDefinition(new NameExpression(_name), parameters.ToArray(), body, decorators);

            res.IsCoroutine = isCoroutine;

            StringBuilder newCall = new StringBuilder();

            newCall.Append(_target.IndentationLevel);
            var method = res.ToCodeString(_ast);

            // fix up indentation...
            for (int curScope = 0; curScope < _scopes.Length; curScope++)
            {
                if (_scopes[curScope] == _targetScope)
                {
                    // this is our target indentation level.
                    var indentationLevel = _scopes[curScope].Body.GetIndentationLevel(_ast);
                    var lines            = method.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
                    int minWhiteSpace    = Int32.MaxValue;
                    for (int curLine = decorators == null ? 1 : 2; curLine < lines.Length; curLine++)
                    {
                        var line = lines[curLine];

                        for (int i = 0; i < line.Length; i++)
                        {
                            if (!Char.IsWhiteSpace(line[i]))
                            {
                                minWhiteSpace = Math.Min(minWhiteSpace, i);
                                break;
                            }
                        }
                    }

                    StringBuilder newLines = new StringBuilder();
                    newLines.Append(indentationLevel);
                    newLines.Append(lines[0]);
                    if (decorators != null)
                    {
                        newLines.Append(_newline);
                        newLines.Append(indentationLevel);
                        newLines.Append(lines[1]);
                    }

                    // don't include a bunch of blank lines...
                    int endLine = lines.Length - 1;
                    for (; endLine >= 0 && String.IsNullOrWhiteSpace(lines[endLine]); endLine--)
                    {
                    }

                    newLines.Append(_newline);
                    for (int curLine = decorators == null ? 1 : 2; curLine <= endLine; curLine++)
                    {
                        var line = lines[curLine];

                        newLines.Append(indentationLevel);
                        if (_insertTabs)
                        {
                            newLines.Append('\t');
                        }
                        else
                        {
                            newLines.Append(' ', _indentSize);
                        }

                        if (line.Length > minWhiteSpace)
                        {
                            newLines.Append(line, minWhiteSpace, line.Length - minWhiteSpace);
                        }
                        newLines.Append(_newline);
                    }
                    newLines.Append(_newline);
                    method = newLines.ToString();
                    break;
                }
            }

            string comma;

            if (_outputVars.Count > 0)
            {
                comma = "";
                foreach (var outputVar in _outputVars)
                {
                    newCall.Append(comma);
                    newCall.Append(outputVar.Name);
                    comma = ", ";
                }
                newCall.Append(" = ");
            }
            else if (_target.ContainsReturn)
            {
                newCall.Append("return ");
            }

            if (isCoroutine)
            {
                newCall.Append("await ");
            }

            if (_targetScope is ClassDefinition)
            {
                var fromScope = _scopes[_scopes.Length - 1] as FunctionDefinition;
                Debug.Assert(fromScope != null);  // we don't allow extracting from classes, so we have to be coming from a function

                if (isStaticMethod)
                {
                    newCall.Append(_targetScope.Name);
                    newCall.Append('.');
                }
                else if (fromScope != null && fromScope.Parameters.Count > 0)
                {
                    newCall.Append(fromScope.Parameters[0].Name);
                    newCall.Append('.');
                }
            }

            newCall.Append(_name);
            newCall.Append('(');

            comma = "";
            foreach (var param in parameters)
            {
                if (param.Name != selfParam)
                {
                    newCall.Append(comma);
                    newCall.Append(param.Name);
                    comma = ", ";
                }
            }

            newCall.Append(')');

            return(new ExtractMethodResult(
                       method,
                       newCall.ToString()
                       ));
        }