示例#1
0
 /**
  * @return the contents that were obtained from this instance since it was started or since the
  *     last call to this method.
  */
 public String getAndClearContents() {
   synchronized (lock) {
     String string = contents.toString();
     contents.clear();
     return string;
   }
 }
示例#2
0
 private void checkExpected(int expected) {
   FastStringBuffer buf = new FastStringBuffer(40 * comps.length);
   for (IToken t : comps) {
     buf.append(t.getRepresentation());
     buf.append(", ");
   }
   String msg = "Expected " + expected + ". Found: " + buf.toString();
   assertEquals(msg, expected, comps.length);
 }
示例#3
0
  public void run(IAction action) {
    FastStringBuffer buf = new FastStringBuffer();
    try {
      PyEdit pyEdit = getPyEdit();

      PySelection pySelection = new PySelection(pyEdit);

      IPythonNature nature = pyEdit.getPythonNature();
      File editorFile = pyEdit.getEditorFile();

      if (editorFile != null) {
        if (nature != null) {
          String mod = nature.resolveModule(editorFile);
          if (mod != null) {
            buf.append(mod);

          } else {
            // Support for external files (not in PYTHONPATH).
            buf.append(FullRepIterable.getFirstPart(editorFile.getName()));
          }
        } else {
          buf.append(FullRepIterable.getFirstPart(editorFile.getName()));
        }
      }

      List<stmtType> path =
          FastParser.parseToKnowGloballyAccessiblePath(
              pySelection.getDoc(), pySelection.getStartLineIndex());
      for (stmtType stmtType : path) {
        if (buf.length() > 0) {
          buf.append('.');
        }
        buf.append(NodeUtils.getRepresentationString(stmtType));
      }

    } catch (MisconfigurationException e1) {
      Log.log(e1);
      return;
    }

    Transfer[] dataTypes = new Transfer[] {TextTransfer.getInstance()};
    Object[] data = new Object[] {buf.toString()};

    Clipboard clipboard = new Clipboard(EditorUtils.getShell().getDisplay());
    try {
      clipboard.setContents(data, dataTypes);
    } catch (SWTError e) {
      if (e.code != DND.ERROR_CANNOT_SET_CLIPBOARD) {
        throw e;
      }
      MessageDialog.openError(
          EditorUtils.getShell(), "Error copying to clipboard.", e.getMessage());
    } finally {
      clipboard.dispose();
    }
  }
示例#4
0
 public static String getRunningName(IPath[] paths) {
   FastStringBuffer buf = new FastStringBuffer(20 * paths.length);
   for (IPath p : paths) {
     if (buf.length() > 0) {
       buf.append(" - ");
     }
     buf.append(p.lastSegment());
   }
   return buf.toString();
 }
示例#5
0
 @Override
 public String toString() {
   if (file != null) {
     FastStringBuffer ret = new FastStringBuffer(name, 40);
     ret.append(" - ");
     ret.appendObject(file);
     return ret.toString();
   }
   return name;
 }
  /**
   * @param lastMayBeMethod if true, it gets the path and accepts a method (if it is the last in the
   *     stack) if false, null is returned if a method is found.
   * @param tempStack is a temporary stack object (which may be cleared)
   * @return a tuple, where the first element is the path where the entry is located (may return
   *     null). and the second element is a boolean that indicates if the last was actually a method
   *     or not.
   */
  private Tuple<String, Boolean> getPathToRoot(
      ASTEntry entry, boolean lastMayBeMethod, boolean acceptAny, FastStack<SimpleNode> tempStack) {
    if (entry.parent == null) {
      return null;
    }
    // just to be sure that it's empty
    tempStack.clear();

    boolean lastIsMethod = false;
    // if the last 'may be a method', in this case, we have to remember that it will actually be the
    // first one
    // to be analyzed.

    // let's get the stack
    while (entry.parent != null) {
      if (entry.parent.node instanceof ClassDef) {
        tempStack.push(entry.parent.node);

      } else if (entry.parent.node instanceof FunctionDef) {
        if (!acceptAny) {
          if (lastIsMethod) {
            // already found a method
            return null;
          }

          if (!lastMayBeMethod) {
            return null;
          }

          // ok, the last one may be a method... (in this search, it MUST be the first one...)
          if (tempStack.size() != 0) {
            return null;
          }
        }

        // ok, there was a class, so, let's go and set it
        tempStack.push(entry.parent.node);
        lastIsMethod = true;

      } else {
        return null;
      }
      entry = entry.parent;
    }

    // now that we have the stack, let's make it into a path...
    FastStringBuffer buf = new FastStringBuffer();
    while (tempStack.size() > 0) {
      if (buf.length() > 0) {
        buf.append(".");
      }
      buf.append(NodeUtils.getRepresentationString(tempStack.pop()));
    }
    return new Tuple<String, Boolean>(buf.toString(), lastIsMethod);
  }
