Merge lp:~ben-hutchings/ensoft-sextant/query-fix into lp:ensoft-sextant

[Robert]

Fixed the 'sextant query ...' commands and updated so that it is possible to limit to internal calls/specify the maximum call depth from the commandline. Output can look quite pretty in yEd.

Fixed the 'sextant query ...' commands and updated so that it is possible to limit to internal calls/specify the maximum call depth from the commandline. Output can look quite pretty in yEd.

[Robert (rjwills)]

review: Approve

[Martin Morrison (isoschiz)]

No proposals found for merge of lp:~ben-hutchings/ensoft-sextant/exception-fix into lp:ensoft-sextant.

=== modified file 'src/sextant/__main__.py'
--- src/sextant/__main__.py	2014-11-18 16:54:17 +0000
+++ src/sextant/__main__.py	2014-12-18 15:16:16 +0000
@@ -158,28 +158,18 @@
     try:
         arg1 = args.funcs[0]
         arg2 = args.funcs[1]
-    except TypeError:
-        pass
-    except IndexError:
-        pass
-
-    try:
-        program_name = args.program[0]
-    except TypeError:
-        program_name = None
-
-    try:
-        suppress_common = args.suppress_common[0]
-    except TypeError:
-        suppress_common = False
-
-    query.query(remote_neo4j=args.remote_neo4j,
+    except (TypeError, IndexError):
+        pass
+
+    query.query(connection,
                 display_neo4j=_displayable_url(args),
                 input_query=args.query,
-                program_name=program_name,
+                program_name=args.program,
                 argument_1=arg1,
                 argument_2=arg2,
-                suppress_common=suppress_common)
+                suppress_common=args.suppress_common,
+                limit_internal=args.limit_internal,
+                limit_call_depth=args.limit_call_depth)
 
 # End of functions which invoke Sextant
 
@@ -243,13 +233,17 @@
     parsers['query'].add_argument('--program', metavar="PROG_NAME",
                                   help="name of program as stored in the database; "
                                        "required for all queries except 'programs'",
-                                  type=str, nargs=1)
+                                  type=str)
     parsers['query'].add_argument('--funcs', metavar='FUNCS',
                                   help='functions to pass to the query',
                                   type=str, nargs='+')
