323 lines
13 KiB
Python
323 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Accurate Chatwoot routes.rb parser that handles nested scope/module/namespace properly.
|
|
The key insight: Chatwoot API routes are structured as:
|
|
/api/v1/accounts/:account_id/... (nested under resources :accounts)
|
|
/platform/api/v1/... (separate namespace)
|
|
/public/api/v1/... (separate namespace)
|
|
|
|
This parser tracks nesting properly to produce full path prefixes.
|
|
"""
|
|
import re
|
|
import sys
|
|
|
|
def parse_routes_rb(filepath):
|
|
with open(filepath, 'r') as f:
|
|
content = f.read()
|
|
|
|
lines = content.split('\n')
|
|
routes = []
|
|
|
|
# Stack tracks nesting context: [(type, name, path_segment, indent)]
|
|
# type can be: 'namespace', 'scope_module', 'scope_path', 'resources', 'resource', 'member', 'collection'
|
|
context_stack = []
|
|
|
|
def get_prefix():
|
|
parts = []
|
|
for typ, name, seg, ind in context_stack:
|
|
if seg: # Only add segments that contribute to path
|
|
parts.append(seg)
|
|
return '/' + '/'.join(parts) if parts else ''
|
|
|
|
def get_current_resource():
|
|
# Find the most recent resources/resource in stack
|
|
for typ, name, seg, ind in reversed(context_stack):
|
|
if typ in ('resources', 'resource'):
|
|
return name
|
|
return None
|
|
|
|
def get_resource_is_singular():
|
|
for typ, name, seg, ind in reversed(context_stack):
|
|
if typ == 'resource':
|
|
return True
|
|
if typ == 'resources':
|
|
return False
|
|
return False
|
|
|
|
def is_in_member():
|
|
for typ, name, seg, ind in reversed(context_stack):
|
|
if typ == 'member':
|
|
return True
|
|
if typ == 'collection':
|
|
return False
|
|
return False
|
|
|
|
def is_in_collection():
|
|
for typ, name, seg, ind in reversed(context_stack):
|
|
if typ == 'collection':
|
|
return True
|
|
if typ == 'member':
|
|
return False
|
|
return False
|
|
|
|
METHOD_MAP = {
|
|
'index': 'GET', 'show': 'GET', 'create': 'POST',
|
|
'update': 'PATCH', 'destroy': 'DELETE', 'new': 'GET', 'edit': 'GET'
|
|
}
|
|
|
|
i = 0
|
|
while i < len(lines):
|
|
line = lines[i]
|
|
stripped = line.strip()
|
|
indent = len(line) - len(line.lstrip())
|
|
|
|
# Skip empty lines and comments
|
|
if not stripped or stripped.startswith('#'):
|
|
i += 1
|
|
continue
|
|
|
|
# ---- NAMESPACE ----
|
|
# namespace :name → adds /name to path
|
|
ns_match = re.match(r'namespace\s+:(\w+)', stripped)
|
|
if ns_match:
|
|
name = ns_match.group(1)
|
|
context_stack.append(('namespace', name, name, indent))
|
|
i += 1
|
|
continue
|
|
|
|
# namespace :name, module: :other → adds /name to path (module only affects controller)
|
|
ns_mod_match = re.match(r'namespace\s+:(\w+),\s*module:\s*:(\w+)', stripped)
|
|
if ns_mod_match:
|
|
name = ns_mod_match.group(1)
|
|
context_stack.append(('namespace', name, name, indent))
|
|
i += 1
|
|
continue
|
|
|
|
# ---- SCOPE ----
|
|
# scope module: :name → does NOT add to path, only to controller module lookup
|
|
scope_mod_match = re.match(r'scope\s+module:\s*:(\w+)', stripped)
|
|
if scope_mod_match:
|
|
# Don't add path segment — scope module: only affects controller resolution
|
|
name = scope_mod_match.group(1)
|
|
context_stack.append(('scope_module', name, '', indent))
|
|
i += 1
|
|
continue
|
|
|
|
# scope 'path' → adds path to URL
|
|
scope_path_match = re.match(r"scope\s+'([^']+)'", stripped)
|
|
if scope_path_match:
|
|
seg = scope_path_match.group(1).lstrip('/')
|
|
context_stack.append(('scope_path', seg, seg, indent))
|
|
i += 1
|
|
continue
|
|
|
|
# ---- END ----
|
|
if stripped == 'end':
|
|
# Pop context stack — find matching block
|
|
while context_stack and context_stack[-1][3] >= indent:
|
|
context_stack.pop()
|
|
i += 1
|
|
continue
|
|
|
|
# ---- RESOURCES / RESOURCE ----
|
|
res_match = re.match(r'(resources|resource)\s+:([a-zA-Z_]\w*)', stripped)
|
|
if res_match:
|
|
kind = res_match.group(1)
|
|
name = res_match.group(2)
|
|
is_singular = (kind == 'resource')
|
|
|
|
# Path segment for resources: name (plural) or name (singular)
|
|
# For nested resources under resources :accounts, the path is /accounts/:account_id
|
|
if is_singular:
|
|
path_seg = name
|
|
else:
|
|
path_seg = name # resources :agents → /agents
|
|
|
|
# Extract only/except
|
|
only_match = re.search(r'only:\s*\[([^\]]+)\]', stripped)
|
|
except_match = re.search(r'except:\s*\[([^\]]+)\]', stripped)
|
|
|
|
default_actions = ['show', 'create', 'update', 'destroy'] if is_singular else ['index', 'show', 'create', 'update', 'destroy', 'new', 'edit']
|
|
actions = only_match and [a.strip().strip(':').strip("'").strip('"') for a in only_match.group(1).split(',')] or default_actions
|
|
|
|
if except_match:
|
|
excluded = [a.strip().strip(':').strip("'").strip('"') for a in except_match.group(1).split(',')]
|
|
actions = [a for a in actions if a not in excluded]
|
|
|
|
prefix = get_prefix()
|
|
|
|
# Determine if this is nested under another resources (needs :parent_id param)
|
|
parent_resource = None
|
|
for typ, pname, pseg, pind in reversed(context_stack):
|
|
if typ in ('resources', 'resource') and pseg:
|
|
parent_resource = pname
|
|
break
|
|
|
|
for action in actions:
|
|
method = METHOD_MAP.get(action, 'GET')
|
|
if is_singular:
|
|
# Singular resource: no :id in path
|
|
path = prefix + '/' + name
|
|
elif action in ('index', 'create', 'new'):
|
|
path = prefix + '/' + name
|
|
elif action == 'edit':
|
|
path = prefix + '/' + name + '/:id/edit'
|
|
else:
|
|
path = prefix + '/' + name + '/:id'
|
|
|
|
routes.append((method, path, action))
|
|
|
|
# Push context for nested sub-routes (member/collection blocks inside)
|
|
# In Rails, nested resources under `resources :accounts` get /accounts/:account_id prefix
|
|
# The context stack path segment includes the param for parent resources
|
|
if is_singular:
|
|
context_stack.append(('resource', name, name, indent))
|
|
else:
|
|
# resources :accounts → nested routes get /accounts/:account_id prefix
|
|
singular = name.rstrip('s') if name.endswith('s') else name
|
|
# Handle special cases
|
|
if name == 'inboxes': singular = 'inbox'
|
|
elif name == 'addresses': singular = 'address'
|
|
elif name == 'csat_survey_responses': singular = 'csat_survey_response'
|
|
elif name == 'custom_attribute_definitions': singular = 'custom_attribute_definition'
|
|
elif name == 'notification_subscriptions': singular = 'notification_subscription'
|
|
elif name == 'assignment_policies': singular = 'assignment_policy'
|
|
elif name == 'assignment_policies_v2': singular = 'assignment_policy_v2'
|
|
elif name == 'agent_capacity_policies': singular = 'agent_capacity_policy'
|
|
elif name == 'custom_filters': singular = 'custom_filter'
|
|
elif name == 'dashboard_apps': singular = 'dashboard_app'
|
|
elif name == 'bulk_actions': singular = 'bulk_action'
|
|
elif name == 'contact_inboxes': singular = 'contact_inbox'
|
|
elif name == 'canned_responses': singular = 'canned_response'
|
|
elif name == 'team_members': singular = 'team_member'
|
|
elif name == 'inbox_members': singular = 'inbox_member'
|
|
elif name == 'macro': singular = 'macro'
|
|
elif name == 'notifications': singular = 'notification'
|
|
elif name == 'labels': singular = 'label'
|
|
elif name == 'articles': singular = 'article'
|
|
elif name == 'categories': singular = 'category'
|
|
elif name == 'companies': singular = 'company'
|
|
elif name == 'campaigns': singular = 'campaign'
|
|
elif name == 'conversations': singular = 'conversation'
|
|
elif name == 'messages': singular = 'message'
|
|
elif name == 'hooks': singular = 'hook'
|
|
elif name == 'portals': singular = 'portal'
|
|
elif name == 'reports': singular = 'report'
|
|
elif name == 'contacts': singular = 'contact'
|
|
elif name == 'agents': singular = 'agent'
|
|
elif name == 'automation_rules': singular = 'automation_rule'
|
|
elif name == 'agent_bots': singular = 'agent_bot'
|
|
elif name == 'apps': singular = 'app'
|
|
elif name == 'assistants': singular = 'assistant'
|
|
elif name == 'scenarios': singular = 'scenario'
|
|
elif name == 'documents': singular = 'document'
|
|
elif name == 'tasks': singular = 'task'
|
|
context_stack.append(('resources', name, name + '/:' + singular + '_id', indent))
|
|
|
|
i += 1
|
|
continue
|
|
|
|
# ---- MEMBER DO ----
|
|
if re.match(r'member\s+do', stripped) or stripped == 'member':
|
|
context_stack.append(('member', 'member', '', indent))
|
|
i += 1
|
|
continue
|
|
|
|
# ---- COLLECTION DO ----
|
|
if re.match(r'collection\s+do', stripped) or stripped == 'collection':
|
|
context_stack.append(('collection', 'collection', '', indent))
|
|
i += 1
|
|
continue
|
|
|
|
# ---- ROUTE DEFINITIONS (inside member/collection blocks) ----
|
|
# post :action_name, on: :member
|
|
inline_member = re.match(r'(get|post|put|patch|delete)\s+:(\w+),\s*on:\s*:member', stripped)
|
|
if inline_member:
|
|
method = inline_member.group(1).upper()
|
|
action_name = inline_member.group(2)
|
|
prefix = get_prefix()
|
|
current_res = get_current_resource()
|
|
path = prefix + '/:id/' + action_name
|
|
routes.append((method, path, action_name))
|
|
i += 1
|
|
continue
|
|
|
|
# post :action_name, on: :collection
|
|
inline_collection = re.match(r'(get|post|put|patch|delete)\s+:(\w+),\s*on:\s*:collection', stripped)
|
|
if inline_collection:
|
|
method = inline_collection.group(1).upper()
|
|
action_name = inline_collection.group(2)
|
|
prefix = get_prefix()
|
|
path = prefix + '/' + action_name
|
|
routes.append((method, path, action_name))
|
|
i += 1
|
|
continue
|
|
|
|
# Inside member/collection block: get/post/etc :action_name
|
|
action_match = re.match(r'(get|post|put|patch|delete)\s+:(\w+)', stripped)
|
|
if action_match:
|
|
method = action_match.group(1).upper()
|
|
action_name = action_match.group(2)
|
|
prefix = get_prefix()
|
|
current_res = get_current_resource()
|
|
|
|
if is_in_member():
|
|
path = prefix + '/:id/' + action_name
|
|
elif is_in_collection():
|
|
path = prefix + '/' + action_name
|
|
else:
|
|
# Top-level action
|
|
path = prefix + '/' + action_name
|
|
|
|
routes.append((method, path, action_name))
|
|
i += 1
|
|
continue
|
|
|
|
# Direct path definition: get 'path', to: ...
|
|
direct_match = re.match(r"(get|post|put|patch|delete)\s+'([^']+)'", stripped)
|
|
if direct_match:
|
|
method = direct_match.group(1).upper()
|
|
path = direct_match.group(2)
|
|
prefix = get_prefix()
|
|
if not path.startswith('/'):
|
|
path = prefix + '/' + path
|
|
routes.append((method, path, ''))
|
|
i += 1
|
|
continue
|
|
|
|
# post 'path', to: ...
|
|
direct_match2 = re.match(r"(get|post|put|patch|delete)\s+\"([^\"]+)\"", stripped)
|
|
if direct_match2:
|
|
method = direct_match2.group(1).upper()
|
|
path = direct_match2.group(2)
|
|
prefix = get_prefix()
|
|
if not path.startswith('/'):
|
|
path = prefix + '/' + path
|
|
routes.append((method, path, ''))
|
|
i += 1
|
|
continue
|
|
|
|
i += 1
|
|
|
|
return routes
|
|
|
|
def main():
|
|
routes = parse_routes_rb('/home/yanghao05/Workspace/chatwoot-reference/config/routes.rb')
|
|
|
|
# Filter only API routes
|
|
api_routes = [(m, p, a) for m, p, a in routes
|
|
if any(x in p for x in ['/api/', '/platform/', '/public/api/', '/widget/', '/hc/'])]
|
|
|
|
# Deduplicate by (method, path)
|
|
unique = sorted(set((m, p) for m, p, a in api_routes))
|
|
|
|
print(f"Total parsed routes: {len(routes)}")
|
|
print(f"API routes (filtered): {len(api_routes)}")
|
|
print(f"Unique API routes: {len(unique)}")
|
|
|
|
# Output for comparison
|
|
for method, path in unique:
|
|
print(f"{method} {path}")
|
|
|
|
if __name__ == '__main__':
|
|
main() |