示例#7
0
  /**
   * copied from org.eclipse.jdt.internal.launching.StandardVMRunner
   *
   * @param args - other arguments to be added to the command line (may be null)
   * @return
   */
  public static String getArgumentsAsStr(String[] commandLine, String... args) {
    if (args != null && args.length > 0) {
      String[] newCommandLine = new String[commandLine.length + args.length];
      System.arraycopy(commandLine, 0, newCommandLine, 0, commandLine.length);
      System.arraycopy(args, 0, newCommandLine, commandLine.length, args.length);
      commandLine = newCommandLine;
    }

    if (commandLine.length < 1) return ""; // $NON-NLS-1$
    FastStringBuffer buf = new FastStringBuffer();
    FastStringBuffer command = new FastStringBuffer();
    for (int i = 0; i < commandLine.length; i++) {
      if (commandLine[i] == null) {
        continue; // ignore nulls (changed from original code)
      }

      buf.append(' ');
      char[] characters = commandLine[i].toCharArray();
      command.clear();
      boolean containsSpace = false;
      for (int j = 0; j < characters.length; j++) {
        char character = characters[j];
        if (character == '\"') {
          command.append('\\');
        } else if (character == ' ') {
          containsSpace = true;
        }
        command.append(character);
      }
      if (containsSpace) {
        buf.append('\"');
        buf.append(command.toString());
        buf.append('\"');
      } else {
        buf.append(command.toString());
      }
    }
    return buf.toString();
  }
示例#8
0
 /** Gets the reader content as a String */
 private static String getString(Reader reader) {
   FastStringBuffer buf = new FastStringBuffer();
   char[] buffer = new char[1024];
   int count;
   try {
     while ((count = reader.read(buffer)) != -1) {
       buf.append(buffer, 0, count);
     }
   } catch (IOException e) {
     return null;
   }
   return buf.toString();
 }
  @Override
  public String toString() {
    synchronized (lock) {
      FastStringBuffer buffer = new FastStringBuffer();
      buffer.append("AdditionalInfo{");

      buffer.append("topLevel=[");
      entrySetToString(buffer, this.topLevelInitialsToInfo.entrySet());
      buffer.append("]\n");
      buffer.append("inner=[");
      entrySetToString(buffer, this.innerInitialsToInfo.entrySet());
      buffer.append("]");

      buffer.append("}");
      return buffer.toString();
    }
  }
  /**
   * The line delimiters must match the platform for the bolds to be correct, so, in this function
   * we remove the ones existing and add the ones dependent on the platform
   */
  protected String correctLineDelimiters(String str) {
    FastStringBuffer buf = new FastStringBuffer();
    for (String s : StringUtils.splitInLines(str)) {

      boolean found = false;
      while (s.endsWith("\r") || s.endsWith("\n")) {
        found = true;
        s = s.substring(0, s.length() - 1);
      }
      buf.append(s);
      if (found) {
        buf.append(LINE_DELIM);
      }
    }
    str = buf.toString();
    return str;
  }
示例#11
0
 public String getLastWord() {
   FastStringBuffer lastWordBuf = new FastStringBuffer(this.count);
   int i;
   // skip whitespaces in the end
   for (i = this.count - 1; i >= 0; i--) {
     if (!Character.isWhitespace(this.value[i])) {
       break;
     }
   }
   // actual word
   for (; i >= 0; i--) {
     if (Character.isWhitespace(this.value[i])) {
       break;
     }
     lastWordBuf.append(this.value[i]);
   }
   lastWordBuf.reverse();
   return lastWordBuf.toString();
 }
