AngularJS-sublime-package.py

import sublime, sublime_plugin, os, re, codecs, threading, json, time, glob, itertools

isST2 = int(sublime.version()) < 3000

if isST2:
	import jscompletions
	import viewlocation
	import message
	import convert
	import scope
else:
	from . import jscompletions
	from . import viewlocation
	from . import message
	from . import convert
	from . import scope


class AngularJS():
	def init(self, isST2):
		self.isST2 = isST2
		self.projects_index_cache = {}
		self.index_cache_location = os.path.join(
			sublime.packages_path(),
			'User',
			'AngularJS.cache'
		)
		self.is_indexing = False
		self.attributes = []
		self.settings = sublime.load_settings('AngularJS-sublime-package.sublime-settings')
		self.settings_completions = sublime.load_settings('AngularJS-completions.sublime-settings')
		self.settings_js_completions = sublime.load_settings('AngularJS-js-completions.sublime-settings')

		try:
			json_data = open(self.index_cache_location, 'r').read()
			self.projects_index_cache = json.loads(json_data)
			json_data.close()
		except:
			pass

		self.process_attributes()

	def view_settings(self):
		return self.active_view().settings().get('AngularJS', {})

	def active_window(self):
		return sublime.active_window()

	def active_view(self):
		return self.active_window().active_view()

	def get_folders(self):
		return self.view_settings().get('folders', self.active_window().folders())

	def get_index_key(self):
		return "".join(self.get_folders())

	def get_project_indexes_at(self, index_key):
		return self.projects_index_cache[index_key]['definitions']

	def exclude_dirs(self):
		exclude_dirs = []
		for folder in self.get_folders():
			exclude_dirs += [glob.glob(folder+"/"+path) for path in self.settings.get('exclude_dirs', [])]
			exclude_dirs += [glob.glob(folder+"/"+path) for path in self.view_settings().get('exclude_dirs', [])]
		return list(itertools.chain(*exclude_dirs))

	def get_current_project_indexes(self):
		if self.get_index_key() in self.projects_index_cache:
			if 'definitions' not in self.projects_index_cache[self.get_index_key()]:
				self.projects_index_cache[self.get_index_key()] = {'definitions':[], 'attributes': {}}
			return self.projects_index_cache[self.get_index_key()]
		else:
			return {'definitions':[], 'attributes': {}}

	def add_indexes_to_cache(self, indexes):
		self.projects_index_cache[self.get_index_key()] = {
			'definitions': indexes[0],
			'attributes': indexes[1]
		}
		# save new indexes to file
		j_data = open(self.index_cache_location, 'w')
		j_data.write(json.dumps(self.projects_index_cache))
		j_data.close()

	def handle_file_open_go_to(self, line):
		if not self.active_view().is_loading():
			self.active_view().run_command('goto_line', {'line': line} )
		else:
			sublime.set_timeout(lambda: self.handle_file_open_go_to(line), 100)

	#
	# completions definitions/logic
	#

	def completions(self, view, prefix, locations, is_inside_tag):
		if is_inside_tag:
			attrs = []
			if(
				not self.settings.get('disable_default_directive_completions')
			):
				attrs = self.attributes[:]

			pt = locations[0] - len(prefix) - 1
			attrs += self.get_isolate_completions(view, prefix, locations, pt)
			attrs += self.add_indexed_directives()
			attrs = convert.attributes(attrs)

			return (attrs, 0)

		if not is_inside_tag:
			completions = []
			#adjust how completions work when used for completing a tag
			completions += [
				(directive[0], convert.indexedDirectiveToTag(directive[1])) for directive in self.add_indexed_directives()
			]
			if not self.settings.get('disable_default_element_completions'):
				elems = [tuple(element) for element in list(self.settings_completions.get('angular_elements', []))]
				elems = convert.elements(elems)
				completions += elems
			return completions

	def get_isolate_completions(self, view, prefix, locations, pt):
		if self.settings.get('disable_indexed_isolate_completions'):
			return []

		# pulled lots from html_completions.py
		SEARCH_LIMIT = 500
		search_start = max(0, pt - SEARCH_LIMIT - len(prefix))
		line = view.substr(sublime.Region(search_start, pt + SEARCH_LIMIT))

		line_head = line[0:pt - search_start]

		# find the tag from end of line_head
		i = len(line_head) - 1
		tag = None
		space_index = len(line_head)
		while i >= 0:
			c = line_head[i]
			if c == '<':
				# found the open tag
				tag = line_head[i + 1:space_index]
				break
			if c == ' ':
				space_index = i
			i -= 1

		# check that this tag looks valid
		if not tag:
			return []

		try:
			attrs = self.get_current_project_indexes().get('attributes').get(tag)
		except:
			return []
		if attrs:
			return [('isolate: ' + a[0] + '\t'+a[1]+'attr', a[0] + '="$1"$0') for a in attrs]
		else:
			return []

	def filter_completions(self):
		current_point = self.active_view().sel()[0].end()
		previous_text_block = self.active_view().substr(sublime.Region(current_point-2,current_point))
		if(previous_text_block == '| '):
			filter_list = self.get_current_project_indexes().get('definitions')
			filter_list = [(i[0], i[0][9:]) for i in filter_list if i[0][:6] == 'filter']
			filter_list = list(set(filter_list)) #attempt to remove duplicates
			filter_list += [tuple(completion)  for completion in self.settings_completions.get('filter_list', [])]
			return(filter_list)
		else:
			return []

	def add_indexed_directives(self):
		if self.settings.get('disable_indexed_directive_completions'): return []

		try:
			indexes = self.get_current_project_indexes().get('definitions')
		except:
			return []

		indexed_attrs = [
			tuple([
				'ngDir_' + convert.definitionToDirective(directive) + '\tAngularJS',
				convert.definitionToDirective(directive)+'="$1"$0'
			]) for directive in indexes if re.match('directive:', directive[0])
		]
		return list(set(indexed_attrs))

	def process_attributes(self):
		add_data_prefix = self.settings.get('enable_data_prefix')

		for attr in self.settings_completions.get('core_attribute_list'):
			if add_data_prefix:
				attr[1] = "data-" + attr[1]

			self.attributes.append(attr)

		for attr in self.settings_completions.get('extended_attribute_list'):
			if add_data_prefix:
				attr[1] = "data-" + attr[1]

			self.attributes.append(attr)

		if self.settings.get('enable_AngularUI_directives'):
			for attr in self.settings_completions.get('AngularUI_attribute_list'):
				if add_data_prefix:
					attr[1] = 'data-' + attr[1]

				self.attributes.append(attr)

		self.attributes = [tuple(attr) for attr in self.attributes]

