Gecko [ www.utparral.edu.mx ]

Name	Size	Permission
__pycache__	[ DIR ]	drwxrwxr-x
appactivatable.py	3.98 KB	-rw-r--r--
completion.py	5.61 KB	-rw-r--r--
document.py	35.07 KB	-rw-r--r--
exporter.py	3.64 KB	-rw-r--r--
helper.py	5.68 KB	-rw-r--r--
importer.py	4.09 KB	-rw-r--r--
__init__.py	1.03 KB	-rw-r--r--
languagemanager.py	1.24 KB	-rw-r--r--
library.py	28.59 KB	-rw-r--r--
manager.py	36.99 KB	-rw-r--r--
parser.py	7.24 KB	-rw-r--r--
placeholder.py	20.57 KB	-rw-r--r--
shareddata.py	2.75 KB	-rw-r--r--
signals.py	2.42 KB	-rw-r--r--
singleton.py	1.13 KB	-rw-r--r--
snippet.py	12.08 KB	-rw-r--r--
substitutionparser.py	5.7 KB	-rw-r--r--
windowactivatable.py	5.56 KB	-rw-r--r--

Code Editor : snippet.py

#    Gedit snippets plugin
#    Copyright (C) 2005-2006  Jesse van den Kieboom <jesse@icecrew.nl>
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

from gi.repository import Gio, Gtk

import sys

from .placeholder import PlaceholderEnd, PlaceholderMirror, Placeholder, PlaceholderShell, PlaceholderEval, PlaceholderRegex, PlaceholderExpand
from .parser import Parser
from . import helper

class EvalUtilities:
    def __init__(self, view=None):
        self.view = view
        self._init_namespace()

def _init_namespace(self):
        self.namespace = {
            '__builtins__': __builtins__,
            'align': self.util_align,
            'readfile': self.util_readfile,
            'filesize': self.util_filesize
        }

def _real_len(self, s, tablen = 0):
        if tablen == 0:
            tablen = self.view.get_tab_width()

return len(s.expandtabs(tablen))

def _filename_to_uri(self, filename):
        gfile = Gio.file_new_for_path(filename)

return gfile.get_uri()

def util_readfile(self, filename):
        stream = Gio.file_new_for_path(filename).read()

if not stream:
            return ''

res = stream.read()
        stream.close()

return res

def util_filesize(self, filename):
        gfile = Gio.file_new_for_path(filename)
        info = gfile.query_info(Gio.FILE_ATTRIBUTE_STANDARD_SIZE)

if not info:
            return 0

return info.get_size()

def util_align(self, items):
        maxlen = []
        tablen = self.view.get_tab_width()

for row in range(0, len(items)):
            for col in range(0, len(items[row]) - 1):
                if row == 0:
                    maxlen.append(0)

items[row][col] += "\t"
                rl = self._real_len(items[row][col], tablen)

if (rl > maxlen[col]):
                    maxlen[col] = rl

result = ''

for row in range(0, len(items)):
            for col in range(0, len(items[row]) - 1):
                item = items[row][col]

result += item + ("\t" * int(((maxlen[col] - \
                        self._real_len(item, tablen)) / tablen)))

result += items[row][len(items[row]) - 1]

if row != len(items) - 1:
                result += "\n"

return result

class Snippet:
    def __init__(self, data, environ = {}):
        self.data = data
        self.environ = environ

def __getitem__(self, prop):
        return self.data[prop]

def __setitem__(self, prop, value):
        self.data[prop] = value

def accelerator_display(self):
        accel = self['accelerator']

if accel:
            keyval, mod = Gtk.accelerator_parse(accel)
            accel = Gtk.accelerator_get_label(keyval, mod)

return accel or ''

def display(self):
        nm = helper.markup_escape(self['description'])

tag = self['tag']
        accel = self.accelerator_display()
        detail = []

if tag and tag != '':
            detail.append(tag)

if accel and accel != '':
            detail.append(accel)

if not detail:
            return nm
        else:
            return nm + ' (<b>' + helper.markup_escape(', '.join(detail)) + \
                    '</b>)'

def _add_placeholder(self, placeholder):
        if placeholder.tabstop in self.placeholders:
            if placeholder.tabstop == -1:
                self.placeholders[-1].append(placeholder)
                self.plugin_data.ordered_placeholders.append(placeholder)
        elif placeholder.tabstop == -1:
            self.placeholders[-1] = [placeholder]
            self.plugin_data.ordered_placeholders.append(placeholder)
        else:
            self.placeholders[placeholder.tabstop] = placeholder
            self.plugin_data.ordered_placeholders.append(placeholder)

def _insert_text(self, text):
        # Insert text keeping indentation in mind
        indented = str.join('\n' + self._indent, helper.spaces_instead_of_tabs(self._view, text).split('\n'))
        self._view.get_buffer().insert(self._insert_iter(), indented)

def _insert_iter(self):
        return self._view.get_buffer().get_iter_at_mark(self._insert_mark)

def _create_environment(self, data):
        if data in self.environ['utf8']:
            val = self.environ['utf8'][data]
        else:
            val = ''

# Get all the current indentation
        all_indent = helper.compute_indentation(self._view, self._insert_iter())

# Substract initial indentation to get the snippet indentation
        indent = all_indent[len(self._indent):]

# Keep indentation
        return str.join('\n' + indent, val.split('\n'))

def _create_placeholder(self, data):
        tabstop = data['tabstop']
        begin = self._insert_iter()

if tabstop == 0:
            # End placeholder
            return PlaceholderEnd(self._view, self.environ, begin, data['default'])
        elif tabstop in self.placeholders:
            # Mirror placeholder
            return PlaceholderMirror(self._view, tabstop, self.environ, begin)
        else:
            # Default placeholder
            return Placeholder(self._view, tabstop, self.environ, data['default'], begin)

