embeditor-rails 2.0.0.beta → 2.0.0

data/lib/node_modules/npm/node_modules/node-gyp/gyp/tools/graphviz.py

@@ -1,100 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2011 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Using the JSON dumped by the dump-dependency-json generator,
-generate input suitable for graphviz to render a dependency graph of
-targets."""
-
-import collections
-import json
-import sys
-
-
-def ParseTarget(target):
-  target, _, suffix = target.partition('#')
-  filename, _, target = target.partition(':')
-  return filename, target, suffix
-
-
-def LoadEdges(filename, targets):
-  """Load the edges map from the dump file, and filter it to only
-  show targets in |targets| and their depedendents."""
-
-  file = open('dump.json')
-  edges = json.load(file)
-  file.close()
-
-  # Copy out only the edges we're interested in from the full edge list.
-  target_edges = {}
-  to_visit = targets[:]
-  while to_visit:
-    src = to_visit.pop()
-    if src in target_edges:
-      continue
-    target_edges[src] = edges[src]
-    to_visit.extend(edges[src])
-
-  return target_edges
-
-
-def WriteGraph(edges):
-  """Print a graphviz graph to stdout.
-  |edges| is a map of target to a list of other targets it depends on."""
-
-  # Bucket targets by file.
-  files = collections.defaultdict(list)
-  for src, dst in edges.items():
-    build_file, target_name, toolset = ParseTarget(src)
-    files[build_file].append(src)
-
-  print 'digraph D {'
-  print '  fontsize=8'  # Used by subgraphs.
-  print '  node [fontsize=8]'
-
-  # Output nodes by file.  We must first write out each node within
-  # its file grouping before writing out any edges that may refer
-  # to those nodes.
-  for filename, targets in files.items():
-    if len(targets) == 1:
-      # If there's only one node for this file, simplify
-      # the display by making it a box without an internal node.
-      target = targets[0]
-      build_file, target_name, toolset = ParseTarget(target)
-      print '  "%s" [shape=box, label="%s\\n%s"]' % (target, filename,
-                                                     target_name)
-    else:
-      # Group multiple nodes together in a subgraph.
-      print '  subgraph "cluster_%s" {' % filename
-      print '    label = "%s"' % filename
-      for target in targets:
-        build_file, target_name, toolset = ParseTarget(target)
-        print '    "%s" [label="%s"]' % (target, target_name)
-      print '  }'
-
-  # Now that we've placed all the nodes within subgraphs, output all
-  # the edges between nodes.
-  for src, dsts in edges.items():
-    for dst in dsts:
-      print '  "%s" -> "%s"' % (src, dst)
-
-  print '}'
-
-
-def main():
-  if len(sys.argv) < 2:
-    print >>sys.stderr, __doc__
-    print >>sys.stderr
-    print >>sys.stderr, 'usage: %s target1 target2...' % (sys.argv[0])
-    return 1
-
-  edges = LoadEdges('dump.json', sys.argv[1:])
-
-  WriteGraph(edges)
-  return 0
-
-
-if __name__ == '__main__':
-  sys.exit(main())

data/lib/node_modules/npm/node_modules/node-gyp/gyp/tools/pretty_gyp.py

@@ -1,155 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2012 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Pretty-prints the contents of a GYP file."""
-
-import sys
-import re
-
-
-# Regex to remove comments when we're counting braces.
-COMMENT_RE = re.compile(r'\s*#.*')
-
-# Regex to remove quoted strings when we're counting braces.
-# It takes into account quoted quotes, and makes sure that the quotes match.
-# NOTE: It does not handle quotes that span more than one line, or
-# cases where an escaped quote is preceeded by an escaped backslash.
-QUOTE_RE_STR = r'(?P<q>[\'"])(.*?)(?<![^\\][\\])(?P=q)'
-QUOTE_RE = re.compile(QUOTE_RE_STR)
-
-
-def comment_replace(matchobj):
-  return matchobj.group(1) + matchobj.group(2) + '#' * len(matchobj.group(3))
-
-
-def mask_comments(input):
-  """Mask the quoted strings so we skip braces inside quoted strings."""
-  search_re = re.compile(r'(.*?)(#)(.*)')
-  return [search_re.sub(comment_replace, line) for line in input]
-
-
-def quote_replace(matchobj):
-  return "%s%s%s%s" % (matchobj.group(1),
-                       matchobj.group(2),
-                       'x'*len(matchobj.group(3)),
-                       matchobj.group(2))
-
-
-def mask_quotes(input):
-  """Mask the quoted strings so we skip braces inside quoted strings."""
-  search_re = re.compile(r'(.*?)' + QUOTE_RE_STR)
-  return [search_re.sub(quote_replace, line) for line in input]
-
-
-def do_split(input, masked_input, search_re):
-  output = []
-  mask_output = []
-  for (line, masked_line) in zip(input, masked_input):
-    m = search_re.match(masked_line)
-    while m:
-      split = len(m.group(1))
-      line = line[:split] + r'\n' + line[split:]
-      masked_line = masked_line[:split] + r'\n' + masked_line[split:]
-      m = search_re.match(masked_line)
-    output.extend(line.split(r'\n'))
-    mask_output.extend(masked_line.split(r'\n'))
-  return (output, mask_output)
-
-
-def split_double_braces(input):
-  """Masks out the quotes and comments, and then splits appropriate
-  lines (lines that matche the double_*_brace re's above) before
-  indenting them below.
-
-  These are used to split lines which have multiple braces on them, so
-  that the indentation looks prettier when all laid out (e.g. closing
-  braces make a nice diagonal line).
-  """
-  double_open_brace_re = re.compile(r'(.*?[\[\{\(,])(\s*)([\[\{\(])')
-  double_close_brace_re = re.compile(r'(.*?[\]\}\)],?)(\s*)([\]\}\)])')
-
-  masked_input = mask_quotes(input)
-  masked_input = mask_comments(masked_input)
-
-  (output, mask_output) = do_split(input, masked_input, double_open_brace_re)
-  (output, mask_output) = do_split(output, mask_output, double_close_brace_re)
-
-  return output
-
-
-def count_braces(line):
-  """keeps track of the number of braces on a given line and returns the result.
-
-  It starts at zero and subtracts for closed braces, and adds for open braces.
-  """
-  open_braces = ['[', '(', '{']
-  close_braces = [']', ')', '}']
-  closing_prefix_re = re.compile(r'(.*?[^\s\]\}\)]+.*?)([\]\}\)],?)\s*$')
-  cnt = 0
-  stripline = COMMENT_RE.sub(r'', line)
-  stripline = QUOTE_RE.sub(r"''", stripline)
-  for char in stripline:
-    for brace in open_braces:
-      if char == brace:
-        cnt += 1
-    for brace in close_braces:
-      if char == brace:
-        cnt -= 1
-
-  after = False
-  if cnt > 0:
-    after = True
-
-  # This catches the special case of a closing brace having something
-  # other than just whitespace ahead of it -- we don't want to
-  # unindent that until after this line is printed so it stays with
-  # the previous indentation level.
-  if cnt < 0 and closing_prefix_re.match(stripline):
-    after = True
-  return (cnt, after)
-
-
-def prettyprint_input(lines):
-  """Does the main work of indenting the input based on the brace counts."""
-  indent = 0
-  basic_offset = 2
-  last_line = ""
-  for line in lines:
-    if COMMENT_RE.match(line):
-      print line
-    else:
-      line = line.strip('\r\n\t ')  # Otherwise doesn't strip \r on Unix.
-      if len(line) > 0:
-        (brace_diff, after) = count_braces(line)
-        if brace_diff != 0:
-          if after:
-            print " " * (basic_offset * indent) + line
-            indent += brace_diff
-          else:
-            indent += brace_diff
-            print " " * (basic_offset * indent) + line
-        else:
-          print " " * (basic_offset * indent) + line
-      else:
-        print ""
-      last_line = line
-
-
-def main():
-  if len(sys.argv) > 1:
-    data = open(sys.argv[1]).read().splitlines()
-  else:
-    data = sys.stdin.read().splitlines()
-  # Split up the double braces.
-  lines = split_double_braces(data)
-
-  # Indent and print the output.
-  prettyprint_input(lines)
-  return 0
-
-
-if __name__ == '__main__':
-  sys.exit(main())