ng = AngularJS()

if int(sublime.version()) < 3000:
	ng.init(isST2=True)


def plugin_loaded():
	global ng
	ng.init(isST2=False)


class AngularJSEventListener(sublime_plugin.EventListener):
	global ng

	def on_query_completions(self, view, prefix, locations):
		if ng.settings.get('disable_all_completions'):
			return []
		if ng.settings.get('show_current_scope'):
			print(view.scope_name(view.sel()[0].a))
		_scope = locations[0]

		if(
			view.score_selector(_scope, ng.settings.get('js_scope'))
			and not view.substr(locations[0] - 1) in ng.settings.get('js_prefixes')
		):
			return jscompletions.global_completions(view, prefix, locations, ng.get_current_project_indexes())
		if(view.score_selector(_scope, 'source.js string.quoted')):
			if viewlocation.at_line_with_module(view, locations):
				return jscompletions.get(('module'), ng.get_current_project_indexes())
			return jscompletions.in_string_completions(prefix, ng.get_current_project_indexes())

		if(viewlocation.at_html_attribute(view, 'ng-controller', locations)):
			return jscompletions.get(('controller'), ng.get_current_project_indexes())
		if(viewlocation.at_html_attribute(view, 'ng-app', locations)):
			return jscompletions.get(('module'), ng.get_current_project_indexes())
		if(view.score_selector(_scope, ng.settings.get('filter_scope'))):
			return ng.filter_completions()

		'''
		check to see if we're at a '<'
		ST 3 element completions can start on the next prefix
		which puts us inside the tag scope and not the element
		'''
		html_lt = True

		if prefix:
			html_lt = view.substr(locations[0]-2) == '<'
		attribute_scopes = list(ng.settings.get('attribute_scopes'))
		attribute_scopes = ', '.join(attribute_scopes)
		is_attribute = view.score_selector(_scope, attribute_scopes)

		if is_attribute and not html_lt:
			return ng.completions(view, prefix, locations, True)

		component_scopes = list(ng.settings.get('component_scopes'))
		component_scopes = ', '.join(component_scopes)
		is_component = view.match_selector(locations[0], component_scopes)
		is_html_scope = scope.matches('text.html')
		#another workaround due to how ST2 and 3 differ when default triggers are triggered
		if(
			((is_component and not is_html_scope) or (ng.isST2 and is_component))
			or
			(is_attribute and html_lt and is_html_scope)
		):
			return ng.completions(view, prefix, locations, False)

	def on_post_save(self, view):
		thread = AngularJSThread(
			file_path = view.file_name(),
			folder_exclude_patterns = view.settings().get('folder_exclude_patterns'),
			exclude_dirs = ng.exclude_dirs(),
			exclude_file_suffixes = ng.settings.get('exclude_file_suffixes'),
			match_definitions = ng.settings.get('match_definitions'),
			match_expression = ng.settings.get('match_expression'),
			match_expression_group = ng.settings.get('match_expression_group'),
			index_key = ng.get_index_key()
		)
		thread.start()