示例#12
0
文件: TreeIO.java 项目: fabioz/Pydev
  public static Map<Integer, String> loadDictFrom(
      FastBufferedReader reader, FastStringBuffer buf, ObjectsPoolMap objectsPoolMap)
      throws IOException {
    int size = StringUtils.parsePositiveInt(reader.readLine());
    HashMap<Integer, String> map = new HashMap<Integer, String>(size + 5);

    FastStringBuffer line;
    int val = 0;
    while (true) {
      line = reader.readLine();
      if (line == null) {
        return map;

      } else if (line.startsWith("-- ")) {
        if (line.startsWith("-- END DICTIONARY")) {
          return map;
        }
        throw new RuntimeException("Unexpected line: " + line);

      } else {
        int length = line.length();
        // line is str=int
        for (int i = 0; i < length; i++) {
          char c = line.charAt(i);
          if (c == '=') {
            val = StringUtils.parsePositiveInt(buf);
            buf.clear();
          } else {
            buf.appendResizeOnExc(c);
          }
        }
        String bufStr = buf.toString();
        String interned = objectsPoolMap.get(bufStr);
        if (interned == null) {
          interned = bufStr;
          objectsPoolMap.put(bufStr, bufStr);
        }
        map.put(val, interned);
        buf.clear();
      }
    }
  }
示例#13
0
  /**
   * Adds spaces after the '#' according to the configured settings. The first char of the buffer
   * passed (which is also the output) should always start with a '#'.
   */
  public static void formatComment(FormatStd std, FastStringBuffer bufWithComment) {
    if (std.spacesInStartComment > 0) {
      Assert.isTrue(bufWithComment.charAt(0) == '#');
      int len = bufWithComment.length();

      char firstCharFound = '\n';
      String bufAsString = bufWithComment.toString();
      // handle cases where the code-formatting should not take place
      if (FileUtils.isPythonShebangLine(bufAsString)) {
        return;
      }

      int spacesFound = 0;
      String remainingStringContent = "";
      for (int j = 1; j < len; j++) { // start at 1 because 0 should always be '#'
        if ((firstCharFound = bufWithComment.charAt(j)) != ' ') {
          remainingStringContent = bufAsString.substring(j).trim();
          break;
        }
        spacesFound += 1;
      }
      if (firstCharFound != '\r'
          && firstCharFound != '\n') { // Only add spaces if it wasn't an empty line.

        // handle cases where the code-formatting should not take place
        for (String s : BLOCK_COMMENT_SKIPS) {
          if (remainingStringContent.endsWith(s) || remainingStringContent.startsWith(s)) {
            return;
          }
        }
        int diff = std.spacesInStartComment - spacesFound;
        if (diff > 0) {
          bufWithComment.insertN(1, ' ', diff);
        }
      }
    }
  }