data/lib/node_modules/npm/node_modules/node-gyp/gyp/tools/pretty_sln.py

@@ -1,168 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2012 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Prints the information in a sln file in a diffable way.
-
-   It first outputs each projects in alphabetical order with their
-   dependencies.
-
-   Then it outputs a possible build order.
-"""
-
-__author__ = 'nsylvain (Nicolas Sylvain)'
-
-import os
-import re
-import sys
-import pretty_vcproj
-
-def BuildProject(project, built, projects, deps):
-  # if all dependencies are done, we can build it, otherwise we try to build the
-  # dependency.
-  # This is not infinite-recursion proof.
-  for dep in deps[project]:
-    if dep not in built:
-      BuildProject(dep, built, projects, deps)
-  print project
-  built.append(project)
-
-def ParseSolution(solution_file):
-  # All projects, their clsid and paths.
-  projects = dict()
-
-  # A list of dependencies associated with a project.
-  dependencies = dict()
-
-  # Regular expressions that matches the SLN format.
-  # The first line of a project definition.
-  begin_project = re.compile(('^Project\("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942'
-                              '}"\) = "(.*)", "(.*)", "(.*)"$'))
-  # The last line of a project definition.
-  end_project = re.compile('^EndProject$')
-  # The first line of a dependency list.
-  begin_dep = re.compile('ProjectSection\(ProjectDependencies\) = postProject$')
-  # The last line of a dependency list.
-  end_dep = re.compile('EndProjectSection$')
-  # A line describing a dependency.
-  dep_line = re.compile(' *({.*}) = ({.*})$')
-
-  in_deps = False
-  solution = open(solution_file)
-  for line in solution:
-    results = begin_project.search(line)
-    if results:
-      # Hack to remove icu because the diff is too different.
-      if results.group(1).find('icu') != -1:
-        continue
-      # We remove "_gyp" from the names because it helps to diff them.
-      current_project = results.group(1).replace('_gyp', '')
-      projects[current_project] = [results.group(2).replace('_gyp', ''),
-                                   results.group(3),
-                                   results.group(2)]
-      dependencies[current_project] = []
-      continue
-
-    results = end_project.search(line)
-    if results:
-      current_project = None
-      continue
-
-    results = begin_dep.search(line)
-    if results:
-      in_deps = True
-      continue
-
-    results = end_dep.search(line)
-    if results:
-      in_deps = False
-      continue
-
-    results = dep_line.search(line)
-    if results and in_deps and current_project:
-      dependencies[current_project].append(results.group(1))
-      continue
-
-  # Change all dependencies clsid to name instead.
-  for project in dependencies:
-    # For each dependencies in this project
-    new_dep_array = []
-    for dep in dependencies[project]:
-      # Look for the project name matching this cldis
-      for project_info in projects:
-        if projects[project_info][1] == dep:
-          new_dep_array.append(project_info)
-    dependencies[project] = sorted(new_dep_array)
-
-  return (projects, dependencies)
-
-def PrintDependencies(projects, deps):
-  print "---------------------------------------"
-  print "Dependencies for all projects"
-  print "---------------------------------------"
-  print "--                                   --"
-
-  for (project, dep_list) in sorted(deps.items()):
-    print "Project : %s" % project
-    print "Path : %s" % projects[project][0]
-    if dep_list:
-      for dep in dep_list:
-        print "  - %s" % dep
-    print ""
-
-  print "--                                   --"
-
-def PrintBuildOrder(projects, deps):
-  print "---------------------------------------"
-  print "Build order                            "
-  print "---------------------------------------"
-  print "--                                   --"
-
-  built = []
-  for (project, _) in sorted(deps.items()):
-    if project not in built:
-      BuildProject(project, built, projects, deps)
-
-  print "--                                   --"
-
-def PrintVCProj(projects):
-
-  for project in projects:
-    print "-------------------------------------"
-    print "-------------------------------------"
-    print project
-    print project
-    print project
-    print "-------------------------------------"
-    print "-------------------------------------"
-
-    project_path = os.path.abspath(os.path.join(os.path.dirname(sys.argv[1]),
-                                                projects[project][2]))
-
-    pretty = pretty_vcproj
-    argv = [ '',
-             project_path,
-             '$(SolutionDir)=%s\\' % os.path.dirname(sys.argv[1]),
-           ]
-    argv.extend(sys.argv[3:])
-    pretty.main(argv)
-
-def main():
-  # check if we have exactly 1 parameter.
-  if len(sys.argv) < 2:
-    print 'Usage: %s "c:\\path\\to\\project.sln"' % sys.argv[0]
-    return 1
-
-  (projects, deps) = ParseSolution(sys.argv[1])
-  PrintDependencies(projects, deps)
-  PrintBuildOrder(projects, deps)
-
-  if '--recursive' in sys.argv:
-    PrintVCProj(projects)
-  return 0
-
-
-if __name__ == '__main__':
-  sys.exit(main())

data/lib/node_modules/npm/node_modules/node-gyp/gyp/tools/pretty_vcproj.py

@@ -1,329 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2012 Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Make the format of a vcproj really pretty.
-
-   This script normalize and sort an xml. It also fetches all the properties
-   inside linked vsprops and include them explicitly in the vcproj.
-
-   It outputs the resulting xml to stdout.
-"""
-
-__author__ = 'nsylvain (Nicolas Sylvain)'
-
-import os
-import sys
-
-from xml.dom.minidom import parse
-from xml.dom.minidom import Node
-
-REPLACEMENTS = dict()
-ARGUMENTS = None
-
-
-class CmpTuple(object):
-  """Compare function between 2 tuple."""
-  def __call__(self, x, y):
-    return cmp(x[0], y[0])
-
-
-class CmpNode(object):
-  """Compare function between 2 xml nodes."""
-
-  def __call__(self, x, y):
-    def get_string(node):
-      node_string = "node"
-      node_string += node.nodeName
-      if node.nodeValue:
-        node_string += node.nodeValue
-
-      if node.attributes:
-        # We first sort by name, if present.
-        node_string += node.getAttribute("Name")
-
-        all_nodes = []
-        for (name, value) in node.attributes.items():
-          all_nodes.append((name, value))
-
-        all_nodes.sort(CmpTuple())
-        for (name, value) in all_nodes:
-          node_string += name
-          node_string += value
-
-      return node_string
-
-    return cmp(get_string(x), get_string(y))
-
-
-def PrettyPrintNode(node, indent=0):
-  if node.nodeType == Node.TEXT_NODE:
-    if node.data.strip():
-      print '%s%s' % (' '*indent, node.data.strip())
-    return
-
-  if node.childNodes:
-    node.normalize()
-  # Get the number of attributes
-  attr_count = 0
-  if node.attributes:
-    attr_count = node.attributes.length
-
-  # Print the main tag
-  if attr_count == 0:
-    print '%s<%s>' % (' '*indent, node.nodeName)
-  else:
-    print '%s<%s' % (' '*indent, node.nodeName)
-
-    all_attributes = []
-    for (name, value) in node.attributes.items():
-      all_attributes.append((name, value))
-      all_attributes.sort(CmpTuple())
-    for (name, value) in all_attributes:
-      print '%s  %s="%s"' % (' '*indent, name, value)
-    print '%s>' % (' '*indent)
-  if node.nodeValue:
-    print '%s  %s' % (' '*indent, node.nodeValue)
-
-  for sub_node in node.childNodes:
-    PrettyPrintNode(sub_node, indent=indent+2)
-  print '%s</%s>' % (' '*indent, node.nodeName)
-
-
-def FlattenFilter(node):
-  """Returns a list of all the node and sub nodes."""
-  node_list = []
-
-  if (node.attributes and
-      node.getAttribute('Name') == '_excluded_files'):
-      # We don't add the "_excluded_files" filter.
-    return []
-
-  for current in node.childNodes:
-    if current.nodeName == 'Filter':
-      node_list.extend(FlattenFilter(current))
-    else:
-      node_list.append(current)
-
-  return node_list
-
-
-def FixFilenames(filenames, current_directory):
-  new_list = []
-  for filename in filenames:
-    if filename:
-      for key in REPLACEMENTS:
-        filename = filename.replace(key, REPLACEMENTS[key])
-      os.chdir(current_directory)
-      filename = filename.strip('"\' ')
-      if filename.startswith('$'):
-        new_list.append(filename)
-      else:
-        new_list.append(os.path.abspath(filename))
-  return new_list
-
-
-def AbsoluteNode(node):
-  """Makes all the properties we know about in this node absolute."""
-  if node.attributes:
-    for (name, value) in node.attributes.items():
-      if name in ['InheritedPropertySheets', 'RelativePath',
-                  'AdditionalIncludeDirectories',
-                  'IntermediateDirectory', 'OutputDirectory',
-                  'AdditionalLibraryDirectories']:
-        # We want to fix up these paths
-        path_list = value.split(';')
-        new_list = FixFilenames(path_list, os.path.dirname(ARGUMENTS[1]))
-        node.setAttribute(name, ';'.join(new_list))
-      if not value:
-        node.removeAttribute(name)
-
-
-def CleanupVcproj(node):
-  """For each sub node, we call recursively this function."""
-  for sub_node in node.childNodes:
-    AbsoluteNode(sub_node)
-    CleanupVcproj(sub_node)
-
-  # Normalize the node, and remove all extranous whitespaces.
-  for sub_node in node.childNodes:
-    if sub_node.nodeType == Node.TEXT_NODE:
-      sub_node.data = sub_node.data.replace("\r", "")
-      sub_node.data = sub_node.data.replace("\n", "")
-      sub_node.data = sub_node.data.rstrip()
-
-  # Fix all the semicolon separated attributes to be sorted, and we also
-  # remove the dups.
-  if node.attributes:
-    for (name, value) in node.attributes.items():
-      sorted_list = sorted(value.split(';'))
-      unique_list = []
-      for i in sorted_list:
-        if not unique_list.count(i):
-          unique_list.append(i)
-      node.setAttribute(name, ';'.join(unique_list))
-      if not value:
-        node.removeAttribute(name)
-
-  if node.childNodes:
-    node.normalize()
-
-  # For each node, take a copy, and remove it from the list.
-  node_array = []
-  while node.childNodes and node.childNodes[0]:
-    # Take a copy of the node and remove it from the list.
-    current = node.childNodes[0]
-    node.removeChild(current)
-
-    # If the child is a filter, we want to append all its children
-    # to this same list.
-    if current.nodeName == 'Filter':
-      node_array.extend(FlattenFilter(current))
-    else:
-      node_array.append(current)
-
-
-  # Sort the list.
-  node_array.sort(CmpNode())
-
-  # Insert the nodes in the correct order.
-  for new_node in node_array:
-    # But don't append empty tool node.
-    if new_node.nodeName == 'Tool':
-      if new_node.attributes and new_node.attributes.length == 1:
-        # This one was empty.
-        continue
-    if new_node.nodeName == 'UserMacro':
-      continue
-    node.appendChild(new_node)
-
-
-def GetConfiguationNodes(vcproj):
-  #TODO(nsylvain): Find a better way to navigate the xml.
-  nodes = []
-  for node in vcproj.childNodes:
-    if node.nodeName == "Configurations":
-      for sub_node in node.childNodes:
-        if sub_node.nodeName == "Configuration":
-          nodes.append(sub_node)
-
-  return nodes
-
-
-def GetChildrenVsprops(filename):
-  dom = parse(filename)
-  if dom.documentElement.attributes:
-    vsprops = dom.documentElement.getAttribute('InheritedPropertySheets')
-    return FixFilenames(vsprops.split(';'), os.path.dirname(filename))
-  return []
-
-def SeekToNode(node1, child2):
-  # A text node does not have properties.
-  if child2.nodeType == Node.TEXT_NODE:
-    return None
-
-  # Get the name of the current node.
-  current_name = child2.getAttribute("Name")
-  if not current_name:
-    # There is no name. We don't know how to merge.
-    return None
-
-  # Look through all the nodes to find a match.
-  for sub_node in node1.childNodes:
-    if sub_node.nodeName == child2.nodeName:
-      name = sub_node.getAttribute("Name")
-      if name == current_name:
-        return sub_node
-
-  # No match. We give up.
-  return None
-
-
-def MergeAttributes(node1, node2):
-  # No attributes to merge?
-  if not node2.attributes:
-    return
-
-  for (name, value2) in node2.attributes.items():
-    # Don't merge the 'Name' attribute.
-    if name == 'Name':
-      continue
-    value1 = node1.getAttribute(name)
-    if value1:
-      # The attribute exist in the main node. If it's equal, we leave it
-      # untouched, otherwise we concatenate it.
-      if value1 != value2:
-        node1.setAttribute(name, ';'.join([value1, value2]))
-    else:
-      # The attribute does nto exist in the main node. We append this one.
-      node1.setAttribute(name, value2)
-
-    # If the attribute was a property sheet attributes, we remove it, since
-    # they are useless.
-    if name == 'InheritedPropertySheets':
-      node1.removeAttribute(name)
-
-
-def MergeProperties(node1, node2):
-  MergeAttributes(node1, node2)
-  for child2 in node2.childNodes:
-    child1 = SeekToNode(node1, child2)
-    if child1:
-      MergeProperties(child1, child2)
-    else:
-      node1.appendChild(child2.cloneNode(True))
-
-
-def main(argv):
-  """Main function of this vcproj prettifier."""
-  global ARGUMENTS
-  ARGUMENTS = argv
-
-  # check if we have exactly 1 parameter.
-  if len(argv) < 2:
-    print ('Usage: %s "c:\\path\\to\\vcproj.vcproj" [key1=value1] '
-           '[key2=value2]' % argv[0])
-    return 1
-
-  # Parse the keys
-  for i in range(2, len(argv)):
-    (key, value) = argv[i].split('=')
-    REPLACEMENTS[key] = value
-
-  # Open the vcproj and parse the xml.
-  dom = parse(argv[1])
-
-  # First thing we need to do is find the Configuration Node and merge them
-  # with the vsprops they include.
-  for configuration_node in GetConfiguationNodes(dom.documentElement):
-    # Get the property sheets associated with this configuration.
-    vsprops = configuration_node.getAttribute('InheritedPropertySheets')
-
-    # Fix the filenames to be absolute.
-    vsprops_list = FixFilenames(vsprops.strip().split(';'),
-                                os.path.dirname(argv[1]))
-
-    # Extend the list of vsprops with all vsprops contained in the current
-    # vsprops.
-    for current_vsprops in vsprops_list:
-      vsprops_list.extend(GetChildrenVsprops(current_vsprops))
-
-    # Now that we have all the vsprops, we need to merge them.
-    for current_vsprops in vsprops_list:
-      MergeProperties(configuration_node,
-                      parse(current_vsprops).documentElement)
-
-  # Now that everything is merged, we need to cleanup the xml.
-  CleanupVcproj(dom.documentElement)
-
-  # Finally, we use the prett xml function to print the vcproj back to the
-  # user.
-  #print dom.toprettyxml(newl="\n")
-  PrettyPrintNode(dom.documentElement)
-  return 0
-
-
-if __name__ == '__main__':
-  sys.exit(main(sys.argv))