class AngularjsDeleteCacheCommand(sublime_plugin.WindowCommand):
	global ng

	def run(self):
		message.alert('Deleting Cache')
		try:
			os.remove(ng.index_cache_location)
		except:
			message.alert('Deleting Cache: No cache file found.')
		ng.projects_index_cache = {}


class AngularjsFileIndexCommand(sublime_plugin.WindowCommand):

	global ng

	def run(self):
		if not ng.active_view():
			message.alert('There was no active view found to process this command')
			return

		ng.is_indexing = True
		thread = AngularJSThread(
			folders = ng.get_folders(),
			folder_exclude_patterns = ng.active_view().settings().get('folder_exclude_patterns'),
			exclude_dirs = ng.exclude_dirs(),
			exclude_file_suffixes = ng.settings.get('exclude_file_suffixes'),
			match_definitions = ng.settings.get('match_definitions'),
			match_expression = ng.settings.get('match_expression'),
			match_expression_group = ng.settings.get('match_expression_group')
		)

		thread.start()
		self.track_walk_thread(thread)

	def track_walk_thread(self, thread):
		message.alert('indexing definitions')

		if thread.is_alive():
			sublime.set_timeout(lambda: self.track_walk_thread(thread), 1000)
		else:
			ng.add_indexes_to_cache(thread.result)
			message.alert('indexing completed in ' + str(thread.time_taken))
			ng.is_indexing = False


class AngularjsFindCommand(sublime_plugin.WindowCommand):

	global ng

	def run(self):
		self.old_view = ng.active_view()
		try:
			self.definition_List = ng.get_current_project_indexes().get('definitions')
		except:
			self.definition_List = None

		if ng.is_indexing:
			return

		if not self.definition_List:
			ng.active_window().run_command('angularjs_file_index')
			return

		self.current_window = ng.active_window()
		self.current_view = ng.active_view()
		self.current_file = self.current_view.file_name()
		self.current_file_location = self.current_view.sel()[0].end()

		formated_definition_list = []
		for item in self.definition_List:
			current_definition = [
				item[0],
				[item[1].replace(path,'') for path in ng.get_folders()][0][1:]
			]
			formated_definition_list.append(current_definition);

		if int(sublime.version()) >= 3000 and ng.settings.get('show_file_preview'):
			self.current_window.show_quick_panel(formated_definition_list, self.on_done, False, -1, self.on_highlight)
		else:
			self.current_window.show_quick_panel(formated_definition_list, self.on_done)

	def on_highlight(self, index):
		self.current_window.open_file(self.definition_List[index][1], sublime.TRANSIENT)
		ng.active_view().run_command('goto_line', {'line': int(self.definition_List[index][2])} )

	def on_done(self, index):
		if index > -1:
			self.current_view = self.current_window.open_file(self.definition_List[index][1])
			self.handle_file_open_go_to(int(self.definition_List[index][2]))
		else:
			self.current_window.focus_view(self.old_view)
			self.current_view.show_at_center(self.current_file_location)

	def handle_file_open_go_to(self, line):
		if not self.current_view.is_loading():
			self.current_view.run_command('goto_line', {'line': line} )
		else:
			sublime.set_timeout(lambda: self.handle_file_open_go_to(line), 100)