示例#14
0
  public void saveToFile(File workspaceMetadataFile) {
    if (workspaceMetadataFile.exists() && !workspaceMetadataFile.isDirectory()) {
      try {
        FileUtils.deleteFile(workspaceMetadataFile);
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
    if (!workspaceMetadataFile.exists()) {
      workspaceMetadataFile.mkdirs();
    }

    File modulesKeysFile = new File(workspaceMetadataFile, "modulesKeys");
    File pythonpatHelperFile = new File(workspaceMetadataFile, "pythonpath");
    FastStringBuffer buf;
    HashMap<String, Integer> commonTokens = new HashMap<String, Integer>();

    synchronized (modulesKeysLock) {
      buf = new FastStringBuffer(this.modulesKeys.size() * 50);
      buf.append(MODULES_MANAGER_V2);

      for (Iterator<ModulesKey> iter = this.modulesKeys.keySet().iterator(); iter.hasNext(); ) {
        ModulesKey next = iter.next();
        buf.append(next.name);
        if (next.file != null) {
          buf.append("|");
          if (next instanceof ModulesKeyForZip) {
            ModulesKeyForZip modulesKeyForZip = (ModulesKeyForZip) next;
            if (modulesKeyForZip.zipModulePath != null) {
              String fileStr = next.file.toString();
              Integer t = commonTokens.get(fileStr);
              if (t == null) {
                t = commonTokens.size();
                commonTokens.put(fileStr, t);
              }
              buf.append(t);
              buf.append("|");

              buf.append(modulesKeyForZip.zipModulePath);
              buf.append("|");
              buf.append(modulesKeyForZip.isFile ? '1' : '0');
            }
          } else {
            buf.append(next.file.toString());
          }
        }
        buf.append('\n');
      }
    }
    if (commonTokens.size() > 0) {
      FastStringBuffer header = new FastStringBuffer(buf.length() + (commonTokens.size() * 50));
      header.append(MODULES_MANAGER_V2);
      header.append("--COMMON--\n");
      for (Map.Entry<String, Integer> entries : commonTokens.entrySet()) {
        header.append(entries.getValue());
        header.append('=');
        header.append(entries.getKey());
        header.append('\n');
      }
      header.append("--END-COMMON--\n");
      header.append(buf);
      buf = header;
    }
    FileUtils.writeStrToFile(buf.toString(), modulesKeysFile);

    this.pythonPathHelper.saveToFile(pythonpatHelperFile);
  }
示例#15
0
文件: TreeIO.java 项目: fabioz/Pydev
  public static PyPublicTreeMap<String, Set<IInfo>> loadTreeFrom(
      final FastBufferedReader reader,
      final Map<Integer, String> dictionary,
      FastStringBuffer buf,
      ObjectsPoolMap objectsPoolMap,
      IPythonNature nature)
      throws IOException {
    PyPublicTreeMap<String, Set<IInfo>> tree = new PyPublicTreeMap<String, Set<IInfo>>();
    final int size = StringUtils.parsePositiveInt(reader.readLine());

    try {

      final Entry[] entries = new Entry[size];
      // each line is something as: cub|CubeColourDialog!13&999@CUBIC!263@cube!202&999@
      // note: the path (2nd int in record) is optional
      for (int iEntry = 0; iEntry < size; iEntry++) {
        buf.clear();
        FastStringBuffer line = reader.readLine();
        if (line == null || line.startsWith("-- ")) {
          throw new RuntimeException("Unexpected line: " + line);
        }
        char[] internalCharsArray = line.getInternalCharsArray();
        int length = line.length();
        String key = null;
        String infoName = null;
        String path = null;

        int i = 0;

        OUT:
        for (; i < length; i++) {
          char c = internalCharsArray[i];
          switch (c) {
            case '|':
              key = ObjectsInternPool.internLocal(objectsPoolMap, buf.toString());
              buf.clear();
              i++;
              break OUT;
            default:
              buf.appendResizeOnExc(c);
          }
        }

        int hashSize = 0;
        OUT2:
        for (; i < length; i++) {
          char c = internalCharsArray[i];
          switch (c) {
            case '|':
              hashSize = StringUtils.parsePositiveInt(buf);
              buf.clear();
              i++;
              break OUT2;
            default:
              buf.appendResizeOnExc(c);
          }
        }
        HashSet<IInfo> set = new HashSet<IInfo>(hashSize);

        for (; i < length; i++) {
          char c = internalCharsArray[i];
          switch (c) {
            case '!':
              infoName = ObjectsInternPool.internLocal(objectsPoolMap, buf.toString());
              buf.clear();
              break;

            case '&':
              path = dictionary.get(StringUtils.parsePositiveInt(buf));
              buf.clear();
              break;

            case '@':
              int dictKey = StringUtils.parsePositiveInt(buf);
              byte type = (byte) dictKey;
              type &=
                  0x07; // leave only the 3 least significant bits there (this is the type -- value
              // from 0 - 8).

              dictKey =
                  (dictKey
                      >> 3); // the entry in the dict doesn't have the least significant bits there.
              buf.clear();
              String moduleDeclared = dictionary.get(dictKey);
              if (moduleDeclared == null) {
                throw new AssertionError("Unable to find key: " + dictKey);
              }
              if (infoName == null) {
                throw new AssertionError("Info name may not be null. Line: " + line);
              }
              switch (type) {
                case IInfo.CLASS_WITH_IMPORT_TYPE:
                  set.add(new ClassInfo(infoName, moduleDeclared, path, false, nature));
                  break;
                case IInfo.METHOD_WITH_IMPORT_TYPE:
                  set.add(new FuncInfo(infoName, moduleDeclared, path, false, nature));
                  break;
                case IInfo.ATTRIBUTE_WITH_IMPORT_TYPE:
                  set.add(new AttrInfo(infoName, moduleDeclared, path, false, nature));
                  break;
                case IInfo.NAME_WITH_IMPORT_TYPE:
                  set.add(new NameInfo(infoName, moduleDeclared, path, false, nature));
                  break;
                case IInfo.MOD_IMPORT_TYPE:
                  set.add(new ModInfo(infoName, false, nature));
                  break;
                default:
                  Log.log("Unexpected type: " + type);
              }
              break;
            default:
              buf.appendResizeOnExc(c);
          }
        }

        entries[iEntry] = new MapEntry(key, set);
      }

      tree.buildFromSorted(
          size,
          new Iterator() {
            private int iNext;

            @Override
            public boolean hasNext() {
              return iNext > size;
            }

            @Override
            public Object next() {
              Object o = entries[iNext];
              iNext++;
              return o;
            }

            @Override
            public void remove() {}
          },
          null,
          null);
    } catch (ClassNotFoundException e) {
      throw new RuntimeException(e);
    }
    return tree;
  }
示例#16
0
  /**
   * This method formats a string given some standard.
   *
   * @param str the string to be formatted
   * @param std the standard to be used
   * @param parensLevel the level of the parenthesis available.
   * @return a new (formatted) string
   * @throws SyntaxErrorException
   */
  private String formatStr(
      String str, FormatStd std, int parensLevel, String delimiter, boolean throwSyntaxError)
      throws SyntaxErrorException {
    char[] cs = str.toCharArray();
    FastStringBuffer buf = new FastStringBuffer();

    // Temporary buffer for some operations. Must always be cleared before it's used.
    FastStringBuffer tempBuf = new FastStringBuffer();

    ParsingUtils parsingUtils = ParsingUtils.create(cs, throwSyntaxError);
    char lastChar = '\0';
    for (int i = 0; i < cs.length; i++) {
      char c = cs[i];

      switch (c) {
        case '\'':
        case '"':
          // ignore literals and multi-line literals, including comments...
          i = parsingUtils.eatLiterals(buf, i, std.trimMultilineLiterals);
          break;

        case '#':
          i = handleComment(std, cs, buf, tempBuf, parsingUtils, i);
          break;

        case ',':
          i = formatForComma(std, cs, buf, i, tempBuf);
          break;

        case '(':
          i =
              formatForPar(
                  parsingUtils, cs, i, std, buf, parensLevel + 1, delimiter, throwSyntaxError);
          break;

          // Things to treat:
          // +, -, *, /, %
          // ** // << >>
          // <, >, !=, <>, <=, >=, //=, *=, /=,
          // & ^ ~ |
        case '*':
          // for *, we also need to treat when it's used in varargs, kwargs and list expansion
          boolean isOperator = false;
          for (int j = buf.length() - 1; j >= 0; j--) {
            char localC = buf.charAt(j);
            if (Character.isWhitespace(localC)) {
              continue;
            }
            if (localC == '(' || localC == ',') {
              // it's not an operator, but vararg. kwarg or list expansion
            }
            if (Character.isJavaIdentifierPart(localC)) {
              // ok, there's a chance that it can be an operator, but we still have to check
              // the chance that it's a wild import
              tempBuf.clear();
              while (Character.isJavaIdentifierPart(localC)) {
                tempBuf.append(localC);
                j--;
                if (j < 0) {
                  break; // break while
                }
                localC = buf.charAt(j);
              }
              String reversed = tempBuf.reverse().toString();
              if (!reversed.equals("import") && !reversed.equals("lambda")) {
                isOperator = true;
              }
            }
            if (localC == '\'' || localC == ')' || localC == ']') {
              isOperator = true;
            }

            // If it got here (i.e.: not whitespace), get out of the for loop.
            break;
          }
          if (!isOperator) {
            buf.append('*');
            break; // break switch
          }
          // Otherwise, FALLTHROUGH

        case '+':
        case '-':
          if (c == '-' || c == '+') { // could also be *

            // handle exponentials correctly: e.g.: 1e-6 cannot have a space
            tempBuf.clear();
            boolean started = false;

            for (int j = buf.length() - 1; ; j--) {
              if (j < 0) {
                break;
              }
              char localC = buf.charAt(j);
              if (localC == ' ' || localC == '\t') {
                if (!started) {
                  continue;
                } else {
                  break;
                }
              }
              started = true;
              if (Character.isJavaIdentifierPart(localC) || localC == '.') {
                tempBuf.append(localC);
              } else {
                break; // break for
              }
            }
            boolean isExponential = true;
            String partialNumber = tempBuf.reverse().toString();
            int partialLen = partialNumber.length();
            if (partialLen < 2 || !Character.isDigit(partialNumber.charAt(0))) {
              // at least 2 chars: the number and the 'e'
              isExponential = false;
            } else {
              // first char checked... now, if the last is an 'e', we must leave it together no
              // matter what
              if (partialNumber.charAt(partialLen - 1) != 'e'
                  && partialNumber.charAt(partialLen - 1) != 'E') {
                isExponential = false;
              }
            }
            if (isExponential) {
              buf.rightTrim();
              buf.append(c);
              // skip the next whitespaces from the buffer
              int initial = i;
              do {
                i++;
              } while (i < cs.length && (c = cs[i]) == ' ' || c == '\t');
              if (i > initial) {
                i--; // backup 1 because we walked 1 too much.
              }
              break; // break switch
            }
            // Otherwise, FALLTHROUGH
          }

        case '/':
        case '%':
        case '<':
        case '>':
        case '!':
        case '&':
        case '^':
        case '~':
        case '|':
          i = handleOperator(std, cs, buf, parsingUtils, i, c);
          c = cs[i];
          break;

          // check for = and == (other cases that have an = as the operator should already be
          // treated)
        case '=':
          if (i < cs.length - 1 && cs[i + 1] == '=') {
            // if == handle as if a regular operator
            i = handleOperator(std, cs, buf, parsingUtils, i, c);
            c = cs[i];
            break;
          }

          while (buf.length() > 0 && buf.lastChar() == ' ') {
            buf.deleteLast();
          }

          boolean surroundWithSpaces = std.operatorsWithSpace;
          if (parensLevel > 0) {
            surroundWithSpaces = std.assignWithSpaceInsideParens;
          }

          // add space before
          if (surroundWithSpaces) {
            buf.append(' ');
          }

          // add the operator and the '='
          buf.append('=');

          // add space after
          if (surroundWithSpaces) {
            buf.append(' ');
          }

          i = parsingUtils.eatWhitespaces(null, i + 1);
          break;

        default:
          if (c == '\r' || c == '\n') {
            if (lastChar == ',' && std.spaceAfterComma && buf.lastChar() == ' ') {
              buf.deleteLast();
            }
            if (std.trimLines) {
              buf.rightTrim();
            }
          }
          buf.append(c);
      }
      lastChar = c;
    }
    if (parensLevel == 0 && std.trimLines) {
      buf.rightTrim();
    }
    return buf.toString();
  }
示例#17
0
  public List<IMessage> getMessages(
      SourceModule module,
      IDocument document,
      IProgressMonitor monitor,
      IAnalysisPreferences prefs) {
    try {

      if (prefs.getSeverityForType(IAnalysisPreferences.TYPE_PEP8) < IMarker.SEVERITY_WARNING) {
        return messages;
      }
      this.prefs = prefs;
      this.document = document;
      messageToIgnore = prefs.getRequiredMessageToIgnore(IAnalysisPreferences.TYPE_PEP8);
      File pep8Loc = JythonModules.getPep8Location();

      if (pep8Loc == null) {
        Log.log("Unable to get pep8 module.");
        return messages;
      }

      IAdaptable projectAdaptable = prefs.getProjectAdaptable();
      if (AnalysisPreferencesPage.useSystemInterpreter(projectAdaptable)) {
        String parameters = AnalysisPreferencesPage.getPep8CommandLineAsStr(projectAdaptable);
        String output =
            PyFormatStd.runWithPep8BaseScript(document.get(), parameters, "pep8.py", "");
        List<String> splitInLines = StringUtils.splitInLines(output, false);

        for (String line : splitInLines) {
          try {
            List<String> lst = StringUtils.split(line, ':', 4);
            int lineNumber = Integer.parseInt(lst.get(1));
            int offset = Integer.parseInt(lst.get(2)) - 1;
            String text = lst.get(3);
            this.reportError(lineNumber, offset, text, null);
          } catch (Exception e) {
            Log.log("Error parsing line: " + line, e);
          }
        }
        return messages;
      }

      String[] pep8CommandLine = AnalysisPreferencesPage.getPep8CommandLine(projectAdaptable);
      FastStringBuffer args = new FastStringBuffer(pep8CommandLine.length * 20);
      for (String string : pep8CommandLine) {
        args.append(',').append("r'").append(string).append('\'');
      }

      // It's important that the interpreter is created in the Thread and not outside the thread
      // (otherwise
      // it may be that the output ends up being shared, which is not what we want.)
      boolean useConsole = AnalysisPreferencesPage.useConsole(projectAdaptable);
      IPythonInterpreter interpreter = JythonPlugin.newPythonInterpreter(useConsole, false);
      String file = StringUtils.replaceAllSlashes(module.getFile().getAbsolutePath());
      interpreter.set("visitor", this);

      List<String> splitInLines = StringUtils.splitInLines(document.get());
      interpreter.set("lines", splitInLines);
      PyObject tempReportError = reportError;
      if (tempReportError != null) {
        interpreter.set("ReportError", tempReportError);
      } else {
        interpreter.set("ReportError", Py.None);
      }
      PyObject pep8Module = JythonModules.getPep8Module(interpreter);
      interpreter.set("pep8", pep8Module);

      String formatted = StringUtils.format(EXECUTE_PEP8, file, args.toString(), file);
      interpreter.exec(formatted);
      if (reportError == null) {
        synchronized (lock) {
          if (reportError == null) {
            reportError = interpreter.get("ReportError");
          }
        }
      }

    } catch (Exception e) {
      Log.log("Error analyzing: " + module, e);
    }

    return messages;
  }
示例#18
0
  /**
   * Formats the contents for when a parenthesis is found (so, go until the closing parens and
   * format it accordingly)
   *
   * @param throwSyntaxError
   * @throws SyntaxErrorException
   */
  private int formatForPar(
      final ParsingUtils parsingUtils,
      final char[] cs,
      final int i,
      final FormatStd std,
      final FastStringBuffer buf,
      final int parensLevel,
      final String delimiter,
      boolean throwSyntaxError)
      throws SyntaxErrorException {
    char c = ' ';
    FastStringBuffer locBuf = new FastStringBuffer();

    int j = i + 1;
    int start = j;
    int end = start;
    while (j < cs.length && (c = cs[j]) != ')') {

      j++;

      if (c == '\'' || c == '"') { // ignore comments or multiline comments...
        j = parsingUtils.eatLiterals(null, j - 1, std.trimMultilineLiterals) + 1;
        end = j;

      } else if (c == '#') {
        j = parsingUtils.eatComments(null, j - 1) + 1;
        end = j;

      } else if (c == '(') { // open another par.
        if (end > start) {
          locBuf.append(cs, start, end - start);
          start = end;
        }
        j =
            formatForPar(
                    parsingUtils,
                    cs,
                    j - 1,
                    std,
                    locBuf,
                    parensLevel + 1,
                    delimiter,
                    throwSyntaxError)
                + 1;
        start = j;

      } else {
        end = j;
      }
    }
    if (end > start) {
      locBuf.append(cs, start, end - start);
      start = end;
    }

    if (c == ')') {
      // Now, when a closing parens is found, let's see the contents of the line where that parens
      // was found
      // and if it's only whitespaces, add all those whitespaces (to handle the following case:
      // a(a,
      //  b
      //   ) <-- we don't want to change this one.
      char c1;
      FastStringBuffer buf1 = new FastStringBuffer();

      if (locBuf.indexOf('\n') != -1 || locBuf.indexOf('\r') != -1) {
        for (int k = locBuf.length();
            k > 0 && (c1 = locBuf.charAt(k - 1)) != '\n' && c1 != '\r';
            k--) {
          buf1.insert(0, c1);
        }
      }

      String formatStr =
          formatStr(trim(locBuf).toString(), std, parensLevel, delimiter, throwSyntaxError);
      FastStringBuffer formatStrBuf = trim(new FastStringBuffer(formatStr, 10));

      String closing = ")";
      if (buf1.length() > 0 && PySelection.containsOnlyWhitespaces(buf1.toString())) {
        formatStrBuf.append(buf1);

      } else if (std.parametersWithSpace) {
        closing = " )";
      }

      if (std.parametersWithSpace) {
        if (formatStrBuf.length() == 0) {
          buf.append("()");

        } else {
          buf.append("( ");
          buf.append(formatStrBuf);
          buf.append(closing);
        }
      } else {
        buf.append('(');
        buf.append(formatStrBuf);
        buf.append(closing);
      }
      return j;
    } else {
      if (throwSyntaxError) {
        throw new SyntaxErrorException("No closing ')' found.");
      }
      // we found no closing parens but we finished looking already, so, let's just add anything
      // without
      // more formatting...
      buf.append('(');
      buf.append(locBuf);
      return j;
    }
  }
示例#19
0
 public String getContents() {
   synchronized (lock) {
     return contents.toString();
   }
 }