def _create_shell(self, data):
        begin = self._insert_iter()
        return PlaceholderShell(self._view, data['tabstop'], self.environ, begin, data['contents'])

def _create_eval(self, data):
        begin = self._insert_iter()
        return PlaceholderEval(self._view, data['tabstop'], self.environ, data['dependencies'], begin, data['contents'], self._utils.namespace)

def _create_regex(self, data):
        begin = self._insert_iter()
        return PlaceholderRegex(self._view, data['tabstop'], self.environ, begin, data['input'], data['pattern'], data['substitution'], data['modifiers'])

def _create_text(self, data):
        return data

def _invalid_placeholder(self, placeholder, remove):
        buf = self._view.get_buffer()

# Remove the text because this placeholder is invalid
        if placeholder.default and remove:
            buf.delete(placeholder.begin_iter(), placeholder.end_iter())

placeholder.remove()

if placeholder.tabstop == -1:
            index = self.placeholders[-1].index(placeholder)
            del self.placeholders[-1][index]
        else:
            del self.placeholders[placeholder.tabstop]

self.plugin_data.ordered_placeholders.remove(placeholder)

def _parse(self, plugin_data):
        # Initialize current variables
        self._view = plugin_data.view
        self._indent = helper.compute_indentation(self._view, self._view.get_buffer().get_iter_at_mark(self.begin_mark))
        self._utils = EvalUtilities(self._view)
        self.placeholders = {}
        self._insert_mark = self.end_mark
        self.plugin_data = plugin_data

# Create parser
        parser = Parser(data=self['text'])

# Parse tokens
        while (True):
            token = parser.token()

if not token:
                break

try:
                val = {'environment': self._create_environment,
                       'placeholder': self._create_placeholder,
                       'shell': self._create_shell,
                       'eval': self._create_eval,
                       'regex': self._create_regex,
                       'text': self._create_text}[token.klass](token.data)
            except KeyError:
                sys.stderr.write('Token class not supported: %s (%s)\n' % token.klass)
                continue

if isinstance(val, str):
                # Insert text
                self._insert_text(val)
            else:
                # Insert placeholder
                self._add_placeholder(val)

# Create end placeholder if there isn't one yet
        if 0 not in self.placeholders:
            self.placeholders[0] = PlaceholderEnd(self._view, self.environ, self.end_iter(), None)
            self.plugin_data.ordered_placeholders.append(self.placeholders[0])

# Make sure run_last is ran for all placeholders and remove any
        # non `ok` placeholders
        for tabstop in self.placeholders.copy():
            ph = (tabstop == -1 and list(self.placeholders[-1])) or [self.placeholders[tabstop]]

for placeholder in ph:
                placeholder.run_last(self.placeholders)

if not placeholder.ok or placeholder.done:
                    self._invalid_placeholder(placeholder, not placeholder.ok)

# Remove all the Expand placeholders which have a tabstop because
        # they can be used to mirror, but they shouldn't be real tabstops
        # (if they have mirrors installed). This is problably a bit of
        # a dirty hack :)
        if -1 not in self.placeholders:
            self.placeholders[-1] = []

for tabstop in self.placeholders.copy():
            placeholder = self.placeholders[tabstop]

if tabstop != -1:
                if isinstance(placeholder, PlaceholderExpand) and \
                   placeholder.has_references:
                    # Add to anonymous placeholders
                    self.placeholders[-1].append(placeholder)

# Remove placeholder
                    del self.placeholders[tabstop]

self.plugin_data = None

def insert_into(self, plugin_data, insert):
        buf = plugin_data.view.get_buffer()
        last_index = 0

# Find closest mark at current insertion, so that we may insert
        # our marks in the correct order
        (current, next) = plugin_data.next_placeholder()

if current:
            # Insert AFTER current
            last_index = plugin_data.placeholders.index(current) + 1
        elif next:
            # Insert BEFORE next
            last_index = plugin_data.placeholders.index(next)
        else:
            # Insert at first position
            last_index = 0

# lastIndex now contains the position of the last mark
        # Create snippet bounding marks
        self.begin_mark = buf.create_mark(None, insert, True)
        self.end_mark = buf.create_mark(None, insert, False)

# Now parse the contents of this snippet, create Placeholders
        # and insert the placholder marks in the marks array of plugin_data
        self._parse(plugin_data)

# So now all of the snippet is in the buffer, we have all our
        # placeholders right here, what's next, put all marks in the
        # plugin_data.marks
        k = sorted(self.placeholders.keys(), reverse=True)

plugin_data.placeholders.insert(last_index, self.placeholders[0])
        last_iter = self.placeholders[0].end_iter()

for tabstop in k:
            if tabstop != -1 and tabstop != 0:
                placeholder = self.placeholders[tabstop]
                end_iter = placeholder.end_iter()

if last_iter.compare(end_iter) < 0:
                    last_iter = end_iter

# Inserting placeholder
                plugin_data.placeholders.insert(last_index, placeholder)

# Move end mark to last placeholder
        buf.move_mark(self.end_mark, last_iter)

return self

def deactivate(self):
        buf = self.begin_mark.get_buffer()

buf.delete_mark(self.begin_mark)
        buf.delete_mark(self.end_mark)

self.placeholders = {}

def begin_iter(self):
        return self.begin_mark.get_buffer().get_iter_at_mark(self.begin_mark)

def end_iter(self):
        return self.end_mark.get_buffer().get_iter_at_mark(self.end_mark)

# ex:ts=4:et:

${this.title}

Code Editor : snippet.py