class AngularjsGoToDefinitionCommand(sublime_plugin.WindowCommand):
	global ng

	def run(self):
		self.active_view = ng.active_view()

		if not ng.get_current_project_indexes().get('definitions'):
			message.alert('No indexing found for project')
			return

		# grab first region
		region = self.active_view.sel()[0]

		# no selection has been made
		# so begin expanding to find word
		if not region.size():
			definition = viewlocation.find_word(self.active_view, region)
		else:
			definition = self.active_view.substr(region)

		# ensure data- is striped out before trying to
		# normalize and look up
		definition = definition.replace('data-', '')

		# convert selections such as app-version to appVersion
		# for proper look up
		definition = re.sub('(\w*)-(\w*)', lambda match: match.group(1) + match.group(2).capitalize(), definition)
		for item in ng.get_current_project_indexes().get('definitions'):
			if(re.search('. '+definition+'$', item[0])):
				self.active_view = ng.active_window().open_file(item[1])
				ng.handle_file_open_go_to(int(item[2]))
				return
		message.alert('definition "%s" could not be found' % definition)


class AngularjsGoToDocumentationCommand(sublime_plugin.WindowCommand):
	global ng

	def run(self):
		import webbrowser

		self.active_view = ng.active_view()

		# grab first region
		region = self.active_view.sel()[0]

		# no selection has been made
		# so begin expanding to find word
		if not region.size():
			definition = viewlocation.find_word(ng.active_view(), region)
		else:
			definition = self.active_view.substr(region)

		# ensure data- is striped out before trying to
		# normalize and look up
		definition = definition.replace('data-', '')

		# convert selections such as app-version to appVersion
		# for proper look up
		definition = re.sub('(\w*)-(\w*)', lambda match: match.group(1) + match.group(2).capitalize(), definition)

		webbrowser.open('http://docs.angularjs.org/api/ng.directive:' + definition)