-    parsers['query'].add_argument('--suppress-common', metavar='BOOL',
-                                  help='suppress commonly called functions (True or False)',
-                                  type=str, nargs=1)
+    parsers['query'].add_argument('--suppress-common', action='store_true',
+                                  help='suppress commonly called functions (True or False)')
+    parsers['query'].add_argument('--limit-internal', action='store_true',
+                                  help='limit call graph walking to internal function calls')
+    parsers['query'].add_argument('--limit-call-depth', metavar='CALL_DEPTH',
+                                  type=int, help='limit the maximum call depth, 0 for unlimited',
+                                  default=0)
 
     parsers['web'] = subparsers.add_parser('web', help="start the web server")
     parsers['web'].add_argument('--port', metavar='PORT', type=int,

=== modified file 'src/sextant/export.py'
--- src/sextant/export.py	2014-11-19 11:37:11 +0000
+++ src/sextant/export.py	2014-12-18 15:16:16 +0000
@@ -111,7 +111,7 @@
             display_func = ProgramConverter.get_display_name(func)
             if func.type == "stub":
                 colour = "#ff00ff"
-            elif func.type == "function_pointer":
+            elif func.type == "pointer":
                 colour = "#99ffff"
             elif func.is_common:
                 colour = "#00FF00"
@@ -141,7 +141,6 @@
                                 </node>\n""".format(func.name, 20, len(display_func)*8, colour, display_func)
 
             functions_called = func.functions_i_call
-            print(functions_called)
             if remove_self_calls is True:
                 #remove calls where a function calls itself
                 for func_called, is_internal, in functions_called:
@@ -149,18 +148,17 @@
                         functions_called.remove(func_called)
 
             for callee, is_internal in functions_called:
-                print(callee, is_internal)
                 color = "#000000" if is_internal else "#ff0000"
                 if callee not in commonly_called:
                     if not(suppress_common_nodes and callee.is_common):
                             output_str += """<edge source="{}" target="{}"> <data key="d9">
                                         <y:PolyLineEdge>
-                                        <y:LineStyle color="#ff0000" type="line" width="1.0"/>
+                                        <y:LineStyle color="{}" type="line" width="1.0"/>
                                         <y:Arrows source="none" target="standard"/>
                                         <y:BendStyle smoothed="false"/>
                                         </y:PolyLineEdge>
                                         </data>
-                                     </edge>\n""".format(func.name, callee.name)
+                                     </edge>\n""".format(func.name, callee.name, color)
 
         output_str += '</graph>\n<data key="d0">    <y:Resources/>  </data>\n</graphml>'
         return output_str

=== modified file 'src/sextant/query.py'
--- src/sextant/query.py	2014-10-10 16:34:37 +0000
+++ src/sextant/query.py	2014-12-18 15:16:16 +0000
@@ -14,8 +14,9 @@
 from .export import ProgramConverter
 
 
-def query(connection, display_neo4j='', program_name=None,
-          argument_1=None, argument_2=None, suppress_common=False):
+def query(connection, input_query, display_neo4j='', program_name=None,
+          argument_1=None, argument_2=None, suppress_common=False,
+          limit_internal=False, limit_call_depth=0):
     """
     Run a query against the database at remote_neo4j.
 
@@ -36,24 +37,6 @@
 
     """
 
-    # if display_neo4j:
-    #     display_url = display_neo4j
-    # else:
-    #     display_url = remote_neo4j
-
-    # try:
-    #     db = db_api.SextantConnection(remote_neo4j)
-    # except requests.exceptions.ConnectionError as err:
-    #     logging.error("Could not connect to Neo4J server {}. Are you sure it is running?".format(display_url))
-    #     logging.error(str(err))
-    #     return 2
-    # #Not supported in python 2
-    # #except (urllib.exceptions.MaxRetryError):
-    #  #   logging.error("Connection was refused to {}. Are you sure the server is running?".format(remote_neo4j))
-    #   #  return 2
-    # except Exception as err:
-    #     logging.exception(str(err))
-    #     return 2
 
     prog = None
     names_list = None
@@ -66,24 +49,28 @@
         if argument_1 is None:
             print('Supply one function name to functions-calling.')
             return 1
-        prog = connection.get_all_functions_calling(program_name, argument_1)
+        prog = connection.get_all_functions_calling(program_name, argument_1,
+                                                    limit_internal, limit_call_depth)
     elif input_query == 'functions-called-by':
         if argument_1 is None:
             print('Supply one function name to functions-called-by.')
             return 1
-        prog = connection.get_all_functions_called(program_name, argument_1)
+        prog = connection.get_all_functions_called(program_name, argument_1,
+                                                   limit_internal, limit_call_depth)
     elif input_query == 'all-call-paths':
         if argument_1 is None and argument_2 is None:
             print('Supply two function names to calls-between.')
             return 1
-        prog = connection.get_call_paths(program_name, argument_1, argument_2)
+        prog = connection.get_call_paths(program_name, argument_1, argument_2,
+                                         limit_internal, limit_call_depth)
     elif input_query == 'whole-program':
         prog = connection.get_whole_program(program_name)
     elif input_query == 'shortest-call-path':
         if argument_1 is None and argument_2 is None:
             print('Supply two function names to shortest-path.')
             return 1
-        prog = connection.get_shortest_path_between_functions(program_name, argument_1, argument_2)
+        prog = connection.get_shortest_path_between_functions(program_name, argument_1, argument_2,
+                                                              limit_internal, limit_call_depth)
     elif input_query == 'functions':
         if program_name is not None:
             func_names = connection.get_function_names(program_name)