class AngularJSThread(threading.Thread):
	global ng

	def __init__(self, **kwargs):
		self.kwargs = kwargs
		threading.Thread.__init__(self)

	def run(self):
		self.function_matches = []
		self.function_match_details = []
		self.attribute_dict = {}
		start = time.time()

		walk_dirs_requirements = (
			'folders',
			'folder_exclude_patterns',
			'exclude_dirs',
			'exclude_file_suffixes',
			'match_definitions',
			'match_expression',
			'match_expression_group'
		)

		reindex_file_requirements = (
			'file_path',
			'index_key',
			'folder_exclude_patterns',
			'exclude_dirs',
			'exclude_file_suffixes',
			'match_definitions',
			'match_expression',
			'match_expression_group'
		)

		if all(keys in self.kwargs for keys in walk_dirs_requirements):
			self.walk_dirs()

		if all(keys in self.kwargs for keys in reindex_file_requirements):
			self.reindex_file(self.kwargs['index_key'])

		self.time_taken = time.time() - start
		self.result = [self.function_matches, self.attribute_dict]

	def compile_patterns(self, patterns):
		match_expressions = []
		for definition in patterns:
			match_expressions.append(
				(definition, re.compile(self.kwargs['match_expression'].format(definition)))
			)
		return match_expressions

	def walk_dirs(self):
		match_expressions = self.compile_patterns(self.kwargs['match_definitions'])

		for path in self.kwargs['folders']:
			for r,d,f in os.walk(path):
				d[:] = [_d for _d in d if _d not in self.kwargs['folder_exclude_patterns']]
				if not [skip for skip in self.kwargs['exclude_dirs'] if os.path.join(path, os.path.normpath(skip)) in r]:
					for _file in f:
						self.parse_file(_file, r, match_expressions)

	def reindex_file(self, index_key):
		file_path = self.kwargs['file_path']

		if not file_path.endswith(".js"): return

		current_path = os.path.split(file_path)[0]
		# adds limit, to insure we never hit an infinite loop...
		folders, limit, count = [], 100, 0
		while True and count < limit:
			count += 1
			current_path, folder = os.path.split(current_path)
			if folder != "": folders.append(folder)
			if current_path == "" or folder == "": break
		if [f for f in folders if f in list(self.kwargs['folder_exclude_patterns'])]:
			return

		if (not file_path.endswith(tuple(self.kwargs['exclude_file_suffixes']))
		and index_key in ng.projects_index_cache
		and not [skip for skip in self.kwargs['exclude_dirs'] if os.path.normpath(skip) in file_path]):
			message.alert('Reindexing ' + self.kwargs['file_path'])
			project_index = ng.get_project_indexes_at(index_key)

			project_index[:] = [
				item for item in project_index
				if item[1] != file_path
			]

			_file = codecs.open(file_path)
			_lines = _file.readlines();
			_file.close()
			line_number = 1
			previous_matched_directive = ''

			for line in _lines:
				if previous_matched_directive != '':
					self.look_for_directive_attribute(line, previous_matched_directive)

				matches = self.get_definition_details(line, self.compile_patterns(self.kwargs['match_definitions']))
				if matches:
					for matched in matches:
						definition_name = matched[0] + ':  '
						definition_value = matched[1].group(int(self.kwargs['match_expression_group']))
						definition_name += definition_value
						project_index.append([definition_name, file_path, str(line_number)])
						if(matched[0] == 'directive'): previous_matched_directive = definition_value
						else: previous_matched_directive = '';
				line_number += 1
			ng.add_indexes_to_cache([project_index, self.attribute_dict])

	def parse_file(self, file_path, r, match_expressions):
		if (file_path.endswith(".js")
		and not file_path.endswith(tuple(self.kwargs['exclude_file_suffixes']))):
			_abs_file_path = os.path.join(r, file_path)
			_file = codecs.open(_abs_file_path)
			_lines = _file.readlines();
			_file.close()
			line_number = 1
			previous_matched_directive = ''

			for line in _lines:
				if previous_matched_directive != '':
					self.look_for_directive_attribute(line, previous_matched_directive)

				matches = self.get_definition_details(line, match_expressions)
				if matches:
					for matched in matches:
						definition_name = matched[0] + ':  '
						definition_value = matched[1].group(int(self.kwargs['match_expression_group']))
						definition_name += definition_value
						self.function_matches.append([definition_name, _abs_file_path, str(line_number)])
						if(matched[0] == 'directive'): previous_matched_directive = definition_value
						else: previous_matched_directive = '';
				line_number += 1

	def look_for_directive_attribute(self, line_content, directive):
		try:
			line_content = line_content.decode('utf8')
		except:
			return
		match = re.findall(r'(\w+.)[:\s]+[\'"](\=|@|&)[\'"]', line_content)
		if(match):
			directive = convert.definitionToDirective([directive])
			if directive not in self.attribute_dict:
				self.attribute_dict[directive] = []
			for attribute in match:
				normliazed_attribute = convert.definitionToDirective([attribute[0].replace(':','').strip()])
				self.attribute_dict[directive].append([normliazed_attribute, attribute[1]])

	def get_definition_details(self, line_content, match_expressions):
		matches = []
		for expression in match_expressions:
			 # [2:-1] removes b'' wrapping
			 # TODO: figure out a better way...
			matched = expression[1].search(repr(line_content)[2:-1])
			if matched:
				matches.append((expression[0], matched))
		return matches