code stringlengths 1 1.72M | language stringclasses 1 value |
|---|---|
from core import convert, equals
from codes import * | Python |
#!/usr/bin/python
import os
from dcinstall import setup_py, debian, AbstractPackageInfo
from dcinstall.version import get_revisions, get_changelog_core, save_last_revision
class build(AbstractPackageInfo.build):
sources_dir = os.path.realpath(os.path.dirname(__file__))
build_dir = sources_dir
result_dir = sources_dir + '/dist'
last_revision, cur_revision = get_revisions(build)
class info(AbstractPackageInfo):
build = build
version = '1.1-SVN%d' % cur_revision
changelog_core = get_changelog_core(last_revision, cur_revision)
name = 'currencies'
deb_package_name = 'foreignsites-currencies'
maintainer = 'Maxim Oransky'
maintainer_email = 'maxim.oransky@gmail.com'
description = 'Library for work with currencies (load rates)'
url = 'http://code.google.com/p/foreignsites/'
deb_depends = [
'python (>= 2.4)',
]
license = 'GNU Lesser General Public License'
###################
# 1. Classic setup.py installer
setup_py.create(info, skipfiles='.*\.pyc|.*\.pyo|\.svn|\.sqlite')
os.system('python setup.py sdist --formats=gztar')
setup_py.clean()
###################
# 2. Debian package
debian.build_package(
info,
['dist/%s-%s.tar.gz' % (info.name, info.version)],
custom_deb_templates = {
'postinst': '%s/postinst.template' % build.build_dir,
},
)
os.system('mv %s*deb %s' % (info.deb_package_name, build.result_dir))
# on sucess save mark current revision as "last builded"
save_last_revision(build, cur_revision) | Python |
#====================================================================
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# ====================================================================
#
# This software consists of voluntary contributions made by many
# individuals on behalf of the Apache Software Foundation. For more
# information on the Apache Software Foundation, please see
# <http://www.apache.org/>.
#
import os
import re
import tempfile
import shutil
ignore_pattern = re.compile('^(.svn|target|bin|classes)')
java_pattern = re.compile('^.*\.java')
annot_pattern = re.compile('import org\.apache\.http\.annotation\.')
def process_dir(dir):
files = os.listdir(dir)
for file in files:
f = os.path.join(dir, file)
if os.path.isdir(f):
if not ignore_pattern.match(file):
process_dir(f)
else:
if java_pattern.match(file):
process_source(f)
def process_source(filename):
tmp = tempfile.mkstemp()
tmpfd = tmp[0]
tmpfile = tmp[1]
try:
changed = False
dst = os.fdopen(tmpfd, 'w')
try:
src = open(filename)
try:
for line in src:
if annot_pattern.match(line):
changed = True
line = line.replace('import org.apache.http.annotation.', 'import net.jcip.annotations.')
dst.write(line)
finally:
src.close()
finally:
dst.close();
if changed:
shutil.move(tmpfile, filename)
else:
os.remove(tmpfile)
except:
os.remove(tmpfile)
process_dir('.')
| Python |
VERSION="0.3.22"
| Python |
#!/usr/bin/env python2
# vim: set et sw=4:
"""agi
This module contains functions and classes to implment AGI scripts in python.
pyvr
{'agi_callerid' : 'mars.putland.int',
'agi_channel' : 'IAX[kputland@kputland]/119',
'agi_context' : 'default',
'agi_dnid' : '666',
'agi_enhanced' : '0.0',
'agi_extension': '666',
'agi_language' : 'en',
'agi_priority' : '1',
'agi_rdnis' : '',
'agi_request' : 'pyst',
'agi_type' : 'IAX'}
"""
import sys, pprint, re
from types import ListType
import signal
DEFAULT_TIMEOUT = 2000 # 2sec timeout used as default for functions that take timeouts
DEFAULT_RECORD = 20000 # 20sec record time
re_code = re.compile(r'(^\d*)\s*(.*)')
re_kv = re.compile(r'(?P<key>\w+)=(?P<value>[^\s]+)\s*(?:\((?P<data>.*)\))*')
class AGIException(Exception): pass
class AGIError(AGIException): pass
class AGIUnknownError(AGIError): pass
class AGIAppError(AGIError): pass
# there are several different types of hangups we can detect
# they all are derrived from AGIHangup
class AGIHangup(AGIAppError): pass
class AGISIGHUPHangup(AGIHangup): pass
class AGISIGPIPEHangup(AGIHangup): pass
class AGIResultHangup(AGIHangup): pass
class AGIDBError(AGIAppError): pass
class AGIUsageError(AGIError): pass
class AGIInvalidCommand(AGIError): pass
class AGI:
"""
This class encapsulates communication between Asterisk an a python script.
It handles encoding commands to Asterisk and parsing responses from
Asterisk.
"""
def __init__(self):
self._got_sighup = False
signal.signal(signal.SIGHUP, self._handle_sighup) # handle SIGHUP
sys.stderr.write('ARGS: ')
sys.stderr.write(str(sys.argv))
sys.stderr.write('\n')
self.env = {}
self._get_agi_env()
def _get_agi_env(self):
while 1:
line = sys.stdin.readline().strip()
sys.stderr.write('ENV LINE: ')
sys.stderr.write(line)
sys.stderr.write('\n')
if line == '':
#blank line signals end
break
key,data = line.split(':')[0], ':'.join(line.split(':')[1:])
key = key.strip()
data = data.strip()
if key <> '':
self.env[key] = data
sys.stderr.write('class AGI: self.env = ')
sys.stderr.write(pprint.pformat(self.env))
sys.stderr.write('\n')
def _quote(self, string):
return ''.join(['"', str(string), '"'])
def _handle_sighup(self, signum, frame):
"""Handle the SIGHUP signal"""
self._got_sighup = True
def test_hangup(self):
"""This function throws AGIHangup if we have recieved a SIGHUP"""
if self._got_sighup:
raise AGISIGHUPHangup("Received SIGHUP from Asterisk")
def execute(self, command, *args):
self.test_hangup()
try:
self.send_command(command, *args)
return self.get_result()
except IOError,e:
if e.errno == 32:
# Broken Pipe * let us go
raise AGISIGPIPEHangup("Received SIGPIPE")
else:
raise
def send_command(self, command, *args):
"""Send a command to Asterisk"""
command = command.strip()
command = '%s %s' % (command, ' '.join(map(str,args)))
command = command.strip()
if command[-1] != '\n':
command += '\n'
sys.stderr.write(' COMMAND: %s' % command)
sys.stdout.write(command)
sys.stdout.flush()
def get_result(self, stdin=sys.stdin):
"""Read the result of a command from Asterisk"""
code = 0
result = {'result':('','')}
line = stdin.readline().strip()
sys.stderr.write(' RESULT_LINE: %s\n' % line)
m = re_code.search(line)
if m:
code, response = m.groups()
code = int(code)
if code == 200:
for key,value,data in re_kv.findall(response):
result[key] = (value, data)
# If user hangs up... we get 'hangup' in the data
if data == 'hangup':
raise AGIResultHangup("User hungup during execution")
if key == 'result' and value == '-1':
raise AGIAppError("Error executing application, or hangup")
sys.stderr.write(' RESULT_DICT: %s\n' % pprint.pformat(result))
return result
elif code == 510:
raise AGIInvalidCommand(response)
elif code == 520:
usage = [line]
line = stdin.readline().strip()
while line[:3] != '520':
usage.append(line)
line = stdin.readline().strip()
usage.append(line)
usage = '%s\n' % '\n'.join(usage)
raise AGIUsageError(usage)
else:
raise AGIUnknownError(code, 'Unhandled code or undefined response')
def _process_digit_list(self, digits):
if type(digits) == ListType:
digits = ''.join(map(str, digits))
return self._quote(digits)
def answer(self):
"""agi.answer() --> None
Answer channel if not already in answer state.
"""
self.execute('ANSWER')['result'][0]
def wait_for_digit(self, timeout=DEFAULT_TIMEOUT):
"""agi.wait_for_digit(timeout=DEFAULT_TIMEOUT) --> digit
Waits for up to 'timeout' milliseconds for a channel to receive a DTMF
digit. Returns digit dialed
Throws AGIError on channel falure
"""
res = self.execute('WAIT FOR DIGIT', timeout)['result'][0]
if res == '0':
return ''
else:
try:
return chr(int(res))
except ValueError:
raise AGIError('Unable to convert result to digit: %s' % res)
def send_text(self, text=''):
"""agi.send_text(text='') --> None
Sends the given text on a channel. Most channels do not support the
transmission of text.
Throws AGIError on error/hangup
"""
self.execute('SEND TEXT', self._quote(text))['result'][0]
def receive_char(self, timeout=DEFAULT_TIMEOUT):
"""agi.receive_char(timeout=DEFAULT_TIMEOUT) --> chr
Receives a character of text on a channel. Specify timeout to be the
maximum time to wait for input in milliseconds, or 0 for infinite. Most channels
do not support the reception of text.
"""
res = self.execute('RECEIVE CHAR', timeout)['result'][0]
if res == '0':
return ''
else:
try:
return chr(int(res))
except:
raise AGIError('Unable to convert result to char: %s' % res)
def tdd_mode(self, mode='off'):
"""agi.tdd_mode(mode='on'|'off') --> None
Enable/Disable TDD transmission/reception on a channel.
Throws AGIAppError if channel is not TDD-capable.
"""
res = self.execute('TDD MODE', mode)['result'][0]
if res == '0':
raise AGIAppError('Channel %s is not TDD-capable')
def stream_file(self, filename, escape_digits='', sample_offset=0):
"""agi.stream_file(filename, escape_digits='', sample_offset=0) --> digit
Send the given file, allowing playback to be interrupted by the given
digits, if any. escape_digits is a string '12345' or a list of
ints [1,2,3,4,5] or strings ['1','2','3'] or mixed [1,'2',3,'4']
If sample offset is provided then the audio will seek to sample
offset before play starts. Returns digit if one was pressed.
Throws AGIError if the channel was disconnected. Remember, the file
extension must not be included in the filename.
"""
escape_digits = self._process_digit_list(escape_digits)
response = self.execute('STREAM FILE', filename, escape_digits, sample_offset)
res = response['result'][0]
if res == '0':
return ''
else:
try:
return chr(int(res))
except:
raise AGIError('Unable to convert result to char: %s' % res)
def control_stream_file(self, filename, escape_digits='', skipms=3000, fwd='', rew='', pause=''):
"""
Send the given file, allowing playback to be interrupted by the given
digits, if any. escape_digits is a string '12345' or a list of
ints [1,2,3,4,5] or strings ['1','2','3'] or mixed [1,'2',3,'4']
If sample offset is provided then the audio will seek to sample
offset before play starts. Returns digit if one was pressed.
Throws AGIError if the channel was disconnected. Remember, the file
extension must not be included in the filename.
"""
escape_digits = self._process_digit_list(escape_digits)
response = self.execute('CONTROL STREAM FILE', self._quote(filename), escape_digits, self._quote(skipms), self._quote(fwd), self._quote(rew), self._quote(pause))
res = response['result'][0]
if res == '0':
return ''
else:
try:
return chr(int(res))
except:
raise AGIError('Unable to convert result to char: %s' % res)
def send_image(self, filename):
"""agi.send_image(filename) --> None
Sends the given image on a channel. Most channels do not support the
transmission of images. Image names should not include extensions.
Throws AGIError on channel failure
"""
res = self.execute('SEND IMAGE', filename)['result'][0]
if res != '0':
raise AGIAppError('Channel falure on channel %s' % self.env.get('agi_channel','UNKNOWN'))
def say_digits(self, digits, escape_digits=''):
"""agi.say_digits(digits, escape_digits='') --> digit
Say a given digit string, returning early if any of the given DTMF digits
are received on the channel.
Throws AGIError on channel failure
"""
digits = self._process_digit_list(digits)
escape_digits = self._process_digit_list(escape_digits)
res = self.execute('SAY DIGITS', digits, escape_digits)['result'][0]
if res == '0':
return ''
else:
try:
return chr(int(res))
except:
raise AGIError('Unable to convert result to char: %s' % res)
def say_number(self, number, escape_digits=''):
"""agi.say_number(number, escape_digits='') --> digit
Say a given digit string, returning early if any of the given DTMF digits
are received on the channel.
Throws AGIError on channel failure
"""
number = self._process_digit_list(number)
escape_digits = self._process_digit_list(escape_digits)
res = self.execute('SAY NUMBER', number, escape_digits)['result'][0]
if res == '0':
return ''
else:
try:
return chr(int(res))
except:
raise AGIError('Unable to convert result to char: %s' % res)
def say_alpha(self, characters, escape_digits=''):
"""agi.say_alpha(string, escape_digits='') --> digit
Say a given character string, returning early if any of the given DTMF
digits are received on the channel.
Throws AGIError on channel failure
"""
characters = self._process_digit_list(characters)
escape_digits = self._process_digit_list(escape_digits)
res = self.execute('SAY ALPHA', characters, escape_digits)['result'][0]
if res == '0':
return ''
else:
try:
return chr(int(res))
except:
raise AGIError('Unable to convert result to char: %s' % res)
def say_phonetic(self, characters, escape_digits=''):
"""agi.say_phonetic(string, escape_digits='') --> digit
Phonetically say a given character string, returning early if any of
the given DTMF digits are received on the channel.
Throws AGIError on channel failure
"""
characters = self._process_digit_list(characters)
escape_digits = self._process_digit_list(escape_digits)
res = self.execute('SAY PHONETIC', characters, escape_digits)['result'][0]
if res == '0':
return ''
else:
try:
return chr(int(res))
except:
raise AGIError('Unable to convert result to char: %s' % res)
def say_date(self, seconds, escape_digits=''):
"""agi.say_date(seconds, escape_digits='') --> digit
Say a given date, returning early if any of the given DTMF digits are
pressed. The date should be in seconds since the UNIX Epoch (Jan 1, 1970 00:00:00)
"""
escape_digits = self._process_digit_list(escape_digits)
res = self.execute('SAY DATE', seconds, escape_digits)['result'][0]
if res == '0':
return ''
else:
try:
return chr(int(res))
except:
raise AGIError('Unable to convert result to char: %s' % res)
def say_time(self, seconds, escape_digits=''):
"""agi.say_time(seconds, escape_digits='') --> digit
Say a given time, returning early if any of the given DTMF digits are
pressed. The time should be in seconds since the UNIX Epoch (Jan 1, 1970 00:00:00)
"""
escape_digits = self._process_digit_list(escape_digits)
res = self.execute('SAY TIME', seconds, escape_digits)['result'][0]
if res == '0':
return ''
else:
try:
return chr(int(res))
except:
raise AGIError('Unable to convert result to char: %s' % res)
def say_datetime(self, seconds, escape_digits='', format='', zone=''):
"""agi.say_datetime(seconds, escape_digits='', format='', zone='') --> digit
Say a given date in the format specfied (see voicemail.conf), returning
early if any of the given DTMF digits are pressed. The date should be
in seconds since the UNIX Epoch (Jan 1, 1970 00:00:00).
"""
escape_digits = self._process_digit_list(escape_digits)
if format: format = self._quote(format)
res = self.execute('SAY DATETIME', seconds, escape_digits, format, zone)['result'][0]
if res == '0':
return ''
else:
try:
return chr(int(res))
except:
raise AGIError('Unable to convert result to char: %s' % res)
def get_data(self, filename, timeout=DEFAULT_TIMEOUT, max_digits=255):
"""agi.get_data(filename, timeout=DEFAULT_TIMEOUT, max_digits=255) --> digits
Stream the given file and receive dialed digits
"""
result = self.execute('GET DATA', filename, timeout, max_digits)
res, value = result['result']
return res
def get_option(self, filename, escape_digits='', timeout=0):
"""agi.get_option(filename, escape_digits='', timeout=0) --> digit
Send the given file, allowing playback to be interrupted by the given
digits, if any. escape_digits is a string '12345' or a list of
ints [1,2,3,4,5] or strings ['1','2','3'] or mixed [1,'2',3,'4']
Returns digit if one was pressed.
Throws AGIError if the channel was disconnected. Remember, the file
extension must not be included in the filename.
"""
escape_digits = self._process_digit_list(escape_digits)
if timeout:
response = self.execute('GET OPTION', filename, escape_digits, timeout)
else:
response = self.execute('GET OPTION', filename, escape_digits)
res = response['result'][0]
if res == '0':
return ''
else:
try:
return chr(int(res))
except:
raise AGIError('Unable to convert result to char: %s' % res)
def set_context(self, context):
"""agi.set_context(context)
Sets the context for continuation upon exiting the application.
No error appears to be produced. Does not set exten or priority
Use at your own risk. Ensure that you specify a valid context.
"""
self.execute('SET CONTEXT', context)
def set_extension(self, extension):
"""agi.set_extension(extension)
Sets the extension for continuation upon exiting the application.
No error appears to be produced. Does not set context or priority
Use at your own risk. Ensure that you specify a valid extension.
"""
self.execute('SET EXTENSION', extension)
def set_priority(self, priority):
"""agi.set_priority(priority)
Sets the priority for continuation upon exiting the application.
No error appears to be produced. Does not set exten or context
Use at your own risk. Ensure that you specify a valid priority.
"""
self.execute('set priority', priority)
def goto_on_exit(self, context='', extension='', priority=''):
context = context or self.env['agi_context']
extension = extension or self.env['agi_extension']
priority = priority or self.env['agi_priority']
self.set_context(context)
self.set_extension(extension)
self.set_priority(priority)
def record_file(self, filename, format='gsm', escape_digits='#', timeout=DEFAULT_RECORD, offset=0, beep='beep'):
"""agi.record_file(filename, format, escape_digits, timeout=DEFAULT_TIMEOUT, offset=0, beep='beep') --> None
Record to a file until a given dtmf digit in the sequence is received
The format will specify what kind of file will be recorded. The timeout
is the maximum record time in milliseconds, or -1 for no timeout. Offset
samples is optional, and if provided will seek to the offset without
exceeding the end of the file
"""
escape_digits = self._process_digit_list(escape_digits)
res = self.execute('RECORD FILE', self._quote(filename), format, escape_digits, timeout, offset, beep)['result'][0]
try:
return chr(int(res))
except:
raise AGIError('Unable to convert result to digit: %s' % res)
def set_autohangup(self, secs):
"""agi.set_autohangup(secs) --> None
Cause the channel to automatically hangup at <secs> seconds in the
future. Of course it can be hungup before then as well. Setting to
0 will cause the autohangup feature to be disabled on this channel.
"""
self.execute('SET AUTOHANGUP', secs)
def hangup(self, channel=''):
"""agi.hangup(channel='')
Hangs up the specified channel.
If no channel name is given, hangs up the current channel
"""
self.execute('HANGUP', channel)
def appexec(self, application, options=''):
"""agi.appexec(application, options='')
Executes <application> with given <options>.
Returns whatever the application returns, or -2 on failure to find
application
"""
result = self.execute('EXEC', application, self._quote(options))
res = result['result'][0]
if res == '-2':
raise AGIAppError('Unable to find application: %s' % application)
return res
def set_callerid(self, number):
"""agi.set_callerid(number) --> None
Changes the callerid of the current channel.
"""
self.execute('SET CALLERID', number)
def channel_status(self, channel=''):
"""agi.channel_status(channel='') --> int
Returns the status of the specified channel. If no channel name is
given the returns the status of the current channel.
Return values:
0 Channel is down and available
1 Channel is down, but reserved
2 Channel is off hook
3 Digits (or equivalent) have been dialed
4 Line is ringing
5 Remote end is ringing
6 Line is up
7 Line is busy
"""
try:
result = self.execute('CHANNEL STATUS', channel)
except AGIHangup:
raise
except AGIAppError:
result = {'result': ('-1','')}
return int(result['result'][0])
def set_variable(self, name, value):
"""Set a channel variable.
"""
self.execute('SET VARIABLE', self._quote(name), self._quote(value))
def get_variable(self, name):
"""Get a channel variable.
This function returns the value of the indicated channel variable. If
the variable is not set, an empty string is returned.
"""
try:
result = self.execute('GET VARIABLE', self._quote(name))
except AGIResultHangup:
result = {'result': ('1', 'hangup')}
res, value = result['result']
return value
def get_full_variable(self, name, channel = None):
"""Get a channel variable.
This function returns the value of the indicated channel variable. If
the variable is not set, an empty string is returned.
"""
try:
if channel:
result = self.execute('GET FULL VARIABLE', self._quote(name), self._quote(channel))
else:
result = self.execute('GET FULL VARIABLE', self._quote(name))
except AGIResultHangup:
result = {'result': ('1', 'hangup')}
res, value = result['result']
return value
def verbose(self, message, level=1):
"""agi.verbose(message='', level=1) --> None
Sends <message> to the console via verbose message system.
<level> is the the verbose level (1-4)
"""
self.execute('VERBOSE', self._quote(message), level)
def database_get(self, family, key):
"""agi.database_get(family, key) --> str
Retrieves an entry in the Asterisk database for a given family and key.
Returns 0 if <key> is not set. Returns 1 if <key>
is set and returns the variable in parenthesis
example return code: 200 result=1 (testvariable)
"""
family = '"%s"' % family
key = '"%s"' % key
result = self.execute('DATABASE GET', self._quote(family), self._quote(key))
res, value = result['result']
if res == '0':
raise AGIDBError('Key not found in database: family=%s, key=%s' % (family, key))
elif res == '1':
return value
else:
raise AGIError('Unknown exception for : family=%s, key=%s, result=%s' % (family, key, pprint.pformat(result)))
def database_put(self, family, key, value):
"""agi.database_put(family, key, value) --> None
Adds or updates an entry in the Asterisk database for a
given family, key, and value.
"""
result = self.execute('DATABASE PUT', self._quote(family), self._quote(key), self._quote(value))
res, value = result['result']
if res == '0':
raise AGIDBError('Unable to put vaule in databale: family=%s, key=%s, value=%s' % (family, key, value))
def database_del(self, family, key):
"""agi.database_del(family, key) --> None
Deletes an entry in the Asterisk database for a
given family and key.
"""
result = self.execute('DATABASE DEL', self._quote(family), self._quote(key))
res, value = result['result']
if res == '0':
raise AGIDBError('Unable to delete from database: family=%s, key=%s' % (family, key))
def database_deltree(self, family, key=''):
"""agi.database_deltree(family, key='') --> None
Deletes a family or specific keytree with in a family
in the Asterisk database.
"""
result = self.execute('DATABASE DELTREE', self._quote(family), self._quote(key))
res, value = result['result']
if res == '0':
raise AGIDBError('Unable to delete tree from database: family=%s, key=%s' % (family, key))
def noop(self):
"""agi.noop() --> None
Does nothing
"""
self.execute('NOOP')
if __name__=='__main__':
agi = AGI()
#agi.appexec('festival','Welcome to Klass Technologies. Thank you for calling.')
#agi.appexec('festival','This is a test of the text to speech engine.')
#agi.appexec('festival','Press 1 for sales ')
#agi.appexec('festival','Press 2 for customer support ')
#agi.hangup()
#agi.goto_on_exit(extension='1234', priority='1')
#sys.exit(0)
#agi.say_digits('123', [4,'5',6])
#agi.say_digits([4,5,6])
#agi.say_number('1234')
#agi.say_number('01234') # 668
#agi.say_number('0xf5') # 245
agi.get_data('demo-congrats')
agi.hangup()
sys.exit(0)
#agi.record_file('pyst-test') #FAILS
#agi.stream_file('demo-congrats', [1,2,3,4,5,6,7,8,9,0,'#','*'])
#agi.appexec('background','demo-congrats')
try:
agi.appexec('backgrounder','demo-congrats')
except AGIAppError:
sys.stderr.write("Handled exception for missing application backgrounder\n")
agi.set_variable('foo','bar')
agi.get_variable('foo')
try:
agi.get_variable('foobar')
except AGIAppError:
sys.stderr.write("Handled exception for missing variable foobar\n")
try:
agi.database_put('foo', 'bar', 'foobar')
agi.database_put('foo', 'baz', 'foobaz')
agi.database_put('foo', 'bat', 'foobat')
v = agi.database_get('foo', 'bar')
sys.stderr.write('DBVALUE foo:bar = %s\n' % v)
v = agi.database_get('bar', 'foo')
sys.stderr.write('DBVALUE foo:bar = %s\n' % v)
agi.database_del('foo', 'bar')
agi.database_deltree('foo')
except AGIDBError:
sys.stderr.write("Handled exception for missing database entry bar:foo\n")
agi.hangup()
| Python |
#!/usr/bin/env python
# vim: set expandtab:
"""
Parse Asterisk configuration files.
This module provides parsing functionality for asterisk config files.
import asterisk.config
import sys
# load and parse the config file
try:
config = asterisk.config.Config('/etc/asterisk/extensions.conf')
except asterisk.config.ParseError, (line, reason):
print "Parse Error line: %s: %s" % (line, reason)
sys.exit(1)
except IOError, reason:
print "Error opening file: %s" % reason
sys.exit(1)
# print our parsed output
for category in config.categories:
print '[%s]' % category.name # print the current category
for item in category.items:
print ' %s = %s' % (item.name, item.value)
"""
import sys
class ParseError(Exception): pass
class Line(object):
def __init__(self, line, number):
self.line = ''
self.comment = ''
line = line.strip() # I guess we don't preserve indentation
self.number = number
parts = line.split(';')
if len(parts) >= 2:
self.line = parts[0].strip()
self.comment = ';'.join(parts[1:]) #Just in case the comment contained ';'
else:
self.line = line
def __str__(self):
return self.get_line()
def get_line(self):
if self.comment and self.line:
return '%s\t;%s' % (self.line, self.comment)
elif self.comment and not self.line:
return ';%s' % self.comment
return self.line
class Category(Line):
def __init__(self, line='', num=-1, name=None):
Line.__init__(self, line, num)
if self.line:
if (self.line[0] != '[' or self.line[-1] != ']'):
raise ParseError(self.number, "Missing '[' or ']' in category definition")
self.name = self.line[1:-1]
elif name:
self.name = name
else:
raise Exception("Must provide name or line representing a category")
self.items = []
self.comments = []
def get_line(self):
if self.comment:
return '[%s]\t;%s' % (self.name, self.comment)
return '[%s]' % self.name
def append(self, item):
self.items.append(item)
def insert(self, index, item):
self.items.insert(index, item)
def pop(self, index=-1):
self.items.pop(index)
def remove(self, item):
self.items.remove(item)
class Item(Line):
def __init__(self, line='', num=-1, name=None, value=None):
Line.__init__(self, line, num)
self.style = ''
if self.line:
self.parse()
elif (name and value):
self.name = name
self.value = value
else:
raise Exception("Must provide name or value representing an item")
def parse(self):
try:
name, value = self.line.split('=', 1)
except ValueError:
if self.line.strip()[-1] == ']':
raise ParseError(self.number, "Category name missing '['")
else:
raise ParseError(self.number, "Item must be in name = value pairs")
if value and value[0] == '>':
self.style = '>' #preserve the style of the original
value = value[1:].strip()
self.name = name.strip()
self.value = value
def get_line(self):
if self.comment:
return '%s =%s %s\t;%s' % (self.name, self.style, self.value, self.comment)
return '%s =%s %s' % (self.name, self.style, self.value)
class Config(object):
def __init__(self, filename):
self.filename = filename
self.raw_lines = [] # Holds the raw strings
self.lines = [] # Holds things in order
self.categories = []
# load and parse the file
self.load()
self.parse()
def load(self):
self.raw_lines = open(self.filename).readlines()
#try:
#self.raw_lines = open(self.filename).readlines()
#except IOError:
#sys.stderr.write('WARNING: error opening filename: %s No data read. Starting new file?' % self.filename)
#self.raw_lines = []
def parse(self):
cat = None
num = 0
for line in self.raw_lines:
num += 1
line = line.strip()
if not line or line[0] == ';':
item = Line(line or '', num)
self.lines.append(item)
if cat: cat.comments.append(item)
continue
elif line[0] == '[':
cat = Category(line, num)
self.lines.append(cat)
self.categories.append(cat)
continue
else:
item = Item(line, num)
self.lines.append(item)
if cat: cat.append(item)
continue
| Python |
""" pyst - A set of interfaces and libraries to allow programming of asterisk from python.
The pyst project includes several python modules to assist in programming
asterisk with python:
agi - python wrapper for agi
agitb - a module to assist in agi debugging, like cgitb
config - a module for parsing asterisk config files
manager - a module for interacting with the asterisk manager interface
"""
__all__ = ['agi', 'agitb', 'config', 'manager']
| Python |
"""More comprehensive traceback formatting for Python scripts.
To enable this module, do:
import asterisk.agitb, asterisk.agi
asterisk.agitb.enable(display = False, logdir = '/var/log/asterisk/')
agi = asterisk.agi.AGI()
asterisk.agitb.enable(agi, False, '/var/log/asterisk')
at the top of your script. The optional arguments to enable() are:
agi - the agi handle to write verbose messages to
display - if true, tracebacks are displayed on the asterisk console
(used with the agi option)
logdir - if set, tracebacks are written to files in this directory
context - number of lines of source code to show for each stack frame
By default, tracebacks are displayed but not saved, and the context is 5 lines.
You may want to add a logdir if you call agitb.enable() before you have
an agi.AGI() handle.
Alternatively, if you have caught an exception and want agitb to display it
for you, call agitb.handler(). The optional argument to handler() is a
3-item tuple (etype, evalue, etb) just like the value of sys.exc_info().
If you do not pass anything to handler() it will use sys.exc_info().
This script was adapted from Ka-Ping Yee's cgitb.
"""
__author__ = 'Matthew Nicholson'
__version__ = '0.1.0'
import sys
__UNDEF__ = [] # a special sentinel object
def lookup(name, frame, locals):
"""Find the value for a given name in the given environment."""
if name in locals:
return 'local', locals[name]
if name in frame.f_globals:
return 'global', frame.f_globals[name]
if '__builtins__' in frame.f_globals:
builtins = frame.f_globals['__builtins__']
if type(builtins) is type({}):
if name in builtins:
return 'builtin', builtins[name]
else:
if hasattr(builtins, name):
return 'builtin', getattr(builtins, name)
return None, __UNDEF__
def scanvars(reader, frame, locals):
"""Scan one logical line of Python and look up values of variables used."""
import tokenize, keyword
vars, lasttoken, parent, prefix, value = [], None, None, '', __UNDEF__
for ttype, token, start, end, line in tokenize.generate_tokens(reader):
if ttype == tokenize.NEWLINE: break
if ttype == tokenize.NAME and token not in keyword.kwlist:
if lasttoken == '.':
if parent is not __UNDEF__:
value = getattr(parent, token, __UNDEF__)
vars.append((prefix + token, prefix, value))
else:
where, value = lookup(token, frame, locals)
vars.append((token, where, value))
elif token == '.':
prefix += lasttoken + '.'
parent = value
else:
parent, prefix = None, ''
lasttoken = token
return vars
def text((etype, evalue, etb), context=5):
"""Return a plain text document describing a given traceback."""
import os, types, time, traceback, linecache, inspect, pydoc
if type(etype) is types.ClassType:
etype = etype.__name__
pyver = 'Python ' + sys.version.split()[0] + ': ' + sys.executable
date = time.ctime(time.time())
head = "%s\n%s\n%s\n" % (str(etype), pyver, date) + '''
A problem occurred in a Python script. Here is the sequence of
function calls leading up to the error, in the order they occurred.
'''
frames = []
records = inspect.getinnerframes(etb, context)
for frame, file, lnum, func, lines, index in records:
file = file and os.path.abspath(file) or '?'
args, varargs, varkw, locals = inspect.getargvalues(frame)
call = ''
if func != '?':
call = 'in ' + func + \
inspect.formatargvalues(args, varargs, varkw, locals,
formatvalue=lambda value: '=' + pydoc.text.repr(value))
highlight = {}
def reader(lnum=[lnum]):
highlight[lnum[0]] = 1
try: return linecache.getline(file, lnum[0])
finally: lnum[0] += 1
vars = scanvars(reader, frame, locals)
rows = [' %s %s' % (file, call)]
if index is not None:
i = lnum - index
for line in lines:
num = '%5d ' % i
rows.append(num+line.rstrip())
i += 1
done, dump = {}, []
for name, where, value in vars:
if name in done: continue
done[name] = 1
if value is not __UNDEF__:
if where == 'global': name = 'global ' + name
elif where == 'local': name = name
else: name = where + name.split('.')[-1]
dump.append('%s = %s' % (name, pydoc.text.repr(value)))
else:
dump.append(name + ' undefined')
rows.append('\n'.join(dump))
frames.append('\n%s\n' % '\n'.join(rows))
exception = ['%s: %s' % (str(etype), str(evalue))]
if type(evalue) is types.InstanceType:
for name in dir(evalue):
value = pydoc.text.repr(getattr(evalue, name))
exception.append('\n%s%s = %s' % (" "*4, name, value))
import traceback
return head + ''.join(frames) + ''.join(exception) + '''
The above is a description of an error in a Python program. Here is
the original traceback:
%s
''' % ''.join(traceback.format_exception(etype, evalue, etb))
class Hook:
"""A hook to replace sys.excepthook that shows tracebacks in HTML."""
def __init__(self, display=1, logdir=None, context=5, file=None,
agi=None):
self.display = display # send tracebacks to browser if true
self.logdir = logdir # log tracebacks to files if not None
self.context = context # number of source code lines per frame
self.file = file or sys.stderr # place to send the output
self.agi = agi
def __call__(self, etype, evalue, etb):
self.handle((etype, evalue, etb))
def handle(self, info=None):
info = info or sys.exc_info()
try:
doc = text(info, self.context)
except: # just in case something goes wrong
import traceback
doc = ''.join(traceback.format_exception(*info))
if self.display:
if self.agi: # print to agi
for line in doc.split('\n'):
self.agi.verbose(line, 4)
else:
self.file.write(doc + '\n')
if self.agi:
self.agi.verbose('A problem occured in a python script', 4)
else:
self.file.write('A problem occured in a python script\n')
if self.logdir is not None:
import os, tempfile
(fd, path) = tempfile.mkstemp(suffix='.txt', dir=self.logdir)
try:
file = os.fdopen(fd, 'w')
file.write(doc)
file.close()
msg = '%s contains the description of this error.' % path
except:
msg = 'Tried to save traceback to %s, but failed.' % path
if self.agi:
self.agi.verbose(msg, 4)
else:
self.file.write(msg + '\n')
try:
self.file.flush()
except: pass
handler = Hook().handle
def enable(agi=None, display=1, logdir=None, context=5):
"""Install an exception handler that formats tracebacks as HTML.
The optional argument 'display' can be set to 0 to suppress sending the
traceback to the browser, and 'logdir' can be set to a directory to cause
tracebacks to be written to files there."""
except_hook = Hook(display=display, logdir=logdir,
context=context, agi=agi)
sys.excepthook = except_hook
global handler
handler = except_hook.handle
| Python |
#!/usr/bin/env python
# vim: set expandtab shiftwidth=4:
"""
Python Interface for Asterisk Manager
This module provides a Python API for interfacing with the asterisk manager.
import asterisk.manager
import sys
def handle_shutdown(event, manager):
print "Recieved shutdown event"
manager.close()
# we could analize the event and reconnect here
def handle_event(event, manager):
print "Recieved event: %s" % event.name
manager = asterisk.manager.Manager()
try:
# connect to the manager
try:
manager.connect('host')
manager.login('user', 'secret')
# register some callbacks
manager.register_event('Shutdown', handle_shutdown) # shutdown
manager.register_event('*', handle_event) # catch all
# get a status report
response = manager.status()
manager.logoff()
except asterisk.manager.ManagerSocketException, (errno, reason):
print "Error connecting to the manager: %s" % reason
sys.exit(1)
except asterisk.manager.ManagerAuthException, reason:
print "Error logging in to the manager: %s" % reason
sys.exit(1)
except asterisk.manager.ManagerException, reason:
print "Error: %s" % reason
sys.exit(1)
finally:
# remember to clean up
manager.close()
Remember all header, response, and event names are case sensitive.
Not all manager actions are implmented as of yet, feel free to add them
and submit patches.
"""
import sys,os
import socket
import threading
import Queue
import re
from cStringIO import StringIO
from types import *
from time import sleep
EOL = '\r\n'
class ManagerMsg(object):
"""A manager interface message"""
def __init__(self, response):
# the raw response, straight from the horse's mouth:
self.response = response
self.data = ''
self.headers = {}
# parse the response
self.parse(response)
# This is an unknown message, may happen if a command (notably
# 'dialplan show something') contains a \n\r\n sequence in the
# middle of output. We hope this happens only *once* during a
# misbehaved command *and* the command ends with --END COMMAND--
# in that case we return an Event. Otherwise we asume it is
# from a misbehaving command not returning a proper header (e.g.
# IAXnetstats in Asterisk 1.4.X)
# A better solution is probably to retain some knowledge of
# commands sent and their expected return syntax. In that case
# we could wait for --END COMMAND-- for 'command'.
# B0rken in asterisk. This should be parseable without context.
if 'Event' not in self.headers and 'Response' not in self.headers:
# there are commands that return the ActionID but not
# 'Response', e.g., IAXpeers in Asterisk 1.4.X
if self.has_header('ActionID'):
self.headers['Response'] = 'Generated Header'
elif '--END COMMAND--' in self.data:
self.headers['Event'] = 'NoClue'
else:
self.headers['Response'] = 'Generated Header'
def parse(self, response):
"""Parse a manager message"""
data = []
for n, line in enumerate (response):
# all valid header lines end in \r\n
if not line.endswith ('\r\n'):
data.extend(response[n:])
break
try:
k, v = (x.strip() for x in line.split(':',1))
self.headers[k] = v
except ValueError:
# invalid header, start of multi-line data response
data.extend(response[n:])
break
self.data = ''.join(data)
def has_header(self, hname):
"""Check for a header"""
return self.headers.has_key(hname)
def get_header(self, hname, defval = None):
"""Return the specfied header"""
return self.headers.get(hname, defval)
def __getitem__(self, hname):
"""Return the specfied header"""
return self.headers[hname]
def __repr__(self):
return self.headers['Response']
class Event(object):
"""Manager interface Events, __init__ expects and 'Event' message"""
def __init__(self, message):
# store all of the event data
self.message = message
self.data = message.data
self.headers = message.headers
# if this is not an event message we have a problem
if not message.has_header('Event'):
raise ManagerException('Trying to create event from non event message')
# get the event name
self.name = message.get_header('Event')
def has_header(self, hname):
"""Check for a header"""
return self.headers.has_key(hname)
def get_header(self, hname, defval = None):
"""Return the specfied header"""
return self.headers.get(hname, defval)
def __getitem__(self, hname):
"""Return the specfied header"""
return self.headers[hname]
def __repr__(self):
return self.headers['Event']
def get_action_id(self):
return self.headers.get('ActionID',0000)
class Manager(object):
def __init__(self):
self._sock = None # our socket
self.title = None # set by received greeting
self._connected = threading.Event()
self._running = threading.Event()
# our hostname
self.hostname = socket.gethostname()
# our queues
self._message_queue = Queue.Queue()
self._response_queue = Queue.Queue()
self._event_queue = Queue.Queue()
# callbacks for events
self._event_callbacks = {}
self._reswaiting = [] # who is waiting for a response
# sequence stuff
self._seqlock = threading.Lock()
self._seq = 0
# some threads
self.message_thread = threading.Thread(target=self.message_loop)
self.event_dispatch_thread = threading.Thread(target=self.event_dispatch)
self.message_thread.setDaemon(True)
self.event_dispatch_thread.setDaemon(True)
def __del__(self):
self.close()
def connected(self):
"""
Check if we are connected or not.
"""
return self._connected.isSet()
def next_seq(self):
"""Return the next number in the sequence, this is used for ActionID"""
self._seqlock.acquire()
try:
return self._seq
finally:
self._seq += 1
self._seqlock.release()
def send_action(self, cdict={}, **kwargs):
"""
Send a command to the manager
If a list is passed to the cdict argument, each item in the list will
be sent to asterisk under the same header in the following manner:
cdict = {"Action": "Originate",
"Variable": ["var1=value", "var2=value"]}
send_action(cdict)
...
Action: Originate
Variable: var1=value
Variable: var2=value
"""
if not self._connected.isSet():
raise ManagerException("Not connected")
# fill in our args
cdict.update(kwargs)
# set the action id
if not cdict.has_key('ActionID'): cdict['ActionID'] = '%s-%08x' % (self.hostname, self.next_seq())
clist = []
# generate the command
for key, value in cdict.items():
if isinstance(value, list):
for item in value:
item = tuple([key, item])
clist.append('%s: %s' % item)
else:
item = tuple([key, value])
clist.append('%s: %s' % item)
clist.append(EOL)
command = EOL.join(clist)
# lock the socket and send our command
try:
self._sock.write(command)
self._sock.flush()
except socket.error, (errno, reason):
raise ManagerSocketException(errno, reason)
self._reswaiting.insert(0,1)
response = self._response_queue.get()
self._reswaiting.pop(0)
if not response:
raise ManagerSocketException(0, 'Connection Terminated')
return response
def _receive_data(self):
"""
Read the response from a command.
"""
multiline = False
wait_for_marker = False
eolcount = 0
# loop while we are sill running and connected
while self._running.isSet() and self._connected.isSet():
try:
lines = []
for line in self._sock :
# check to see if this is the greeting line
if not self.title and '/' in line and not ':' in line:
# store the title of the manager we are connecting to:
self.title = line.split('/')[0].strip()
# store the version of the manager we are connecting to:
self.version = line.split('/')[1].strip()
# fake message header
lines.append ('Response: Generated Header\r\n')
lines.append (line)
break
# If the line is EOL marker we have a complete message.
# Some commands are broken and contain a \n\r\n
# sequence, in the case wait_for_marker is set, we
# have such a command where the data ends with the
# marker --END COMMAND--, so we ignore embedded
# newlines until we see that marker
if line == EOL and not wait_for_marker :
multiline = False
if lines or not self._connected.isSet():
break
# ignore empty lines at start
continue
lines.append(line)
# line not ending in \r\n or without ':' isn't a
# valid header and starts multiline response
if not line.endswith('\r\n') or ':' not in line:
multiline = True
# Response: Follows indicates we should wait for end
# marker --END COMMAND--
if not multiline and line.startswith('Response') and \
line.split(':', 1)[1].strip() == 'Follows':
wait_for_marker = True
# same when seeing end of multiline response
if multiline and line.startswith('--END COMMAND--'):
wait_for_marker = False
multiline = False
if not self._connected.isSet():
break
else:
# EOF during reading
self._sock.close()
self._connected.clear()
# if we have a message append it to our queue
if lines and self._connected.isSet():
self._message_queue.put(lines)
else:
self._message_queue.put(None)
except socket.error:
self._sock.close()
self._connected.clear()
self._message_queue.put(None)
def register_event(self, event, function):
"""
Register a callback for the specfied event.
If a callback function returns True, no more callbacks for that
event will be executed.
"""
# get the current value, or an empty list
# then add our new callback
current_callbacks = self._event_callbacks.get(event, [])
current_callbacks.append(function)
self._event_callbacks[event] = current_callbacks
def unregister_event(self, event, function):
"""
Unregister a callback for the specified event.
"""
current_callbacks = self._event_callbacks.get(event, [])
current_callbacks.remove(function)
self._event_callbacks[event] = current_callbacks
def message_loop(self):
"""
The method for the event thread.
This actually recieves all types of messages and places them
in the proper queues.
"""
# start a thread to recieve data
t = threading.Thread(target=self._receive_data)
t.setDaemon(True)
t.start()
try:
# loop getting messages from the queue
while self._running.isSet():
# get/wait for messages
data = self._message_queue.get()
# if we got None as our message we are done
if not data:
# notify the other queues
self._event_queue.put(None)
for waiter in self._reswaiting:
self._response_queue.put(None)
break
# parse the data
message = ManagerMsg(data)
# check if this is an event message
if message.has_header('Event'):
self._event_queue.put(Event(message))
# check if this is a response
elif message.has_header('Response'):
self._response_queue.put(message)
else:
print 'No clue what we got\n%s' % message.data
finally:
# wait for our data receiving thread to exit
t.join()
def event_dispatch(self):
"""This thread is responsible for dispatching events"""
# loop dispatching events
while self._running.isSet():
# get/wait for an event
ev = self._event_queue.get()
# if we got None as an event, we are finished
if not ev:
break
# dispatch our events
# first build a list of the functions to execute
callbacks = (self._event_callbacks.get(ev.name, [])
+ self._event_callbacks.get('*', []))
# now execute the functions
for callback in callbacks:
if callback(ev, self):
break
def connect(self, host, port=5038):
"""Connect to the manager interface"""
if self._connected.isSet():
raise ManagerException('Already connected to manager')
# make sure host is a string
assert type(host) in StringTypes
port = int(port) # make sure port is an int
# create our socket and connect
try:
_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
_sock.connect((host,port))
self._sock = _sock.makefile ()
_sock.close ()
except socket.error, (errno, reason):
raise ManagerSocketException(errno, reason)
# we are connected and running
self._connected.set()
self._running.set()
# start the event thread
self.message_thread.start()
# start the event dispatching thread
self.event_dispatch_thread.start()
# get our initial connection response
return self._response_queue.get()
def close(self):
"""Shutdown the connection to the manager"""
# if we are still running, logout
if self._running.isSet() and self._connected.isSet():
self.logoff()
if self._running.isSet():
# put None in the message_queue to kill our threads
self._message_queue.put(None)
# wait for the event thread to exit
self.message_thread.join()
# make sure we do not join our self (when close is called from event handlers)
if threading.currentThread() != self.event_dispatch_thread:
# wait for the dispatch thread to exit
self.event_dispatch_thread.join()
self._running.clear()
# Manager actions
def login(self, username, secret):
"""Login to the manager, throws ManagerAuthException when login falis"""
cdict = {'Action':'Login'}
cdict['Username'] = username
cdict['Secret'] = secret
response = self.send_action(cdict)
if response.get_header('Response') == 'Error':
raise ManagerAuthException(response.get_header('Message'))
return response
def ping(self):
"""Send a ping action to the manager"""
cdict = {'Action':'Ping'}
response = self.send_action(cdict)
return response
def logoff(self):
"""Logoff from the manager"""
cdict = {'Action':'Logoff'}
response = self.send_action(cdict)
return response
def hangup(self, channel):
"""Hangup the specified channel"""
cdict = {'Action':'Hangup'}
cdict['Channel'] = channel
response = self.send_action(cdict)
return response
def status(self, channel = ''):
"""Get a status message from asterisk"""
cdict = {'Action':'Status'}
cdict['Channel'] = channel
response = self.send_action(cdict)
return response
def redirect(self, channel, exten, priority='1', extra_channel='', context=''):
"""Redirect a channel"""
cdict = {'Action':'Redirect'}
cdict['Channel'] = channel
cdict['Exten'] = exten
cdict['Priority'] = priority
if context: cdict['Context'] = context
if extra_channel: cdict['ExtraChannel'] = extra_channel
response = self.send_action(cdict)
return response
def originate(self, channel, exten, context='', priority='', timeout='', caller_id='', async=False, account='', variables={}):
"""Originate a call"""
cdict = {'Action':'Originate'}
cdict['Channel'] = channel
cdict['Exten'] = exten
if context: cdict['Context'] = context
if priority: cdict['Priority'] = priority
if timeout: cdict['Timeout'] = timeout
if caller_id: cdict['CallerID'] = caller_id
if async: cdict['Async'] = 'yes'
if account: cdict['Account'] = account
# join dict of vairables together in a string in the form of 'key=val|key=val'
# with the latest CVS HEAD this is no longer necessary
# if variables: cdict['Variable'] = '|'.join(['='.join((str(key), str(value))) for key, value in variables.items()])
if variables: cdict['Variable'] = ['='.join((str(key), str(value))) for key, value in variables.items()]
response = self.send_action(cdict)
return response
def mailbox_status(self, mailbox):
"""Get the status of the specfied mailbox"""
cdict = {'Action':'MailboxStatus'}
cdict['Mailbox'] = mailbox
response = self.send_action(cdict)
return response
def command(self, command):
"""Execute a command"""
cdict = {'Action':'Command'}
cdict['Command'] = command
response = self.send_action(cdict)
return response
def extension_state(self, exten, context):
"""Get the state of an extension"""
cdict = {'Action':'ExtensionState'}
cdict['Exten'] = exten
cdict['Context'] = context
response = self.send_action(cdict)
return response
def playdtmf (self, channel, digit) :
"""Plays a dtmf digit on the specified channel"""
cdict = {'Action':'PlayDTMF'}
cdict['Channel'] = channel
cdict['Digit'] = digit
response = self.send_action(cdict)
return response
def absolute_timeout(self, channel, timeout):
"""Set an absolute timeout on a channel"""
cdict = {'Action':'AbsoluteTimeout'}
cdict['Channel'] = channel
cdict['Timeout'] = timeout
response = self.send_action(cdict)
return response
def mailbox_count(self, mailbox):
cdict = {'Action':'MailboxCount'}
cdict['Mailbox'] = mailbox
response = self.send_action(cdict)
return response
def sippeers(self):
cdict = {'Action' : 'Sippeers'}
response = self.send_action(cdict)
return response
def sipshowpeer(self, peer):
cdict = {'Action' : 'SIPshowpeer'}
cdict['Peer'] = peer
response = self.send_action(cdict)
return response
class ManagerException(Exception): pass
class ManagerSocketException(ManagerException): pass
class ManagerAuthException(ManagerException): pass
| Python |
#!/usr/bin/env python
from asterisk.agi import *
from conversions import conversions_list
prefixes = ["9"]
cel_code = "9"
local_code = "11"
def formatPhone(phone):
parts = phone.split("-")
if len(parts) == 1:
return formatManualPhone(phone)
else:
return formatDialerPhone(parts)
def formatDialerPhone(phone):
area = phone[2]
number = phone[3]
if area == cel_code:
return formatCelPhone(area, number)
else:
return formatLinePhone(area, number)
def formatCelPhone(area, number):
formatedNumber = area + number
for key in conversions_list.iterkeys():
if formatedNumber.startswith(key):
formatedNumber = formatedNumber.replace(key, conversions_list[key], 1)
break
return formatedNumber
def formatLinePhone(area, number):
formatedNumber = "0" + area + number
if area == local_code:
formatedNumber = number
return formatedNumber
def formatManualPhone(phone):
formatedNumber = phone
for p in prefixes:
if phone.startswith(p):
formatedNumber = phone[len(p):]
break
return formatedNumber
if __name__ == "__main__":
agi = AGI()
exten = agi.env['agi_extension']
phone = formatPhone(exten)
agi.set_variable("PHONENUMBER", phone)
| Python |
conversions_list = {"911":"15",
"9220":"022015",
"92202":"0220215",
"9221":"022115",
"92221":"0222115",
"92223":"0222315",
"92224":"0222415",
"92225":"0222515",
"92226":"0222615",
"92227":"0222715",
"92229":"0222915",
"9223":"022315",
"92241":"0224115",
"92242":"0224215",
"92243":"0224315",
"92244":"0224415",
"92245":"0224515",
"92246":"0224615",
"92252":"0225215",
"92254":"0225415",
"92255":"0225515",
"92257":"0225715",
"92261":"0226115",
"92262":"0226215",
"92264":"0226415",
"92265":"0226515",
"92266":"0226615",
"92267":"0226715",
"92268":"0226815",
"92271":"0227115",
"92272":"0227215",
"92273":"0227315",
"92274":"0227415",
"92281":"0228115",
"92283":"0228315",
"92284":"0228415",
"92285":"0228515",
"92286":"0228615",
"92291":"0229115",
"92292":"0229215",
"92293":"0229315",
"92296":"0229615",
"92297":"0229715",
"92302":"0230215",
"92314":"0231415",
"92316":"0231615",
"92317":"0231715",
"92320":"0232015",
"92322":"0232215",
"92323":"0232315",
"92324":"0232415",
"92325":"0232515",
"92326":"0232615",
"92331":"0233115",
"92333":"0233315",
"92334":"0233415",
"92335":"0233515",
"92336":"0233615",
"92337":"0233715",
"92338":"0233815",
"92342":"0234215",
"92343":"0234315",
"92344":"0234415",
"92345":"0234515",
"92346":"0234615",
"92352":"0235215",
"92353":"0235315",
"92354":"0235415",
"92355":"0235515",
"92356":"0235615",
"92357":"0235715",
"92358":"0235815",
"92362":"0236215",
"9237":"023715",
"92392":"0239215",
"92393":"0239315",
"92394":"0239415",
"92395":"0239515",
"92396":"0239615",
"92473":"0247315",
"92474":"0247415",
"92475":"0247515",
"92477":"0247715",
"92478":"0247815",
"9261":"026115",
"92622":"0262215",
"92623":"0262315",
"92624":"0262415",
"92625":"0262515",
"92626":"0262615",
"92627":"0262715",
"9264":"026415",
"92646":"0264615",
"92647":"0264715",
"92648":"0264815",
"92651":"0265115",
"92652":"0265215",
"92655":"0265515",
"92656":"0265615",
"92657":"0265715",
"92658":"0265815",
"92901":"0290115",
"92902":"0290215",
"92903":"0290315",
"9291":"029115",
"92920":"0292015",
"92921":"0292115",
"92922":"0292215",
"92923":"0292315",
"92924":"0292415",
"92925":"0292515",
"92926":"0292615",
"92927":"0292715",
"92928":"0292815",
"92929":"0292915",
"92931":"0293115",
"92932":"0293215",
"92933":"0293315",
"92934":"0293415",
"92935":"0293515",
"92936":"0293615",
"92940":"0294015",
"92941":"0294115",
"92942":"0294215",
"92944":"0294415",
"92945":"0294515",
"92946":"0294615",
"92948":"0294815",
"92952":"0295215",
"92953":"0295315",
"92954":"0295415",
"92962":"0296215",
"92963":"0296315",
"92964":"0296415",
"92965":"0296515",
"92966":"0296615",
"9297":"029715",
"92972":"0297215",
"92982":"0298215",
"92983":"0298315",
"9299":"029915",
"93327":"0332715",
"93329":"0332915",
"93382":"0338215",
"93385":"0338515",
"93387":"0338715",
"93388":"0338815",
"93400":"0340015",
"93401":"0340115",
"93402":"0340215",
"93404":"0340415",
"93405":"0340515",
"93406":"0340615",
"93407":"0340715",
"93408":"0340815",
"93409":"0340915",
"9341":"034115",
"9342":"034215",
"9343":"034315",
"93435":"0343515",
"93436":"0343615",
"93437":"0343715",
"93438":"0343815",
"93442":"0344215",
"93444":"0344415",
"93445":"0344515",
"93446":"0344615",
"93447":"0344715",
"9345":"034515",
"93454":"0345415",
"93455":"0345515",
"93456":"0345615",
"93458":"0345815",
"93460":"0346015",
"93461":"0346115",
"93462":"0346215",
"93463":"0346315",
"93464":"0346415",
"93465":"0346515",
"93466":"0346615",
"93467":"0346715",
"93468":"0346815",
"93469":"0346915",
"93471":"0347115",
"93472":"0347215",
"93476":"0347615",
"93482":"0348215",
"93483":"0348315",
"93487":"0348715",
"93488":"0348815",
"93489":"0348915",
"93491":"0349115",
"93492":"0349215",
"93493":"0349315",
"93496":"0349615",
"93497":"0349715",
"93498":"0349815",
"9351":"035115",
"93521":"0352115",
"93522":"0352215",
"93524":"0352415",
"93525":"0352515",
"9353":"035315",
"93532":"0353215",
"93533":"0353315",
"93534":"0353415",
"93541":"0354115",
"93542":"0354215",
"93543":"0354315",
"93544":"0354415",
"93546":"0354615",
"93547":"0354715",
"93548":"0354815",
"93549":"0354915",
"93562":"0356215",
"93563":"0356315",
"93564":"0356415",
"93571":"0357115",
"93572":"0357215",
"93573":"0357315",
"93574":"0357415",
"93575":"0357515",
"93576":"0357615",
"9358":"035815",
"93582":"0358215",
"93583":"0358315",
"93584":"0358415",
"93585":"0358515",
"93711":"0371115",
"93715":"0371515",
"93716":"0371615",
"93717":"0371715",
"93718":"0371815",
"93721":"0372115",
"93722":"0372215",
"93725":"0372515",
"93731":"0373115",
"93732":"0373215",
"93734":"0373415",
"93735":"0373515",
"93741":"0374115",
"93743":"0374315",
"93751":"0375115",
"93752":"0375215",
"93754":"0375415",
"93755":"0375515",
"93756":"0375615",
"93757":"0375715",
"93758":"0375815",
"93772":"0377215",
"93773":"0377315",
"93774":"0377415",
"93775":"0377515",
"93777":"0377715",
"93781":"0378115",
"93782":"0378215",
"93783":"0378315",
"93786":"0378615",
"9381":"038115",
"93821":"0382115",
"93822":"0382215",
"93825":"0382515",
"93826":"0382615",
"93827":"0382715",
"93832":"0383215",
"93833":"0383315",
"93835":"0383515",
"93837":"0383715",
"93838":"0383815",
"93841":"0384115",
"93843":"0384315",
"93844":"0384415",
"93845":"0384515",
"93846":"0384615",
"9385":"038515",
"93854":"0385415",
"93855":"0385515",
"93856":"0385615",
"93857":"0385715",
"93858":"0385815",
"93861":"0386115",
"93862":"0386215",
"93863":"0386315",
"93865":"0386515",
"93867":"0386715",
"93868":"0386815",
"93869":"0386915",
"9387":"038715",
"93875":"0387515",
"93876":"0387615",
"93877":"0387715",
"93878":"0387815",
"9388":"038815",
"93884":"0388415",
"93885":"0388515",
"93886":"0388615",
"93887":"0388715",
"93891":"0389115",
"93892":"0389215",
"93894":"0389415"}; | Python |
#!/usr/bin/env python
# CheckMentioned.py
# Find all the properties used in SciTE source files and check if they
# are mentioned in scite/doc/SciTEDoc.html.
import os
import string
import stat
srcRoot = "../../scite"
srcDir = os.path.join(srcRoot, "src")
docFileName = os.path.join(srcRoot, "doc", "SciTEDoc.html")
propsFileName = os.path.join(srcDir, "SciTEGlobal.properties")
try: # Old Python
identCharacters = "_*." + string.letters + string.digits
except AttributeError: # Python 3.x
identCharacters = "_*." + string.ascii_letters + string.digits
# These properties are for debugging or for optionally attached features or are archaic
# and kept to preserve compatibility.
# lexerpath.*.lpeg is a special case for LPEG lexers associated with Scintillua projects.
knownDebugOptionalAndArchaicProperties = {
"asynchronous.sleep":1, # Debug
"dwell.period":1, # Debug
"bookmark.pixmap":1, # Debug
"lexerpath.*.lpeg":1, # Option for Scintillua
"ipc.director.name":1, # Archaic
}
# These properties are either set by SciTE and used (not set) in property files or
# should only be located in known lexer-specific property files.
knownOutputAndLexerProperties = {
"find.directory":1,
"find.what":1,
"xml.auto.close.tags":1,
"indent.python.colon":1,
}
knownOutputAndLexerProperties.update(knownDebugOptionalAndArchaicProperties)
# Convert all punctuation characters except '_', '*', and '.' into spaces.
def depunctuate(s):
d = ""
for ch in s:
if ch in identCharacters:
d = d + ch
else:
d = d + " "
return d
srcPaths = []
for filename in os.listdir(srcRoot):
dirname = os.path.join(srcRoot, filename)
if stat.S_ISDIR(os.stat(dirname)[stat.ST_MODE]):
for src in os.listdir(dirname):
if ".cxx" in src and ".bak" not in src:
srcPaths.append(dirname + os.sep + src)
propertiesPaths = []
for src in os.listdir(srcDir):
if ".properties" in src and \
"Embedded" not in src and \
"SciTE.properties" not in src and \
".bak" not in src:
propertiesPaths.append(os.path.join(srcDir, src))
def nameOKSrc(src):
if os.path.splitext(srcPath)[1] not in [".cxx", ".h"]:
return False
if "lua" in srcPath.lower():
return False
if "IFaceTable" in srcPath:
return False
if "Exporters" in srcPath:
return False
return True
def grabQuoted(s):
if '"' in s:
s = s[s.find('"')+1:]
if '"' in s:
return s[:s.find('"')]
return ""
def stripComment(s):
if "//" in s:
return s[:s.find("//")]
return s
propertyNames = {}
literalStrings = {}
dontLook = False # ignore contributor names as they don't get localised
#print srcPaths
for srcPath in srcPaths:
try: # Python 3.0
srcFile = open(srcPath, encoding='latin_1')
except TypeError: # Python 2.6
srcFile = open(srcPath)
except NameError: # Python 2.3
srcFile = open(srcPath)
for srcLine in srcFile.readlines():
srcLine = stripComment(srcLine).strip()
if '"' in srcLine and "props" in srcLine and ("Get" in srcLine or "ColourOfProperty" in srcLine):
parts = srcLine.split('\"')
#print parts
if len(parts) > 1:
propertyName = parts[1]
if propertyName:
propertyNames[propertyName] = 0
#print propertyName
if '"' in srcLine and nameOKSrc(srcPath):
if "Atsuo" in srcLine or '{"IDM_' in srcLine or dontLook:
dontLook = ";" not in srcLine
elif not srcLine.startswith("#") and \
not srcLine.startswith("//") and \
"SendDirector" not in srcLine and \
"gtk_signal_connect" not in srcLine:
srcLine = grabQuoted(srcLine)
if srcLine:
if srcLine[:1] not in ["<"]:
literalStrings[srcLine] = 1
srcFile.close()
docFile = open(docFileName, "rt")
for docLine in docFile.readlines():
for word in depunctuate(docLine).split():
if word in propertyNames.keys():
propertyNames[word] = 1
docFile.close()
print("# Not mentioned in %s" % docFileName)
identifiersSorted = list(propertyNames.keys())
identifiersSorted.sort()
for identifier in identifiersSorted:
if not propertyNames[identifier] and identifier not in knownDebugOptionalAndArchaicProperties:
print(identifier)
# Rest flags for searching properties file
for identifier in identifiersSorted:
propertyNames[identifier] = 0
def keyOfLine(line):
if '=' in line:
line = line.strip()
if line[0] == "#":
line = line[1:]
line = line[:line.find("=")]
line = line.strip()
return line
else:
return None
propsFile = open(propsFileName, "rt")
for propLine in propsFile.readlines():
if propLine:
key = keyOfLine(propLine)
if key:
if key in propertyNames.keys():
propertyNames[key] = 1
propsFile.close()
print("\n# Not mentioned in %s" % propsFileName)
for identifier in identifiersSorted:
if not propertyNames[identifier] and identifier not in knownOutputAndLexerProperties:
if "." != identifier[-1:]:
print(identifier)
# This is a test to see whether properties are defined in more than one file.
# It doesn't understand the if directive so yields too many false positives to run often.
print("\n# Duplicate mentions")
"""
fileOfProp = {}
notRealProperties = ["abbrev.properties", "SciTE.properties", "Embedded.properties"]
for filename in os.listdir(srcRoot + os.sep + "src"):
if filename.count(".properties") and filename not in notRealProperties:
propsFile = open(srcRoot + os.sep + "src" + os.sep + filename, "rt")
for line in propsFile.readlines():
if line and not line.startswith("#"):
key = keyOfLine(line)
if key:
if key in fileOfProp:
print("Clash for %s %s %s" % (key, fileOfProp[key], filename))
else:
fileOfProp[key] =filename
propsFile.close()
"""
propertiesSet = {}
for k in propertyNames.keys():
propertiesSet[k] = 1
localeFileName = srcRoot + "/win32/locale.properties"
localeSet = {}
for line in open(localeFileName):
if not line.startswith("#"):
line = line.strip().strip("=")
localeSet[line.lower()] = 1
resourceFileName = srcRoot + "/win32/SciTERes.rc"
resourceSet = {}
for line in open(resourceFileName):
line = line.strip()
if "VIRTKEY" not in line and \
"VALUE" not in line and \
"1234567" not in line and \
not line.startswith("BLOCK") and \
not line.startswith("FONT") and \
not line.startswith("ICON") and \
not line.startswith("ID") and \
"#include" not in line:
line = grabQuoted(line)
if line:
if '\\t' in line:
line = line[:line.find('\\t')]
line = line.replace('&','')
line = line.replace('...','')
if len(line) > 2:
resourceSet[line] = 1
print("\n# Missing localisation of resource")
resourceSet = list(resourceSet.keys())
resourceSet.sort()
for l in resourceSet:
if l.lower() not in localeSet:
print(l)
def present(l, n):
low = n.lower()
if low in localeSet:
return True
return low.replace("_","").replace("&","") in localeSet
literalStrings = [l for l in literalStrings.keys() if l not in identifiersSorted]
literalStrings = [l for l in list(literalStrings) if not present(localeSet, l)]
propsFile = open(propsFileName, "rt")
for propLine in propsFile.readlines():
if propLine:
key = keyOfLine(propLine)
if key:
if key in propertyNames.keys():
propertyNames[key] = 1
propsFile.close()
propToFile = {}
for propPath in propertiesPaths:
base = os.path.basename(propPath)
base = propPath
propsFile = open(propPath)
for propLine in propsFile.readlines():
if propLine and not propLine.startswith("#"):
key = keyOfLine(propLine)
if key:
if key not in propToFile:
propToFile[key] = []
propToFile[key].append(base)
propsFile.close()
print("\n# Duplicate properties")
propToFileKeys = list(propToFile.keys())
propToFileKeys.sort()
for k in propToFileKeys:
files = propToFile[k]
if len(files) > 1:
if files.count(files[0]) < len(files):
print(k + (", ".join(propToFile[k])))
| Python |
#!/usr/bin/env python
# RegenerateSource.py - implemented 2013 by Neil Hodgson neilh@scintilla.org
# Released to the public domain.
# Regenerate the SciTE source files that list all the lexers and all the
# properties files.
# Should be run whenever a new lexer is added or removed.
# Requires Python 2.5 or later
# Most files are regenerated in place with templates stored in comments.
# The VS .NET project file is generated into a different file as the
# VS .NET environment will not retain comments when modifying the file.
# The format of generation comments is documented in FileGenerator.py.
# Regenerates Scintilla files by calling LexGen.RegenerateAll
import glob, os, sys
srcRoot = "../.."
sys.path.append(srcRoot + "/scintilla/scripts")
from FileGenerator import Generate, Regenerate, UpdateLineInFile, ReplaceREInFile
import ScintillaData
import LexGen
def UpdateVersionNumbers(sci, root):
UpdateLineInFile(root + "scite/src/SciTE.h", "#define VERSION_SCITE",
"#define VERSION_SCITE \"" + sci.versionDotted + "\"")
UpdateLineInFile(root + "scite/src/SciTE.h", "#define VERSION_WORDS",
"#define VERSION_WORDS " + sci.versionCommad)
UpdateLineInFile(root + "scite/src/SciTE.h", "#define COPYRIGHT_DATES",
'#define COPYRIGHT_DATES "December 1998-' + sci.myModified + '"')
UpdateLineInFile(root + "scite/src/SciTE.h", "#define COPYRIGHT_YEARS",
'#define COPYRIGHT_YEARS "1998-' + sci.yearModified + '"')
UpdateLineInFile(root + "scite/doc/SciTEDownload.html", " Release",
" Release " + sci.versionDotted)
ReplaceREInFile(root + "scite/doc/SciTEDownload.html",
r"/scintilla/([a-zA-Z]+)\d\d\d",
r"/scintilla/\g<1>" + sci.version)
UpdateLineInFile(root + "scite/doc/SciTE.html",
' <font color="#FFCC99" size="3"> Release version',
' <font color="#FFCC99" size="3"> Release version ' + \
sci.versionDotted + '<br />')
UpdateLineInFile(root + "scite/doc/SciTE.html",
' Site last modified',
' Site last modified ' + sci.mdyModified + '</font>')
UpdateLineInFile(root + "scite/doc/SciTE.html",
' <meta name="Date.Modified"',
' <meta name="Date.Modified" content="' + sci.dateModified + '" />')
def RegenerateAll():
root="../../"
sci = ScintillaData.ScintillaData(root + "scintilla/")
# Generate HTML to document each property
# This is done because tags can not be safely put inside comments in HTML
documentProperties = list(sci.propertyDocuments.keys())
ScintillaData.SortListInsensitive(documentProperties)
propertiesHTML = []
for k in documentProperties:
propertiesHTML.append("\t<tr id='property-%s'>\n\t<td>%s</td>\n\t<td>%s</td>\n\t</tr>" %
(k, k, sci.propertyDocuments[k]))
# Find all the SciTE properties files
otherProps = [
"abbrev.properties",
"Embedded.properties",
"SciTEGlobal.properties",
"SciTE.properties"]
propFilePaths = glob.glob(root + "scite/src/*.properties")
ScintillaData.SortListInsensitive(propFilePaths)
propFiles = [os.path.basename(f) for f in propFilePaths if os.path.basename(f) not in otherProps]
ScintillaData.SortListInsensitive(propFiles)
Regenerate(root + "scite/win32/makefile", "#", propFiles)
Regenerate(root + "scite/win32/scite.mak", "#", propFiles)
Regenerate(root + "scite/src/SciTEProps.cxx", "//", sci.lexerProperties)
Regenerate(root + "scite/doc/SciTEDoc.html", "<!--", propertiesHTML)
Generate(root + "scite/boundscheck/vcproj.gen",
root + "scite/boundscheck/SciTE.vcproj", "#", sci.lexFiles)
UpdateVersionNumbers(sci, root)
LexGen.RegenerateAll("../../scintilla/")
RegenerateAll()
| Python |
#!/usr/bin/env python3
# CheckMentioned.py
# Find all the symbols in scintilla/include/Scintilla.h and check if they
# are mentioned in scintilla/doc/ScintillaDoc.html.
import string
uninteresting = {
"SCINTILLA_H", "SCI_START", "SCI_LEXER_START", "SCI_OPTIONAL_START",
# These archaic names are #defined to the Sci_ prefixed modern equivalents.
# They are not documented so they are not used in new code.
"CharacterRange", "TextRange", "TextToFind", "RangeToFormat",
}
srcRoot = "../.."
incFileName = srcRoot + "/scintilla/include/Scintilla.h"
docFileName = srcRoot + "/scintilla/doc/ScintillaDoc.html"
try: # Old Python
identCharacters = "_" + string.letters + string.digits
except AttributeError: # Python 3.x
identCharacters = "_" + string.ascii_letters + string.digits
# Convert all punctuation characters except '_' into spaces.
def depunctuate(s):
d = ""
for ch in s:
if ch in identCharacters:
d = d + ch
else:
d = d + " "
return d
symbols = {}
incFile = open(incFileName, "rt")
for line in incFile.readlines():
if line.startswith("#define"):
identifier = line.split()[1]
symbols[identifier] = 0
incFile.close()
docFile = open(docFileName, "rt")
for line in docFile.readlines():
for word in depunctuate(line).split():
if word in symbols.keys():
symbols[word] = 1
docFile.close()
identifiersSorted = list(symbols.keys())
identifiersSorted.sort()
for identifier in identifiersSorted:
if not symbols[identifier] and identifier not in uninteresting:
print(identifier)
| Python |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import with_statement
import os, sys
scintillaDirectory = os.path.join("..", "..", "scintilla")
scintillaScriptsDirectory = os.path.join(scintillaDirectory, "scripts")
sys.path.append(scintillaScriptsDirectory)
import Face
def cell(s):
return "<td>%s</td>" % s
def faceFeatures(out):
out.write("<h2>Scintilla key commands</h2>\n")
out.write("<table>\n")
out.write("<thead>%s%s%s</thead>\n" % (cell("Command"), cell("Name"), cell("Explanation")))
face = Face.Face()
face.ReadFromFile(os.path.join(scintillaDirectory, "include", "Scintilla.iface"))
texts = []
for name in face.features:
#~ print name
f = face.features[name]
if f["FeatureType"] == "fun" and \
f["ReturnType"] == "void" and \
not (f["Param1Type"] or f["Param2Type"]):
texts.append([name, f["Value"], " ".join(f["Comment"])])
texts.sort()
for t in texts:
out.write("<tr>%s%s%s</tr>\n" % (cell(t[1]), cell(t[0]), cell(t[2])))
out.write("</table>\n")
def menuFeatures(out):
out.write("<h2>SciTE menu commands</h2>\n")
out.write("<table>\n")
out.write("<thead>%s%s</thead>\n" % (cell("Command"), cell("Menu text")))
with open(os.path.join("..", "win32", "SciTERes.rc"), "rt") as f:
for l in f:
l = l.strip()
if l.startswith("MENUITEM") and "SEPARATOR" not in l:
l = l.replace("MENUITEM", "").strip()
text, symbol = l.split('",', 1)
symbol = symbol.strip()
text = text[1:].replace("&", "").replace("...", "")
if "\\t" in text:
text = text.split("\\t",1)[0]
if text:
out.write("<tr><td>%s</td><td>%s</td></tr>\n" % (symbol, text))
out.write("</table>\n")
startFile = """
<?xml version="1.0"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<!--Generated by scite/scripts/commandsdoc.py -->
<style type="text/css">
table { border: 1px solid #1F1F1F; border-collapse: collapse; }
td { border: 1px solid; border-color: #E0E0E0 #000000; padding: 1px 5px 1px 5px; }
th { border: 1px solid #1F1F1F; padding: 1px 5px 1px 5px; }
thead { background-color: #000000; color: #FFFFFF; }
</style>
<body>
"""
if __name__ == "__main__":
with open(os.path.join("..", "doc", "CommandValues.html"), "w") as out:
out.write(startFile)
menuFeatures(out)
faceFeatures(out)
out.write("</body>\n</html>\n")
| Python |
#!/usr/bin/env python
# makerpms.py
# Copy files all over the place build RPMs and copy to top level directory
import os
import shutil
srcRoot = "../../"
rpmRoot = "/usr/src/redhat/SOURCES/"
rpmBin = "/usr/src/redhat/RPMS/i386/"
rpmSource = "/usr/src/redhat/SRPMS/"
verFileName = srcRoot + "scintilla/version.txt"
vers = open(verFileName)
#139
vFull = vers.read().strip()
vers.close()
#1.39
vPoint = vFull[0] + "." + vFull[1:]
#1, 3, 9, 0
vComma = vFull[0] + ", " + vFull[1] + ", " + vFull[2] + ", 0"
print("[ %s | %s | %s ]" % (vFull, vPoint, vComma))
tgzV = "scite" + vFull + ".tgz"
tgzFileName = srcRoot + "scite.tgz"
tgzVFileName = srcRoot + tgzV
print("[ %s | %s ]" % (tgzFileName, tgzVFileName))
if not os.access(tgzFileName, os.F_OK):
print("Base file '" + tgzFileName + "' does not exist.")
else:
shutil.copyfile(tgzFileName, tgzVFileName)
os.unlink(tgzFileName)
rpmVFileName = rpmRoot + tgzV
shutil.copyfile(tgzVFileName, rpmVFileName)
# Run the rpm build command
os.system("rpm -ba scite.spec")
rpmB = "scite-" + vPoint + "-1.i386.rpm"
shutil.copyfile(rpmBin + rpmB, srcRoot + rpmB)
rpmS = "scite-" + vPoint + "-1.src.rpm"
shutil.copyfile(rpmSource + rpmS, srcRoot + rpmS)
| Python |
#! /usr/bin/env python
# Produces a .api file for SciTE's identifier completion and calltip features.
# invoke as
# python tags2api.py tags >x.api
# before running this program, create a tags file with
# ctags --excmd=number --c-types=pcdgstu <header files>
import fileinput
import time
# Definitions that start with _ are often used for infrastructure
# like include guards and can be removed with
removePrivate=1
# The Windows headers include both ANSI and UniCode versions
# of many functions with macros that default to one or the other.
# When winMode is on, these 4 lines are replaced with either the
# ANSI or UniCode prototype.
winMode = 1
include="A" # Set to "W" if you want the UniCode prototypes.
class FileCache:
'''Caches the contents of a set of files.
Avoids reading files repeatedly from disk by holding onto the
contents of each file as a list of strings.
'''
def __init__(self):
self.filecache = {}
def grabFile(self, filename):
'''Return the contents of a file as a list of strings.
New line characters are removed.
'''
if filename not in self.filecache:
contents=[]
f = open(filename)
for line in f.readlines():
if line[-1:] == '\n': line = line[:-1]
contents.append(line)
f.close()
self.filecache[filename] = contents
return self.filecache[filename]
def bracesDiff(s):
''' Counts the number of '(' and ')' in a string and returns the difference between the two.
Used to work out when a function prototype is complete.
'''
diff = 0
mode=0 # 0 <=> default, 1 <=> comment, 2 <=> string
for i in range(len(s)):
if mode == 0: # default mode
if s[i]=='(':
diff += 1
elif s[i]==')':
diff -= 1
elif s[i]=='"':
mode=2
elif i>0 and s[i-1]=='/' and s[i]=='/':
return diff
elif i>0 and s[i-1]=='/' and s[i]=='*':
mode=1
elif mode == 1: # comment
if i>0 and s[i-1]=='*' and s[i]=='/':
mode=0
elif mode == 2: # string
if s[i]=='"':
mode=0
return diff
fc = FileCache()
apis = {}
for line in fileinput.input():
if line[0] != '!': # Not a comment.
(entityName, fileName, lineNo, tagType) = line.split("\t")[:4]
curLineNo = int(lineNo[:-2]) - 1 # -1 because line numbers in tags file start at 1.
contents = fc.grabFile(fileName)
if (not removePrivate or entityName[0] != '_') and not entityName.startswith("operator "):
if tagType[0] in "pf": # Function prototype.
try:
braces = bracesDiff(contents[curLineNo])
curDef = contents[curLineNo]
while braces > 0: # Search for end of prototype.
curLineNo = curLineNo + 1
braces = braces + bracesDiff(contents[curLineNo])
curDef = curDef + contents[curLineNo]
# Normalise the appearance of the prototype.
curDef = curDef.strip()
# Replace whitespace sequences with a single space character.
curDef = " ".join(curDef.split())
# Remove space around the '('.
curDef = curDef.replace(" (", '(').replace("( ", '(')
# Remove trailing semicolon.
curDef = curDef.replace(";", '')
# Remove implementation if present.
if "{" in curDef and "}" in curDef:
startImpl = curDef.find("{")
endImpl = curDef.find("}")
curDef = curDef[:startImpl] + curDef[endImpl+1:]
else:
# Remove trailing brace.
curDef = curDef.rstrip("{")
# Remove return type.
curDef = curDef[curDef.find(entityName):]
# Remove virtual indicator.
if curDef.replace(" ", "").endswith(")=0"):
curDef = curDef.rstrip("0 ")
curDef = curDef.rstrip("= ")
# Remove trailing space.
curDef = curDef.rstrip()
if winMode:
if curDef.find("A(") >= 0:
if "A" in include:
apis[curDef.replace("A(", '(')] = 1
elif curDef.find("W(") >= 0:
if "W" in include:
apis[curDef.replace("W(", '(')] = 1
else: # A character set independent function.
apis[curDef] = 1
else:
apis.add[curDef] = 1
except IndexError:
pass
elif tagType[0] == 'd': # Macro definition.
curDef = contents[curLineNo]
if (not winMode) or (curDef[-1] not in "AW"):
apis[entityName] = 1
else:
apis[entityName] = 1
apisKeys = list(apis.keys())
apisKeys.sort()
print("\n".join(apisKeys))
| Python |
#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
from PySide.QtCore import *
from PySide.QtGui import *
import ScintillaConstants as sci
sys.path.append("../..")
from bin import ScintillaEditPy
txtInit = "int main(int argc, char **argv) {\n" \
" // Start up the gnome\n" \
" gnome_init(\"stest\", \"1.0\", argc, argv);\n}\n";
keywords = \
"and and_eq asm auto bitand bitor bool break " \
"case catch char class compl const const_cast continue " \
"default delete do double dynamic_cast else enum explicit export extern false float for " \
"friend goto if inline int long mutable namespace new not not_eq " \
"operator or or_eq private protected public " \
"register reinterpret_cast return short signed sizeof static static_cast struct switch " \
"template this throw true try typedef typeid typename union unsigned using " \
"virtual void volatile wchar_t while xor xor_eq";
def uriDropped():
print "uriDropped"
class Form(QDialog):
def __init__(self, parent=None):
super(Form, self).__init__(parent)
self.resize(460,300)
# Create widgets
self.edit = ScintillaEditPy.ScintillaEdit(self)
self.edit.uriDropped.connect(uriDropped)
self.edit.command.connect(self.receive_command)
self.edit.notify.connect(self.receive_notification)
self.edit.styleClearAll()
self.edit.setMarginWidthN(0, 35)
self.edit.setScrollWidth(200)
self.edit.setScrollWidthTracking(1)
self.edit.setLexer(sci.SCLEX_CPP)
self.edit.styleSetFore(sci.SCE_C_COMMENT, 0x008000)
self.edit.styleSetFore(sci.SCE_C_COMMENTLINE, 0x008000)
self.edit.styleSetFore(sci.SCE_C_COMMENTDOC, 0x008040)
self.edit.styleSetItalic(sci.SCE_C_COMMENTDOC, 1)
self.edit.styleSetFore(sci.SCE_C_NUMBER, 0x808000)
self.edit.styleSetFore(sci.SCE_C_WORD, 0x800000)
self.edit.styleSetBold(sci.SCE_C_WORD, True)
self.edit.styleSetFore(sci.SCE_C_STRING, 0x800080)
self.edit.styleSetFore(sci.SCE_C_PREPROCESSOR, 0x008080)
self.edit.styleSetBold(sci.SCE_C_OPERATOR, True)
self.edit.setMultipleSelection(1)
self.edit.setVirtualSpaceOptions(
sci.SCVS_RECTANGULARSELECTION | sci.SCVS_USERACCESSIBLE)
self.edit.setAdditionalSelectionTyping(1)
self.edit.styleSetFore(sci.STYLE_INDENTGUIDE, 0x808080)
self.edit.setIndentationGuides(sci.SC_IV_LOOKBOTH)
self.edit.setKeyWords(0, keywords)
self.edit.addText(len(txtInit), txtInit)
self.edit.setSel(1,10)
retriever = str(self.edit.getLine(1))
print(type(retriever), len(retriever))
print('[' + retriever + ']')
someText = str(self.edit.textRange(2,5))
print(len(someText), '[' + someText + ']')
someText = self.edit.getCurLine(100)
print(len(someText), '[' + someText + ']')
someText = self.edit.styleFont(1)
print(len(someText), '[' + someText + ']')
someText = self.edit.getSelText()
print(len(someText), '[' + someText + ']')
someText = self.edit.tag(1)
print(len(someText), '[' + someText + ']')
someText = self.edit.autoCCurrentText()
print(len(someText), '[' + someText + ']')
someText = self.edit.annotationText(1)
print(len(someText), '[' + someText + ']')
someText = self.edit.annotationStyles(1)
print(len(someText), '[' + someText + ']')
someText = self.edit.describeKeyWordSets()
print(len(someText), '[' + someText + ']')
someText = self.edit.propertyNames()
print(len(someText), '[' + someText + ']')
self.edit.setProperty("fold", "1")
someText = self.edit.property("fold")
print(len(someText), '[' + someText + ']')
someText = self.edit.propertyExpanded("fold")
print(len(someText), '[' + someText + ']')
someText = self.edit.lexerLanguage()
print(len(someText), '[' + someText + ']')
someText = self.edit.describeProperty("styling.within.preprocessor")
print(len(someText), '[' + someText + ']')
xx = self.edit.findText(0, "main", 0, 25)
print(type(xx), xx)
print("isBold", self.edit.styleBold(sci.SCE_C_WORD))
# Retrieve the document and write into it
doc = self.edit.get_doc()
doc.insert_string(40, "***")
stars = doc.get_char_range(40,3)
assert stars == "***"
# Create a new independent document and attach it to the editor
doc = ScintillaEditPy.ScintillaDocument()
doc.insert_string(0, "/***/\nif(a)\n")
self.edit.set_doc(doc)
self.edit.setLexer(sci.SCLEX_CPP)
def Call(self, message, wParam=0, lParam=0):
return self.edit.send(message, wParam, lParam)
def resizeEvent(self, e):
self.edit.resize(e.size().width(), e.size().height())
def receive_command(self, wParam, lParam):
# Show underline at start when focussed
notifyCode = wParam >> 16
if (notifyCode == sci.SCEN_SETFOCUS) or (notifyCode == sci.SCEN_KILLFOCUS):
self.edit.setIndicatorCurrent(sci.INDIC_CONTAINER);
self.edit.indicatorClearRange(0, self.edit.length())
if notifyCode == sci.SCEN_SETFOCUS:
self.edit.indicatorFillRange(0, 2);
def receive_notification(self, scn):
if scn.nmhdr.code == sci.SCN_CHARADDED:
print "Char %02X" % scn.ch
elif scn.nmhdr.code == sci.SCN_SAVEPOINTREACHED:
print "Saved"
elif scn.nmhdr.code == sci.SCN_SAVEPOINTLEFT:
print "Unsaved"
elif scn.nmhdr.code == sci.SCN_MODIFIED:
print "Modified"
elif scn.nmhdr.code == sci.SCN_UPDATEUI:
print "Update UI"
elif scn.nmhdr.code == sci.SCN_PAINTED:
#print "Painted"
pass
else:
print "Notification", scn.nmhdr.code
pass
if __name__ == '__main__':
# Create the Qt Application
app = QApplication(sys.argv)
# Create and show the form
form = Form()
form.show()
# Run the main Qt loop
sys.exit(app.exec_())
| Python |
import distutils.sysconfig
import getopt
import glob
import os
import platform
import shutil
import subprocess
import stat
import sys
sys.path.append(os.path.join("..", "ScintillaEdit"))
import WidgetGen
scintillaDirectory = "../.."
scintillaScriptsDirectory = os.path.join(scintillaDirectory, "scripts")
sys.path.append(scintillaScriptsDirectory)
from FileGenerator import GenerateFile
# Decide up front which platform, treat anything other than Windows or OS X as Linux
PLAT_WINDOWS = platform.system() == "Windows"
PLAT_DARWIN = platform.system() == "Darwin"
PLAT_LINUX = not (PLAT_DARWIN or PLAT_WINDOWS)
def IsFileNewer(name1, name2):
""" Returns whether file with name1 is newer than file with name2. Returns 1
if name2 doesn't exist. """
if not os.path.exists(name1):
return 0
if not os.path.exists(name2):
return 1
mod_time1 = os.stat(name1)[stat.ST_MTIME]
mod_time2 = os.stat(name2)[stat.ST_MTIME]
return (mod_time1 > mod_time2)
def textFromRun(args):
(stdoutdata, stderrdata) = subprocess.Popen(args, shell=True, stdout=subprocess.PIPE).communicate()
return stdoutdata
def runProgram(args, exitOnFailure):
print(" ".join(args))
retcode = subprocess.call(" ".join(args), shell=True, stderr=subprocess.STDOUT)
if retcode:
print("Failed in " + " ".join(args) + " return code = " + str(retcode))
if exitOnFailure:
sys.exit()
def usage():
print("sepbuild.py [-h|--help][-c|--clean][-u|--underscore-names]")
print("")
print("Generate PySide wappers and build them.")
print("")
print("options:")
print("")
print("-c --clean remove all object and generated files")
print("-b --pyside-base Location of the PySide+Qt4 sandbox to use")
print("-h --help display this text")
print("-d --debug=yes|no force debug build (or non-debug build)")
print("-u --underscore-names use method_names consistent with GTK+ standards")
modifyFunctionElement = """ <modify-function signature="%s">%s
</modify-function>"""
injectCode = """
<inject-code class="target" position="beginning">%s
</inject-code>"""
injectCheckN = """
if (!cppArg%d) {
PyErr_SetString(PyExc_ValueError, "Null string argument");
return 0;
}"""
def methodSignature(name, v, options):
argTypes = ""
p1Type = WidgetGen.cppAlias(v["Param1Type"])
if p1Type == "int":
p1Type = "sptr_t"
if p1Type:
argTypes = argTypes + p1Type
p2Type = WidgetGen.cppAlias(v["Param2Type"])
if p2Type == "int":
p2Type = "sptr_t"
if p2Type and v["Param2Type"] != "stringresult":
if p1Type:
argTypes = argTypes + ", "
argTypes = argTypes + p2Type
methodName = WidgetGen.normalisedName(name, options, v["FeatureType"])
constDeclarator = " const" if v["FeatureType"] == "get" else ""
return methodName + "(" + argTypes + ")" + constDeclarator
def printTypeSystemFile(f, options):
out = []
for name in f.order:
v = f.features[name]
if v["Category"] != "Deprecated":
feat = v["FeatureType"]
if feat in ["fun", "get", "set"]:
checks = ""
if v["Param1Type"] == "string":
checks = checks + (injectCheckN % 0)
if v["Param2Type"] == "string":
if v["Param1Type"] == "": # Only arg 2 -> treat as first
checks = checks + (injectCheckN % 0)
else:
checks = checks + (injectCheckN % 1)
if checks:
inject = injectCode % checks
out.append(modifyFunctionElement % (methodSignature(name, v, options), inject))
#if v["Param1Type"] == "string":
# out.append("<string-xml>" + name + "</string-xml>\n")
return out
def doubleBackSlashes(s):
# Quote backslashes so qmake does not produce warnings
return s.replace("\\", "\\\\")
class SepBuilder:
def __init__(self):
# Discover configuration parameters
self.ScintillaEditIncludes = [".", "../ScintillaEdit", "../ScintillaEditBase", "../../include"]
if PLAT_WINDOWS:
self.MakeCommand = "nmake"
self.MakeTarget = "release"
else:
self.MakeCommand = "make"
self.MakeTarget = ""
if PLAT_DARWIN:
self.QMakeOptions = "-spec macx-g++"
else:
self.QMakeOptions = ""
# Default to debug build if running in a debug build interpreter
self.DebugBuild = hasattr(sys, 'getobjects')
# Python
self.PyVersion = "%d.%d" % sys.version_info[:2]
self.PyVersionSuffix = distutils.sysconfig.get_config_var("VERSION")
self.PyIncludes = distutils.sysconfig.get_python_inc()
self.PyPrefix = distutils.sysconfig.get_config_var("prefix")
self.PyLibDir = distutils.sysconfig.get_config_var(
("LIBDEST" if sys.platform == 'win32' else "LIBDIR"))
# Scintilla
with open("../../version.txt") as f:
version = f.read()
self.ScintillaVersion = version[0] + '.' + version[1] + '.' + version[2]
# Find out what qmake is called
self.QMakeCommand = "qmake"
if not PLAT_WINDOWS:
# On Unix qmake may not be present but qmake-qt4 may be so check
pathToQMake = textFromRun("which qmake-qt4 || which qmake").rstrip()
self.QMakeCommand = os.path.basename(pathToQMake)
# Qt default location from qmake
self._SetQtIncludeBase(textFromRun(self.QMakeCommand + " -query QT_INSTALL_HEADERS").rstrip())
# PySide default location
# No standard for installing PySide development headers and libs on Windows so
# choose /usr to be like Linux
self._setPySideBase('\\usr' if PLAT_WINDOWS else '/usr')
self.ProInclude = "sepbuild.pri"
self.qtStyleInterface = True
def _setPySideBase(self, base):
self.PySideBase = base
if PLAT_LINUX:
self.PySideTypeSystem = textFromRun("pkg-config --variable=typesystemdir pyside").rstrip()
self.PySideIncludeBase = textFromRun("pkg-config --variable=includedir pyside").rstrip()
self.ShibokenIncludeBase = textFromRun("pkg-config --variable=includedir shiboken").rstrip()
else:
self.PySideTypeSystem = os.path.join(self.PySideBase, "share", "PySide", "typesystems")
self.ShibokenIncludeBase = os.path.join(self.PySideBase, "include", "shiboken")
self.PySideIncludeBase = os.path.join(self.PySideBase, "include", "PySide")
self.PySideIncludes = [
self.ShibokenIncludeBase,
self.PySideIncludeBase,
os.path.join(self.PySideIncludeBase, "QtCore"),
os.path.join(self.PySideIncludeBase, "QtGui")]
self.PySideLibDir = os.path.join(self.PySideBase, "lib")
self.AllIncludes = os.pathsep.join(self.QtIncludes + self.ScintillaEditIncludes + self.PySideIncludes)
self.ShibokenGenerator = "shiboken"
# Is this still needed? It doesn't work with latest shiboken sources
#if PLAT_DARWIN:
# # On OS X, can not automatically find Shiboken dylib so provide a full path
# self.ShibokenGenerator = os.path.join(self.PySideLibDir, "generatorrunner", "shiboken")
def generateAPI(self, args):
os.chdir(os.path.join("..", "ScintillaEdit"))
if not self.qtStyleInterface:
args.insert(0, '--underscore-names')
WidgetGen.main(args)
f = WidgetGen.readInterface(False)
os.chdir(os.path.join("..", "ScintillaEditPy"))
options = {"qtStyle": self.qtStyleInterface}
GenerateFile("typesystem_ScintillaEdit.xml.template", "typesystem_ScintillaEdit.xml",
"<!-- ", True, printTypeSystemFile(f, options))
def runGenerator(self):
generatorrunner = "shiboken"
for name in ('shiboken', 'generatorrunner'):
if PLAT_WINDOWS:
name += '.exe'
name = os.path.join(self.PySideBase, "bin", name)
if os.path.exists(name):
generatorrunner = name
break
args = [
generatorrunner,
"--generator-set=" + self.ShibokenGenerator,
"global.h ",
"--avoid-protected-hack",
"--enable-pyside-extensions",
"--include-paths=" + self.AllIncludes,
"--typesystem-paths=" + self.PySideTypeSystem,
"--output-directory=.",
"typesystem_ScintillaEdit.xml"]
print(" ".join(args))
retcode = subprocess.call(" ".join(args), shell=True, stderr=subprocess.STDOUT)
if retcode:
print("Failed in generatorrunner", retcode)
sys.exit()
def writeVariables(self):
# Write variables needed into file to be included from project so it does not have to discover much
with open(self.ProInclude, "w") as f:
f.write("SCINTILLA_VERSION=" + self.ScintillaVersion + "\n")
f.write("PY_VERSION=" + self.PyVersion + "\n")
f.write("PY_VERSION_SUFFIX=" + self.PyVersionSuffix + "\n")
f.write("PY_PREFIX=" + doubleBackSlashes(self.PyPrefix) + "\n")
f.write("PY_INCLUDES=" + doubleBackSlashes(self.PyIncludes) + "\n")
f.write("PY_LIBDIR=" + doubleBackSlashes(self.PyLibDir) + "\n")
f.write("PYSIDE_INCLUDES=" + doubleBackSlashes(self.PySideIncludeBase) + "\n")
f.write("PYSIDE_LIB=" + doubleBackSlashes(self.PySideLibDir) + "\n")
f.write("SHIBOKEN_INCLUDES=" + doubleBackSlashes(self.ShibokenIncludeBase) + "\n")
if self.DebugBuild:
f.write("CONFIG += debug\n")
else:
f.write("CONFIG += release\n")
def make(self):
runProgram([self.QMakeCommand, self.QMakeOptions], exitOnFailure=True)
runProgram([self.MakeCommand, self.MakeTarget], exitOnFailure=True)
def cleanEverything(self):
self.generateAPI(["--clean"])
runProgram([self.MakeCommand, "distclean"], exitOnFailure=False)
filesToRemove = [self.ProInclude, "typesystem_ScintillaEdit.xml",
"../../bin/ScintillaEditPy.so", "../../bin/ScintillaConstants.py"]
for file in filesToRemove:
try:
os.remove(file)
except OSError:
pass
for logFile in glob.glob("*.log"):
try:
os.remove(logFile)
except OSError:
pass
shutil.rmtree("debug", ignore_errors=True)
shutil.rmtree("release", ignore_errors=True)
shutil.rmtree("ScintillaEditPy", ignore_errors=True)
def buildEverything(self):
cleanGenerated = False
opts, args = getopt.getopt(sys.argv[1:], "hcdub",
["help", "clean", "debug=",
"underscore-names", "pyside-base="])
for opt, arg in opts:
if opt in ("-h", "--help"):
usage()
sys.exit()
elif opt in ("-c", "--clean"):
cleanGenerated = True
elif opt in ("-d", "--debug"):
self.DebugBuild = (arg == '' or arg.lower() == 'yes')
if self.DebugBuild and sys.platform == 'win32':
self.MakeTarget = 'debug'
elif opt in ("-b", '--pyside-base'):
self._SetQtIncludeBase(os.path.join(os.path.normpath(arg), 'include'))
self._setPySideBase(os.path.normpath(arg))
elif opt in ("-u", "--underscore-names"):
self.qtStyleInterface = False
if cleanGenerated:
self.cleanEverything()
else:
self.writeVariables()
self.generateAPI([""])
self.runGenerator()
self.make()
self.copyScintillaConstants()
def copyScintillaConstants(self):
orig = 'ScintillaConstants.py'
dest = '../../bin/' + orig
if IsFileNewer(dest, orig):
return
f = open(orig, 'r')
contents = f.read()
f.close()
f = open(dest, 'w')
f.write(contents)
f.close()
def _SetQtIncludeBase(self, base):
self.QtIncludeBase = base
self.QtIncludes = [self.QtIncludeBase] + [os.path.join(self.QtIncludeBase, sub) for sub in ["QtCore", "QtGui"]]
# Set path so correct qmake is found
path = os.environ.get('PATH', '').split(os.pathsep)
qt_bin_dir = os.path.join(os.path.dirname(base), 'bin')
if qt_bin_dir not in path:
path.insert(0, qt_bin_dir)
os.environ['PATH'] = os.pathsep.join(path)
if __name__ == "__main__":
sepBuild = SepBuilder()
sepBuild.buildEverything()
| Python |
#!/usr/bin/env python
# WidgetGen.py - regenerate the ScintillaWidgetCpp.cpp and ScintillaWidgetCpp.h files
# Check that API includes all gtkscintilla2 functions
import sys
import os
import getopt
scintillaDirectory = "../.."
scintillaScriptsDirectory = os.path.join(scintillaDirectory, "scripts")
sys.path.append(scintillaScriptsDirectory)
import Face
from FileGenerator import GenerateFile
def underscoreName(s):
# Name conversion fixes to match gtkscintilla2
irregular = ['WS', 'EOL', 'AutoC', 'KeyWords', 'BackSpace', 'UnIndents', 'RE', 'RGBA']
for word in irregular:
replacement = word[0] + word[1:].lower()
s = s.replace(word, replacement)
out = ""
for c in s:
if c.isupper():
if out:
out += "_"
out += c.lower()
else:
out += c
return out
def normalisedName(s, options, role=None):
if options["qtStyle"]:
if role == "get":
s = s.replace("Get", "")
return s[0].lower() + s[1:]
else:
return underscoreName(s)
typeAliases = {
"position": "int",
"colour": "int",
"keymod": "int",
"string": "const char *",
"stringresult": "const char *",
"cells": "const char *",
}
def cppAlias(s):
if s in typeAliases:
return typeAliases[s]
else:
return s
understoodTypes = ["", "void", "int", "bool", "position",
"colour", "keymod", "string", "stringresult", "cells"]
def checkTypes(name, v):
understandAllTypes = True
if v["ReturnType"] not in understoodTypes:
#~ print("Do not understand", v["ReturnType"], "for", name)
understandAllTypes = False
if v["Param1Type"] not in understoodTypes:
#~ print("Do not understand", v["Param1Type"], "for", name)
understandAllTypes = False
if v["Param2Type"] not in understoodTypes:
#~ print("Do not understand", v["Param2Type"], "for", name)
understandAllTypes = False
return understandAllTypes
def arguments(v, stringResult, options):
ret = ""
p1Type = cppAlias(v["Param1Type"])
if p1Type == "int":
p1Type = "sptr_t"
if p1Type:
ret = ret + p1Type + " " + normalisedName(v["Param1Name"], options)
p2Type = cppAlias(v["Param2Type"])
if p2Type == "int":
p2Type = "sptr_t"
if p2Type and not stringResult:
if p1Type:
ret = ret + ", "
ret = ret + p2Type + " " + normalisedName(v["Param2Name"], options)
return ret
def printPyFile(f, options):
out = []
for name in f.order:
v = f.features[name]
if v["Category"] != "Deprecated":
feat = v["FeatureType"]
if feat in ["val"]:
out.append(name + "=" + v["Value"])
if feat in ["evt"]:
out.append("SCN_" + name.upper() + "=" + v["Value"])
return out
def printHFile(f, options):
out = []
for name in f.order:
v = f.features[name]
if v["Category"] != "Deprecated":
feat = v["FeatureType"]
if feat in ["fun", "get", "set"]:
if checkTypes(name, v):
constDeclarator = " const" if feat == "get" else ""
returnType = cppAlias(v["ReturnType"])
if returnType == "int":
returnType = "sptr_t"
stringResult = v["Param2Type"] == "stringresult"
if stringResult:
returnType = "QByteArray"
out.append("\t" + returnType + " " + normalisedName(name, options, feat) + "(" +
arguments(v, stringResult, options)+
")" + constDeclarator + ";")
return out
def methodNames(f, options):
for name in f.order:
v = f.features[name]
if v["Category"] != "Deprecated":
feat = v["FeatureType"]
if feat in ["fun", "get", "set"]:
if checkTypes(name, v):
yield normalisedName(name, options)
def printCPPFile(f, options):
out = []
for name in f.order:
v = f.features[name]
if v["Category"] != "Deprecated":
feat = v["FeatureType"]
if feat in ["fun", "get", "set"]:
if checkTypes(name, v):
constDeclarator = " const" if feat == "get" else ""
featureDefineName = "SCI_" + name.upper()
returnType = cppAlias(v["ReturnType"])
if returnType == "int":
returnType = "sptr_t"
stringResult = v["Param2Type"] == "stringresult"
if stringResult:
returnType = "QByteArray"
returnStatement = ""
if returnType != "void":
returnStatement = "return "
out.append(returnType + " ScintillaEdit::" + normalisedName(name, options, feat) + "(" +
arguments(v, stringResult, options) +
")" + constDeclarator + " {")
returns = ""
if stringResult:
returns += " " + returnStatement + "TextReturner(" + featureDefineName + ", "
if "*" in cppAlias(v["Param1Type"]):
returns += "(sptr_t)"
if v["Param1Name"]:
returns += normalisedName(v["Param1Name"], options)
else:
returns += "0"
returns += ");"
else:
returns += " " + returnStatement + "send(" + featureDefineName + ", "
if "*" in cppAlias(v["Param1Type"]):
returns += "(sptr_t)"
if v["Param1Name"]:
returns += normalisedName(v["Param1Name"], options)
else:
returns += "0"
returns += ", "
if "*" in cppAlias(v["Param2Type"]):
returns += "(sptr_t)"
if v["Param2Name"]:
returns += normalisedName(v["Param2Name"], options)
else:
returns += "0"
returns += ");"
out.append(returns)
out.append("}")
out.append("")
return out
def gtkNames():
# The full path on my machine: should be altered for anyone else
p = "C:/Users/Neil/Downloads/wingide-source-4.0.1-1/wingide-source-4.0.1-1/external/gtkscintilla2/gtkscintilla.c"
with open(p) as f:
for l in f.readlines():
if "gtk_scintilla_" in l:
name = l.split()[1][14:]
if '(' in name:
name = name.split('(')[0]
yield name
def usage():
print("WidgetGen.py [-c|--clean][-h|--help][-u|--underscore-names]")
print("")
print("Generate full APIs for ScintillaEdit class and ScintillaConstants.py.")
print("")
print("options:")
print("")
print("-c --clean remove all generated code from files")
print("-h --help display this text")
print("-u --underscore-names use method_names consistent with GTK+ standards")
def readInterface(cleanGenerated):
f = Face.Face()
if not cleanGenerated:
f.ReadFromFile("../../include/Scintilla.iface")
return f
def main(argv):
# Using local path for gtkscintilla2 so don't default to checking
checkGTK = False
cleanGenerated = False
qtStyleInterface = True
# The --gtk-check option checks for full coverage of the gtkscintilla2 API but
# depends on a particular directory so is not mentioned in --help.
opts, args = getopt.getopt(argv, "hcgu", ["help", "clean", "gtk-check", "underscore-names"])
for opt, arg in opts:
if opt in ("-h", "--help"):
usage()
sys.exit()
elif opt in ("-c", "--clean"):
cleanGenerated = True
elif opt in ("-g", "--gtk-check"):
checkGTK = True
elif opt in ("-u", "--underscore-names"):
qtStyleInterface = False
options = {"qtStyle": qtStyleInterface}
f = readInterface(cleanGenerated)
try:
GenerateFile("ScintillaEdit.cpp.template", "ScintillaEdit.cpp",
"/* ", True, printCPPFile(f, options))
GenerateFile("ScintillaEdit.h.template", "ScintillaEdit.h",
"/* ", True, printHFile(f, options))
GenerateFile("../ScintillaEditPy/ScintillaConstants.py.template",
"../ScintillaEditPy/ScintillaConstants.py",
"# ", True, printPyFile(f, options))
if checkGTK:
names = set(methodNames(f))
#~ print("\n".join(names))
namesGtk = set(gtkNames())
for name in namesGtk:
if name not in names:
print(name, "not found in Qt version")
for name in names:
if name not in namesGtk:
print(name, "not found in GTK+ version")
except:
raise
if cleanGenerated:
for file in ["ScintillaEdit.cpp", "ScintillaEdit.h", "../ScintillaEditPy/ScintillaConstants.py"]:
try:
os.remove(file)
except OSError:
pass
if __name__ == "__main__":
main(sys.argv[1:])
| Python |
#!/usr/bin/env python
# HFacer.py - regenerate the Scintilla.h and SciLexer.h files from the Scintilla.iface interface
# definition file.
# Implemented 2000 by Neil Hodgson neilh@scintilla.org
# Requires Python 2.5 or later
import sys
import os
import Face
from FileGenerator import UpdateFile, Generate, Regenerate, UpdateLineInFile, lineEnd
def printLexHFile(f):
out = []
for name in f.order:
v = f.features[name]
if v["FeatureType"] in ["val"]:
if "SCE_" in name or "SCLEX_" in name:
out.append("#define " + name + " " + v["Value"])
return out
def printHFile(f):
out = []
previousCategory = ""
for name in f.order:
v = f.features[name]
if v["Category"] != "Deprecated":
if v["Category"] == "Provisional" and previousCategory != "Provisional":
out.append("#ifndef SCI_DISABLE_PROVISIONAL")
previousCategory = v["Category"]
if v["FeatureType"] in ["fun", "get", "set"]:
featureDefineName = "SCI_" + name.upper()
out.append("#define " + featureDefineName + " " + v["Value"])
elif v["FeatureType"] in ["evt"]:
featureDefineName = "SCN_" + name.upper()
out.append("#define " + featureDefineName + " " + v["Value"])
elif v["FeatureType"] in ["val"]:
if not ("SCE_" in name or "SCLEX_" in name):
out.append("#define " + name + " " + v["Value"])
out.append("#endif")
return out
f = Face.Face()
try:
f.ReadFromFile("../include/Scintilla.iface")
Regenerate("../include/Scintilla.h", "/* ", printHFile(f))
Regenerate("../include/SciLexer.h", "/* ", printLexHFile(f))
print("Maximum ID is %s" % max([x for x in f.values if int(x) < 3000]))
except:
raise
| Python |
# Script to generate CaseConvert.cxx from Python's Unicode data
# Should be run rarely when a Python with a new version of Unicode data is available.
# Should not be run with old versions of Python.
# Current best approach divides case conversions into two cases:
# simple symmetric and complex.
# Simple symmetric is where a lower and upper case pair convert to each
# other and the folded form is the same as the lower case.
# There are 1006 symmetric pairs.
# These are further divided into ranges (stored as lower, upper, range length,
# range pitch and singletons (stored as lower, upper).
# Complex is for cases that don't fit the above: where there are multiple
# characters in one of the forms or fold is different to lower or
# lower(upper(x)) or upper(lower(x)) are not x. These are represented as UTF-8
# strings with original, folded, upper, and lower separated by '|'.
# There are 126 complex cases.
import codecs, itertools, os, string, sys, unicodedata
from FileGenerator import Regenerate
def contiguousRanges(l, diff):
# l is s list of lists
# group into lists where first element of each element differs by diff
out = [[l[0]]]
for s in l[1:]:
if s[0] != out[-1][-1][0] + diff:
out.append([])
out[-1].append(s)
return out
def flatten(listOfLists):
"Flatten one level of nesting"
return itertools.chain.from_iterable(listOfLists)
def conversionSets():
# For all Unicode characters, see whether they have case conversions
# Return 2 sets: one of simple symmetric conversion cases and another
# with complex cases.
complexes = []
symmetrics = []
for ch in range(sys.maxunicode):
if ch >= 0xd800 and ch <= 0xDBFF:
continue
if ch >= 0xdc00 and ch <= 0xDFFF:
continue
uch = chr(ch)
fold = uch.casefold()
upper = uch.upper()
lower = uch.lower()
symmetric = False
if uch != upper and len(upper) == 1 and uch == lower and uch == fold:
lowerUpper = upper.lower()
foldUpper = upper.casefold()
if lowerUpper == foldUpper and lowerUpper == uch:
symmetric = True
symmetrics.append((ch, ord(upper), ch - ord(upper)))
if uch != lower and len(lower) == 1 and uch == upper and lower == fold:
upperLower = lower.upper()
if upperLower == uch:
symmetric = True
if fold == uch:
fold = ""
if upper == uch:
upper = ""
if lower == uch:
lower = ""
if (fold or upper or lower) and not symmetric:
complexes.append((uch, fold, upper, lower))
return symmetrics, complexes
def groupRanges(symmetrics):
# Group the symmetrics into groups where possible, returning a list
# of ranges and a list of symmetrics that didn't fit into a range
def distance(s):
return s[2]
groups = []
uniquekeys = []
for k, g in itertools.groupby(symmetrics, distance):
groups.append(list(g)) # Store group iterator as a list
uniquekeys.append(k)
contiguousGroups = flatten([contiguousRanges(g, 1) for g in groups])
longGroups = [(x[0][0], x[0][1], len(x), 1) for x in contiguousGroups if len(x) > 4]
oneDiffs = [s for s in symmetrics if s[2] == 1]
contiguousOnes = flatten([contiguousRanges(g, 2) for g in [oneDiffs]])
longOneGroups = [(x[0][0], x[0][1], len(x), 2) for x in contiguousOnes if len(x) > 4]
rangeGroups = sorted(longGroups+longOneGroups, key=lambda s: s[0])
rangeCoverage = list(flatten([range(r[0], r[0]+r[2]*r[3], r[3]) for r in rangeGroups]))
nonRanges = [(l, u) for l, u, d in symmetrics if l not in rangeCoverage]
return rangeGroups, nonRanges
def escape(s):
return "".join((chr(c) if chr(c) in string.ascii_letters else "\\x%x" % c) for c in s.encode('utf-8'))
def updateCaseConvert():
symmetrics, complexes = conversionSets()
rangeGroups, nonRanges = groupRanges(symmetrics)
print(len(rangeGroups), "ranges")
rangeLines = ["%d,%d,%d,%d, " % x for x in rangeGroups]
print(len(nonRanges), "non ranges")
nonRangeLines = ["%d,%d, " % x for x in nonRanges]
print(len(symmetrics), "symmetric")
complexLines = ['"%s|%s|%s|%s|"' % tuple(escape(t) for t in x) for x in complexes]
print(len(complexLines), "complex")
Regenerate("../src/CaseConvert.cxx", "//", rangeLines, nonRangeLines, complexLines)
updateCaseConvert()
| Python |
#!/usr/bin/env python
# LexGen.py - implemented 2002 by Neil Hodgson neilh@scintilla.org
# Released to the public domain.
# Regenerate the Scintilla source files that list all the lexers.
# Should be run whenever a new lexer is added or removed.
# Requires Python 2.5 or later
# Files are regenerated in place with templates stored in comments.
# The format of generation comments is documented in FileGenerator.py.
from FileGenerator import Regenerate, UpdateLineInFile, ReplaceREInFile
import ScintillaData
def UpdateVersionNumbers(sci, root):
UpdateLineInFile(root + "win32/ScintRes.rc", "#define VERSION_SCINTILLA",
"#define VERSION_SCINTILLA \"" + sci.versionDotted + "\"")
UpdateLineInFile(root + "win32/ScintRes.rc", "#define VERSION_WORDS",
"#define VERSION_WORDS " + sci.versionCommad)
UpdateLineInFile(root + "qt/ScintillaEditBase/ScintillaEditBase.pro",
"VERSION =",
"VERSION = " + sci.versionDotted)
UpdateLineInFile(root + "qt/ScintillaEdit/ScintillaEdit.pro",
"VERSION =",
"VERSION = " + sci.versionDotted)
UpdateLineInFile(root + "doc/ScintillaDownload.html", " Release",
" Release " + sci.versionDotted)
ReplaceREInFile(root + "doc/ScintillaDownload.html",
r"/scintilla/([a-zA-Z]+)\d\d\d",
r"/scintilla/\g<1>" + sci.version)
UpdateLineInFile(root + "doc/index.html",
' <font color="#FFCC99" size="3"> Release version',
' <font color="#FFCC99" size="3"> Release version ' +\
sci.versionDotted + '<br />')
UpdateLineInFile(root + "doc/index.html",
' Site last modified',
' Site last modified ' + sci.mdyModified + '</font>')
UpdateLineInFile(root + "doc/ScintillaHistory.html",
' Released ',
' Released ' + sci.dmyModified + '.')
def RegenerateAll(root):
sci = ScintillaData.ScintillaData(root)
Regenerate(root + "src/Catalogue.cxx", "//", sci.lexerModules)
Regenerate(root + "win32/scintilla.mak", "#", sci.lexFiles)
UpdateVersionNumbers(sci, root)
if __name__=="__main__":
RegenerateAll("../")
| Python |
# Script to generate CharacterCategory.cxx from Python's Unicode data
# Should be run rarely when a Python with a new version of Unicode data is available.
# Should not be run with old versions of Python.
import codecs, os, platform, sys, unicodedata
from FileGenerator import Regenerate
def findCategories(filename):
with codecs.open(filename, "r", "UTF-8") as infile:
lines = [x.strip() for x in infile.readlines() if "\tcc" in x]
values = "".join(lines).replace(" ","").split(",")
print(values)
return [v[2:] for v in values]
def updateCharacterCategory(filename):
values = ["// Created with Python %s, Unicode %s" % (
platform.python_version(), unicodedata.unidata_version)]
category = unicodedata.category(chr(0))
startRange = 0
for ch in range(sys.maxunicode):
uch = chr(ch)
if unicodedata.category(uch) != category:
value = startRange * 32 + categories.index(category)
values.append("%d," % value)
category = unicodedata.category(uch)
startRange = ch
value = startRange * 32 + categories.index(category)
values.append("%d," % value)
Regenerate(filename, "//", values)
categories = findCategories("../lexlib/CharacterCategory.h")
updateCharacterCategory("../lexlib/CharacterCategory.cxx")
| Python |
# Face.py - module for reading and parsing Scintilla.iface file
# Implemented 2000 by Neil Hodgson neilh@scintilla.org
# Released to the public domain.
# Requires Python 2.5 or later
def sanitiseLine(line):
if line[-1:] == '\n': line = line[:-1]
if line.find("##") != -1:
line = line[:line.find("##")]
line = line.strip()
return line
def decodeFunction(featureVal):
retType, rest = featureVal.split(" ", 1)
nameIdent, params = rest.split("(")
name, value = nameIdent.split("=")
params, rest = params.split(")")
param1, param2 = params.split(",")
return retType, name, value, param1, param2
def decodeEvent(featureVal):
retType, rest = featureVal.split(" ", 1)
nameIdent, params = rest.split("(")
name, value = nameIdent.split("=")
return retType, name, value
def decodeParam(p):
param = p.strip()
type = ""
name = ""
value = ""
if " " in param:
type, nv = param.split(" ")
if "=" in nv:
name, value = nv.split("=")
else:
name = nv
return type, name, value
class Face:
def __init__(self):
self.order = []
self.features = {}
self.values = {}
self.events = {}
def ReadFromFile(self, name):
currentCategory = ""
currentComment = []
currentCommentFinished = 0
file = open(name)
for line in file.readlines():
line = sanitiseLine(line)
if line:
if line[0] == "#":
if line[1] == " ":
if currentCommentFinished:
currentComment = []
currentCommentFinished = 0
currentComment.append(line[2:])
else:
currentCommentFinished = 1
featureType, featureVal = line.split(" ", 1)
if featureType in ["fun", "get", "set"]:
try:
retType, name, value, param1, param2 = decodeFunction(featureVal)
except ValueError:
print("Failed to decode %s" % line)
raise
p1 = decodeParam(param1)
p2 = decodeParam(param2)
self.features[name] = {
"FeatureType": featureType,
"ReturnType": retType,
"Value": value,
"Param1Type": p1[0], "Param1Name": p1[1], "Param1Value": p1[2],
"Param2Type": p2[0], "Param2Name": p2[1], "Param2Value": p2[2],
"Category": currentCategory, "Comment": currentComment
}
if value in self.values:
raise Exception("Duplicate value " + value + " " + name)
self.values[value] = 1
self.order.append(name)
elif featureType == "evt":
retType, name, value = decodeEvent(featureVal)
self.features[name] = {
"FeatureType": featureType,
"ReturnType": retType,
"Value": value,
"Category": currentCategory, "Comment": currentComment
}
if value in self.events:
raise Exception("Duplicate event " + value + " " + name)
self.events[value] = 1
self.order.append(name)
elif featureType == "cat":
currentCategory = featureVal
elif featureType == "val":
try:
name, value = featureVal.split("=", 1)
except ValueError:
print("Failure %s" % featureVal)
raise Exception()
self.features[name] = {
"FeatureType": featureType,
"Category": currentCategory,
"Value": value }
self.order.append(name)
elif featureType == "enu" or featureType == "lex":
name, value = featureVal.split("=", 1)
self.features[name] = {
"FeatureType": featureType,
"Category": currentCategory,
"Value": value }
self.order.append(name)
| Python |
# ScintillaData.py - implemented 2013 by Neil Hodgson neilh@scintilla.org
# Released to the public domain.
# Common code used by Scintilla and SciTE for source file regeneration.
# The ScintillaData object exposes information about Scintilla as properties:
# Version properties
# version
# versionDotted
# versionCommad
#
# Date last modified
# dateModified
# yearModified
# mdyModified
# dmyModified
# myModified
#
# Information about lexers and properties defined in lexers
# lexFiles
# sorted list of lexer files
# lexerModules
# sorted list of module names
# lexerProperties
# sorted list of lexer properties
# propertyDocuments
# dictionary of property documentation { name: document string }
# This file can be run to see the data it provides.
# Requires Python 2.5 or later
from __future__ import with_statement
import datetime, glob, os, textwrap
import FileGenerator
def FindModules(lexFile):
modules = []
with open(lexFile) as f:
for l in f.readlines():
if l.startswith("LexerModule"):
l = l.replace("(", " ")
modules.append(l.split()[1])
return modules
# Properties that start with lexer. or fold. are automatically found but there are some
# older properties that don't follow this pattern so must be explicitly listed.
knownIrregularProperties = [
"fold",
"styling.within.preprocessor",
"tab.timmy.whinge.level",
"asp.default.language",
"html.tags.case.sensitive",
"ps.level",
"ps.tokenize",
"sql.backslash.escapes",
"nsis.uservars",
"nsis.ignorecase"
]
def FindProperties(lexFile):
properties = {}
with open(lexFile) as f:
for l in f.readlines():
if ("GetProperty" in l or "DefineProperty" in l) and "\"" in l:
l = l.strip()
if not l.startswith("//"): # Drop comments
propertyName = l.split("\"")[1]
if propertyName.lower() == propertyName:
# Only allow lower case property names
if propertyName in knownIrregularProperties or \
propertyName.startswith("fold.") or \
propertyName.startswith("lexer."):
properties[propertyName] = 1
return properties
def FindPropertyDocumentation(lexFile):
documents = {}
with open(lexFile) as f:
name = ""
for l in f.readlines():
l = l.strip()
if "// property " in l:
propertyName = l.split()[2]
if propertyName.lower() == propertyName:
# Only allow lower case property names
name = propertyName
documents[name] = ""
elif "DefineProperty" in l and "\"" in l:
propertyName = l.split("\"")[1]
if propertyName.lower() == propertyName:
# Only allow lower case property names
name = propertyName
documents[name] = ""
elif name:
if l.startswith("//"):
if documents[name]:
documents[name] += " "
documents[name] += l[2:].strip()
elif l.startswith("\""):
l = l[1:].strip()
if l.endswith(";"):
l = l[:-1].strip()
if l.endswith(")"):
l = l[:-1].strip()
if l.endswith("\""):
l = l[:-1]
# Fix escaped double quotes
l = l.replace("\\\"", "\"")
documents[name] += l
else:
name = ""
for name in list(documents.keys()):
if documents[name] == "":
del documents[name]
return documents
def ciCompare(a,b):
return cmp(a.lower(), b.lower())
def ciKey(a):
return a.lower()
def SortListInsensitive(l):
try: # Try key function
l.sort(key=ciKey)
except TypeError: # Earlier version of Python, so use comparison function
l.sort(ciCompare)
class ScintillaData:
def __init__(self, scintillaRoot):
# Discover verion information
with open(scintillaRoot + "version.txt") as f:
self.version = f.read().strip()
self.versionDotted = self.version[0] + '.' + self.version[1] + '.' + \
self.version[2]
self.versionCommad = self.version[0] + ', ' + self.version[1] + ', ' + \
self.version[2] + ', 0'
with open(scintillaRoot + "doc/index.html") as f:
self.dateModified = [l for l in f.readlines() if "Date.Modified" in l]\
[0].split('\"')[3]
# 20130602
# index.html, SciTE.html
dtModified = datetime.datetime.strptime(self.dateModified, "%Y%m%d")
self.yearModified = self.dateModified[0:4]
monthModified = dtModified.strftime("%B")
dayModified = "%d" % dtModified.day
self.mdyModified = monthModified + " " + dayModified + " " + self.yearModified
# May 22 2013
# index.html, SciTE.html
self.dmyModified = dayModified + " " + monthModified + " " + self.yearModified
# 22 May 2013
# ScintillaHistory.html -- only first should change
self.myModified = monthModified + " " + self.yearModified
# Find all the lexer source code files
lexFilePaths = glob.glob(scintillaRoot + "lexers/Lex*.cxx")
SortListInsensitive(lexFilePaths)
self.lexFiles = [os.path.basename(f)[:-4] for f in lexFilePaths]
self.lexerModules = []
lexerProperties = set()
self.propertyDocuments = {}
for lexFile in lexFilePaths:
self.lexerModules.extend(FindModules(lexFile))
for k in FindProperties(lexFile).keys():
lexerProperties.add(k)
documents = FindPropertyDocumentation(lexFile)
for k in documents.keys():
if k not in self.propertyDocuments:
self.propertyDocuments[k] = documents[k]
SortListInsensitive(self.lexerModules)
self.lexerProperties = list(lexerProperties)
SortListInsensitive(self.lexerProperties)
def printWrapped(text):
print(textwrap.fill(text, subsequent_indent=" "))
if __name__=="__main__":
sci = ScintillaData("../")
print("Version %s %s %s" % (sci.version, sci.versionDotted, sci.versionCommad))
print("Date last modified %s %s %s %s %s" % (
sci.dateModified, sci.yearModified, sci.mdyModified, sci.dmyModified, sci.myModified))
printWrapped(str(len(sci.lexFiles)) + " lexer files: " + ", ".join(sci.lexFiles))
printWrapped(str(len(sci.lexerModules)) + " lexer modules: " + ", ".join(sci.lexerModules))
printWrapped("Lexer properties: " + ", ".join(sci.lexerProperties))
print("Lexer property documentation:")
documentProperties = list(sci.propertyDocuments.keys())
SortListInsensitive(documentProperties)
for k in documentProperties:
print(" " + k)
print(textwrap.fill(sci.propertyDocuments[k], initial_indent=" ",
subsequent_indent=" "))
| Python |
#!/usr/bin/env python
# LexGen.py - implemented 2002 by Neil Hodgson neilh@scintilla.org
# Released to the public domain.
# Regenerate the Scintilla and SciTE source files that list
# all the lexers and all the properties files.
# Should be run whenever a new lexer is added or removed.
# Requires Python 2.4 or later
# Most files are regenerated in place with templates stored in comments.
# The VS .NET project file is generated into a different file as the
# VS .NET environment will not retain comments when modifying the file.
# The files are copied to a string apart from sections between a
# ++Autogenerated comment and a --Autogenerated comment which is
# generated by the CopyWithInsertion function. After the whole
# string is instantiated, it is compared with the target file and
# if different the file is rewritten.
# Does not regenerate the Visual C++ 6 project files but does the VS .NET
# project file.
import string
import sys
import os
import glob
# EOL constants
CR = "\r"
LF = "\n"
CRLF = "\r\n"
if sys.platform == "win32":
NATIVE = CRLF
else:
# Yes, LF is the native EOL even on Mac OS X. CR is just for
# Mac OS <=9 (a.k.a. "Mac Classic")
NATIVE = LF
# Automatically generated sections contain start and end comments,
# a definition line and the results.
# The results are replaced by regenerating based on the definition line.
# The definition line is a comment prefix followed by "**".
# If there is a digit after the ** then this indicates which list to use
# and the digit and next character are not part of the definition
# Backslash is used as an escape within the definition line.
# The part between \( and \) is repeated for each item in the list.
# \* is replaced by each list item. \t, and \n are tab and newline.
def CopyWithInsertion(input, commentPrefix, retainDefs, eolType, *lists):
copying = 1
listid = 0
output = []
for line in input.splitlines(0):
isStartGenerated = line.startswith(commentPrefix + "++Autogenerated")
if copying and not isStartGenerated:
output.append(line)
if isStartGenerated:
if retainDefs:
output.append(line)
copying = 0
definition = ""
elif not copying and line.startswith(commentPrefix + "**"):
if retainDefs:
output.append(line)
definition = line[len(commentPrefix + "**"):]
if (commentPrefix == "<!--") and (" -->" in definition):
definition = definition.replace(" -->", "")
listid = 0
if definition[0] in string.digits:
listid = int(definition[:1])
definition = definition[2:]
# Hide double slashes as a control character
definition = definition.replace("\\\\", "\001")
# Do some normal C style transforms
definition = definition.replace("\\n", "\n")
definition = definition.replace("\\t", "\t")
# Get the doubled backslashes back as single backslashes
definition = definition.replace("\001", "\\")
startRepeat = definition.find("\\(")
endRepeat = definition.find("\\)")
intro = definition[:startRepeat]
out = ""
if intro.endswith("\n"):
pos = 0
else:
pos = len(intro)
out += intro
middle = definition[startRepeat+2:endRepeat]
for i in lists[listid]:
item = middle.replace("\\*", i)
if pos and (pos + len(item) >= 80):
out += "\\\n"
pos = 0
out += item
pos += len(item)
if item.endswith("\n"):
pos = 0
outro = definition[endRepeat+2:]
out += outro
out = out.replace("\n", eolType) # correct EOLs in generated content
output.append(out)
elif line.startswith(commentPrefix + "--Autogenerated"):
copying = 1
if retainDefs:
output.append(line)
output = [line.rstrip(" \t") for line in output] # trim trailing whitespace
return eolType.join(output) + eolType
def UpdateFile(filename, updated):
""" If the file is different to updated then copy updated
into the file else leave alone so CVS and make don't treat
it as modified. """
try:
infile = open(filename, "rb")
except IOError: # File is not there yet
out = open(filename, "wb")
out.write(updated.encode('utf-8'))
out.close()
print("New %s" % filename)
return
original = infile.read()
infile.close()
original = original.decode('utf-8')
if updated != original:
os.unlink(filename)
out = open(filename, "wb")
out.write(updated.encode('utf-8'))
out.close()
print("Changed %s " % filename)
#~ else:
#~ print "Unchanged", filename
def Generate(inpath, outpath, commentPrefix, eolType, *lists):
"""Generate 'outpath' from 'inpath'.
"eolType" indicates the type of EOLs to use in the generated
file. It should be one of following constants: LF, CRLF,
CR, or NATIVE.
"""
#print "generate '%s' -> '%s' (comment prefix: %r, eols: %r)"\
# % (inpath, outpath, commentPrefix, eolType)
try:
infile = open(inpath, "rb")
except IOError:
print("Can not open %s" % inpath)
return
original = infile.read()
infile.close()
original = original.decode('utf-8')
updated = CopyWithInsertion(original, commentPrefix,
inpath == outpath, eolType, *lists)
UpdateFile(outpath, updated)
def Regenerate(filename, commentPrefix, eolType, *lists):
"""Regenerate the given file.
"eolType" indicates the type of EOLs to use in the generated
file. It should be one of following constants: LF, CRLF,
CR, or NATIVE.
"""
Generate(filename, filename, commentPrefix, eolType, *lists)
def FindModules(lexFile):
modules = []
f = open(lexFile)
for l in f.readlines():
if l.startswith("LexerModule"):
l = l.replace("(", " ")
modules.append(l.split()[1])
return modules
# Properties that start with lexer. or fold. are automatically found but there are some
# older properties that don't follow this pattern so must be explicitly listed.
knownIrregularProperties = [
"fold",
"styling.within.preprocessor",
"tab.timmy.whinge.level",
"asp.default.language",
"html.tags.case.sensitive",
"ps.level",
"ps.tokenize",
"sql.backslash.escapes",
"nsis.uservars",
"nsis.ignorecase"
]
def FindProperties(lexFile):
properties = {}
f = open(lexFile)
for l in f.readlines():
if ("GetProperty" in l or "DefineProperty" in l) and "\"" in l:
l = l.strip()
if not l.startswith("//"): # Drop comments
propertyName = l.split("\"")[1]
if propertyName.lower() == propertyName:
# Only allow lower case property names
if propertyName in knownIrregularProperties or \
propertyName.startswith("fold.") or \
propertyName.startswith("lexer."):
properties[propertyName] = 1
return properties
def FindPropertyDocumentation(lexFile):
documents = {}
f = open(lexFile)
name = ""
for l in f.readlines():
l = l.strip()
if "// property " in l:
propertyName = l.split()[2]
if propertyName.lower() == propertyName:
# Only allow lower case property names
name = propertyName
documents[name] = ""
elif "DefineProperty" in l and "\"" in l:
propertyName = l.split("\"")[1]
if propertyName.lower() == propertyName:
# Only allow lower case property names
name = propertyName
documents[name] = ""
elif name:
if l.startswith("//"):
if documents[name]:
documents[name] += " "
documents[name] += l[2:].strip()
elif l.startswith("\""):
l = l[1:].strip()
if l.endswith(";"):
l = l[:-1].strip()
if l.endswith(")"):
l = l[:-1].strip()
if l.endswith("\""):
l = l[:-1]
# Fix escaped double quotes
l = l.replace("\\\"", "\"")
documents[name] += l
else:
name = ""
for name in list(documents.keys()):
if documents[name] == "":
del documents[name]
return documents
def ciCompare(a,b):
return cmp(a.lower(), b.lower())
def ciKey(a):
return a.lower()
def sortListInsensitive(l):
try: # Try key function
l.sort(key=ciKey)
except TypeError: # Earlier version of Python, so use comparison function
l.sort(ciCompare)
def UpdateLineInFile(path, linePrefix, lineReplace):
lines = []
with open(path, "r") as f:
for l in f.readlines():
l = l.rstrip()
if l.startswith(linePrefix):
lines.append(lineReplace)
else:
lines.append(l)
contents = NATIVE.join(lines) + NATIVE
UpdateFile(path, contents)
def UpdateVersionNumbers(root):
with open(root + "scintilla/version.txt") as f:
version = f.read()
versionDotted = version[0] + '.' + version[1] + '.' + version[2]
versionCommad = version[0] + ', ' + version[1] + ', ' + version[2] + ', 0'
UpdateLineInFile(root + "scintilla/win32/ScintRes.rc", "#define VERSION_SCINTILLA",
"#define VERSION_SCINTILLA \"" + versionDotted + "\"")
UpdateLineInFile(root + "scintilla/win32/ScintRes.rc", "#define VERSION_WORDS",
"#define VERSION_WORDS " + versionCommad)
UpdateLineInFile(root + "scintilla/qt/ScintillaEditBase/ScintillaEditBase.pro",
"VERSION =",
"VERSION = " + versionDotted)
UpdateLineInFile(root + "scintilla/qt/ScintillaEdit/ScintillaEdit.pro",
"VERSION =",
"VERSION = " + versionDotted)
UpdateLineInFile(root + "scintilla/doc/ScintillaDownload.html", " Release",
" Release " + versionDotted)
UpdateLineInFile(root + "scintilla/doc/index.html",
' <font color="#FFCC99" size="3"> Release version',
' <font color="#FFCC99" size="3"> Release version ' + versionDotted + '<br />')
if os.path.exists(root + "scite"):
UpdateLineInFile(root + "scite/src/SciTE.h", "#define VERSION_SCITE",
"#define VERSION_SCITE \"" + versionDotted + "\"")
UpdateLineInFile(root + "scite/src/SciTE.h", "#define VERSION_WORDS",
"#define VERSION_WORDS " + versionCommad)
UpdateLineInFile(root + "scite/doc/SciTEDownload.html", " Release",
" Release " + versionDotted)
UpdateLineInFile(root + "scite/doc/SciTE.html",
' <font color="#FFCC99" size="3"> Release version',
' <font color="#FFCC99" size="3"> Release version ' + versionDotted + '<br />')
def RegenerateAll():
root="../../"
# Find all the lexer source code files
lexFilePaths = glob.glob(root + "scintilla/lexers/Lex*.cxx")
sortListInsensitive(lexFilePaths)
lexFiles = [os.path.basename(f)[:-4] for f in lexFilePaths]
print(lexFiles)
lexerModules = []
lexerProperties = {}
propertyDocuments = {}
for lexFile in lexFilePaths:
lexerModules.extend(FindModules(lexFile))
for k in FindProperties(lexFile).keys():
lexerProperties[k] = 1
documents = FindPropertyDocumentation(lexFile)
for k in documents.keys():
propertyDocuments[k] = documents[k]
sortListInsensitive(lexerModules)
lexerProperties = list(lexerProperties.keys())
sortListInsensitive(lexerProperties)
# Generate HTML to document each property
# This is done because tags can not be safely put inside comments in HTML
documentProperties = list(propertyDocuments.keys())
sortListInsensitive(documentProperties)
propertiesHTML = []
for k in documentProperties:
propertiesHTML.append("\t<tr id='property-%s'>\n\t<td>%s</td>\n\t<td>%s</td>\n\t</tr>" %
(k, k, propertyDocuments[k]))
# Find all the SciTE properties files
otherProps = ["abbrev.properties", "Embedded.properties", "SciTEGlobal.properties", "SciTE.properties"]
if os.path.exists(root + "scite"):
propFilePaths = glob.glob(root + "scite/src/*.properties")
sortListInsensitive(propFilePaths)
propFiles = [os.path.basename(f) for f in propFilePaths if os.path.basename(f) not in otherProps]
sortListInsensitive(propFiles)
print(propFiles)
Regenerate(root + "scintilla/src/Catalogue.cxx", "//", NATIVE, lexerModules)
Regenerate(root + "scintilla/win32/scintilla.mak", "#", NATIVE, lexFiles)
Regenerate(root + "scintilla/win32/scintilla_vc6.mak", "#", NATIVE, lexFiles)
if os.path.exists(root + "scite"):
Regenerate(root + "scite/win32/makefile", "#", NATIVE, propFiles)
Regenerate(root + "scite/win32/scite.mak", "#", NATIVE, propFiles)
Regenerate(root + "scite/src/SciTEProps.cxx", "//", NATIVE, lexerProperties)
Regenerate(root + "scite/doc/SciTEDoc.html", "<!--", NATIVE, propertiesHTML)
Generate(root + "scite/boundscheck/vcproj.gen",
root + "scite/boundscheck/SciTE.vcproj", "#", NATIVE, lexFiles)
UpdateVersionNumbers(root)
RegenerateAll()
| Python |
# -*- coding: utf-8 -*-
from __future__ import with_statement
import io, os, sys, unittest
if sys.platform == "win32":
import XiteWin as Xite
else:
import XiteQt as Xite
keywordsHTML = [
b"b body content head href html link meta "
b"name rel script strong title type xmlns",
b"function",
b"sub"
]
class TestLexers(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
def AsStyled(self):
text = self.ed.Contents()
data = io.BytesIO()
prevStyle = -1
for o in range(self.ed.Length):
styleNow = self.ed.GetStyleAt(o)
if styleNow != prevStyle:
styleBuf = "{%0d}" % styleNow
data.write(styleBuf.encode('utf-8'))
prevStyle = styleNow
data.write(text[o:o+1])
return data.getvalue()
def LexExample(self, name, lexerName, keywords=None):
if keywords is None:
keywords = []
self.ed.SetCodePage(65001)
self.ed.LexerLanguage = lexerName
bits = self.ed.StyleBitsNeeded
mask = 2 << bits - 1
self.ed.StyleBits = bits
for i in range(len(keywords)):
self.ed.SetKeyWords(i, keywords[i])
nameExample = os.path.join("examples", name)
namePrevious = nameExample +".styled"
nameNew = nameExample +".new"
with open(nameExample, "rb") as f:
prog = f.read()
BOM = b"\xEF\xBB\xBF"
if prog.startswith(BOM):
prog = prog[len(BOM):]
lenDocument = len(prog)
self.ed.AddText(lenDocument, prog)
self.ed.Colourise(0, lenDocument)
self.assertEquals(self.ed.EndStyled, lenDocument)
try:
with open(namePrevious, "rb") as f:
prevStyled = f.read()
except FileNotFoundError:
prevStyled = ""
progStyled = self.AsStyled()
if progStyled != prevStyled:
with open(nameNew, "wb") as f:
f.write(progStyled)
print(progStyled)
print(prevStyled)
self.assertEquals(progStyled, prevStyled)
# The whole file doesn't parse like it did before so don't try line by line
# as that is likely to fail many times.
return
# Try partial lexes from the start of every line which should all be identical.
for line in range(self.ed.LineCount):
lineStart = self.ed.PositionFromLine(line)
self.ed.StartStyling(lineStart, mask)
self.assertEquals(self.ed.EndStyled, lineStart)
self.ed.Colourise(lineStart, lenDocument)
progStyled = self.AsStyled()
if progStyled != prevStyled:
with open(nameNew, "wb") as f:
f.write(progStyled)
self.assertEquals(progStyled, prevStyled)
# Give up after one failure
return
def testCXX(self):
self.LexExample("x.cxx", b"cpp", [b"int"])
def testPython(self):
self.LexExample("x.py", b"python",
[b"class def else for if import in print return while"])
def testHTML(self):
self.LexExample("x.html", b"hypertext", keywordsHTML)
def testASP(self):
self.LexExample("x.asp", b"hypertext", keywordsHTML)
def testPHP(self):
self.LexExample("x.php", b"hypertext", keywordsHTML)
def testVB(self):
self.LexExample("x.vb", b"vb", [b"as dim or string"])
def testLua(self):
self.LexExample("x.lua", b"lua", [b"function end"])
def testRuby(self):
self.LexExample("x.rb", b"ruby", [b"class def end"])
def testPerl(self):
self.LexExample("x.pl", b"perl", [b"printf sleep use while"])
def testD(self):
self.LexExample("x.d", b"d",
[b"keyword1", b"keyword2", b"", b"keyword4", b"keyword5",
b"keyword6", b"keyword7"])
if __name__ == '__main__':
Xite.main("lexTests")
| Python |
# List many windows message numbers
msgs = {
"WM_ACTIVATE":6,
"WM_ACTIVATEAPP":28,
"WM_CAPTURECHANGED":533,
"WM_CHAR":258,
"WM_CLOSE":16,
"WM_CREATE":1,
"WM_COMMAND":273,
"WM_DESTROY":2,
"WM_ENTERSIZEMOVE":561,
"WM_ERASEBKGND":20,
"WM_EXITSIZEMOVE":562,
"WM_GETMINMAXINFO":36,
"WM_GETTEXT":13,
"WM_IME_SETCONTEXT":0x0281,
"WM_IME_NOTIFY":0x0282,
"WM_KEYDOWN":256,
"WM_KEYUP":257,
"WM_KILLFOCUS":8,
"WM_LBUTTONDOWN":513,
"WM_LBUTTONUP":514,
"WM_MBUTTONDOWN":519,
"WM_MBUTTONUP":520,
"WM_MBUTTONDBLCLK":521,
"WM_MOUSEACTIVATE":33,
"WM_MOUSEMOVE":512,
"WM_MOVE":3,
"WM_MOVING":534,
"WM_NCACTIVATE":134,
"WM_NCCALCSIZE":131,
"WM_NCCREATE":129,
"WM_NCDESTROY":130,
"WM_NCHITTEST":132,
"WM_NCLBUTTONDBLCLK":163,
"WM_NCLBUTTONDOWN":161,
"WM_NCLBUTTONUP":162,
"WM_NCMOUSEMOVE":160,
"WM_NCPAINT":133,
"WM_PAINT":15,
"WM_PARENTNOTIFY":528,
"WM_SETCURSOR":32,
"WM_SETFOCUS":7,
"WM_SETFONT":48,
"WM_SETTEXT":12,
"WM_SHOWWINDOW":24,
"WM_SIZE":5,
"WM_SIZING":532,
"WM_SYNCPAINT":136,
"WM_SYSCOMMAND":274,
"WM_SYSKEYDOWN":260,
"WM_TIMER":275,
"WM_USER":1024,
"WM_USER+1":1025,
"WM_WINDOWPOSCHANGED":71,
"WM_WINDOWPOSCHANGING":70,
}
sgsm={}
for k,v in msgs.items():
sgsm[v] = k
| Python |
# -*- coding: utf-8 -*-
from __future__ import with_statement
from __future__ import unicode_literals
import codecs, ctypes, os, sys, unittest
if sys.platform == "win32":
import XiteWin as Xite
else:
import XiteQt as Xite
class TestSimple(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
def testLength(self):
self.assertEquals(self.ed.Length, 0)
def testAddText(self):
self.ed.AddText(1, b"x")
self.assertEquals(self.ed.Length, 1)
self.assertEquals(self.ed.GetCharAt(0), ord("x"))
self.assertEquals(self.ed.GetStyleAt(0), 0)
self.ed.ClearAll()
self.assertEquals(self.ed.Length, 0)
def testDeleteRange(self):
self.ed.AddText(5, b"abcde")
self.assertEquals(self.ed.Length, 5)
self.ed.DeleteRange(1, 2)
self.assertEquals(self.ed.Length, 3)
self.assertEquals(self.ed.Contents(), b"ade")
def testAddStyledText(self):
self.assertEquals(self.ed.EndStyled, 0)
self.ed.AddStyledText(2, b"x\002")
self.assertEquals(self.ed.Length, 1)
self.assertEquals(self.ed.GetCharAt(0), ord("x"))
self.assertEquals(self.ed.GetStyleAt(0), 2)
self.assertEquals(self.ed.StyledTextRange(0, 1), b"x\002")
self.ed.ClearDocumentStyle()
self.assertEquals(self.ed.Length, 1)
self.assertEquals(self.ed.GetCharAt(0), ord("x"))
self.assertEquals(self.ed.GetStyleAt(0), 0)
self.assertEquals(self.ed.StyledTextRange(0, 1), b"x\0")
def testStyling(self):
self.assertEquals(self.ed.EndStyled, 0)
self.ed.AddStyledText(4, b"x\002y\003")
self.assertEquals(self.ed.StyledTextRange(0, 2), b"x\002y\003")
self.ed.StartStyling(0,0xf)
self.ed.SetStyling(1, 5)
self.assertEquals(self.ed.StyledTextRange(0, 2), b"x\005y\003")
# Set the mask so 0 bit changed but not 2 bit
self.ed.StartStyling(0,0x1)
self.ed.SetStyling(1, 0)
self.assertEquals(self.ed.StyledTextRange(0, 2), b"x\004y\003")
self.ed.StartStyling(0,0xff)
self.ed.SetStylingEx(2, b"\100\101")
self.assertEquals(self.ed.StyledTextRange(0, 2), b"x\100y\101")
def testPosition(self):
self.assertEquals(self.ed.CurrentPos, 0)
self.assertEquals(self.ed.Anchor, 0)
self.ed.AddText(1, b"x")
# Caret has automatically moved
self.assertEquals(self.ed.CurrentPos, 1)
self.assertEquals(self.ed.Anchor, 1)
self.ed.SelectAll()
self.assertEquals(self.ed.CurrentPos, 0)
self.assertEquals(self.ed.Anchor, 1)
self.ed.Anchor = 0
self.assertEquals(self.ed.Anchor, 0)
# Check line positions
self.assertEquals(self.ed.PositionFromLine(0), 0)
self.assertEquals(self.ed.GetLineEndPosition(0), 1)
self.assertEquals(self.ed.PositionFromLine(1), 1)
self.ed.CurrentPos = 1
self.assertEquals(self.ed.Anchor, 0)
self.assertEquals(self.ed.CurrentPos, 1)
def testBeyonEnd(self):
self.ed.AddText(1, b"x")
self.assertEquals(self.ed.GetLineEndPosition(0), 1)
self.assertEquals(self.ed.GetLineEndPosition(1), 1)
self.assertEquals(self.ed.GetLineEndPosition(2), 1)
def testSelection(self):
self.assertEquals(self.ed.CurrentPos, 0)
self.assertEquals(self.ed.Anchor, 0)
self.assertEquals(self.ed.SelectionStart, 0)
self.assertEquals(self.ed.SelectionEnd, 0)
self.ed.AddText(1, b"x")
self.ed.SelectionStart = 0
self.assertEquals(self.ed.CurrentPos, 1)
self.assertEquals(self.ed.Anchor, 0)
self.assertEquals(self.ed.SelectionStart, 0)
self.assertEquals(self.ed.SelectionEnd, 1)
self.ed.SelectionStart = 1
self.assertEquals(self.ed.CurrentPos, 1)
self.assertEquals(self.ed.Anchor, 1)
self.assertEquals(self.ed.SelectionStart, 1)
self.assertEquals(self.ed.SelectionEnd, 1)
self.ed.SelectionEnd = 0
self.assertEquals(self.ed.CurrentPos, 0)
self.assertEquals(self.ed.Anchor, 0)
def testSetSelection(self):
self.ed.AddText(4, b"abcd")
self.ed.SetSel(1, 3)
self.assertEquals(self.ed.SelectionStart, 1)
self.assertEquals(self.ed.SelectionEnd, 3)
result = self.ed.GetSelText(0)
self.assertEquals(result, b"bc\0")
self.ed.ReplaceSel(0, b"1234")
self.assertEquals(self.ed.Length, 6)
self.assertEquals(self.ed.Contents(), b"a1234d")
def testReadOnly(self):
self.ed.AddText(1, b"x")
self.assertEquals(self.ed.ReadOnly, 0)
self.assertEquals(self.ed.Contents(), b"x")
self.ed.ReadOnly = 1
self.assertEquals(self.ed.ReadOnly, 1)
self.ed.AddText(1, b"x")
self.assertEquals(self.ed.Contents(), b"x")
self.ed.ReadOnly = 0
self.ed.AddText(1, b"x")
self.assertEquals(self.ed.Contents(), b"xx")
self.ed.Null()
self.assertEquals(self.ed.Contents(), b"xx")
def testAddLine(self):
data = b"x" * 70 + b"\n"
for i in range(5):
self.ed.AddText(len(data), data)
self.xite.DoEvents()
self.assertEquals(self.ed.LineCount, i + 2)
self.assert_(self.ed.Length > 0)
def testInsertText(self):
data = b"xy"
self.ed.InsertText(0, data)
self.assertEquals(self.ed.Length, 2)
self.assertEquals(data, self.ed.ByteRange(0,2))
self.ed.InsertText(1, data)
# Should now be "xxyy"
self.assertEquals(self.ed.Length, 4)
self.assertEquals(b"xxyy", self.ed.ByteRange(0,4))
def testInsertNul(self):
data = b"\0"
self.ed.AddText(1, data)
self.assertEquals(self.ed.Length, 1)
self.assertEquals(data, self.ed.ByteRange(0,1))
def testUndoRedo(self):
data = b"xy"
self.assertEquals(self.ed.Modify, 0)
self.assertEquals(self.ed.UndoCollection, 1)
self.assertEquals(self.ed.CanRedo(), 0)
self.assertEquals(self.ed.CanUndo(), 0)
self.ed.InsertText(0, data)
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.ed.Modify, 1)
self.assertEquals(self.ed.CanRedo(), 0)
self.assertEquals(self.ed.CanUndo(), 1)
self.ed.Undo()
self.assertEquals(self.ed.Length, 0)
self.assertEquals(self.ed.Modify, 0)
self.assertEquals(self.ed.CanRedo(), 1)
self.assertEquals(self.ed.CanUndo(), 0)
self.ed.Redo()
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.ed.Modify, 1)
self.assertEquals(data, self.ed.Contents())
self.assertEquals(self.ed.CanRedo(), 0)
self.assertEquals(self.ed.CanUndo(), 1)
def testUndoSavePoint(self):
data = b"xy"
self.assertEquals(self.ed.Modify, 0)
self.ed.InsertText(0, data)
self.assertEquals(self.ed.Modify, 1)
self.ed.SetSavePoint()
self.assertEquals(self.ed.Modify, 0)
self.ed.InsertText(0, data)
self.assertEquals(self.ed.Modify, 1)
def testUndoCollection(self):
data = b"xy"
self.assertEquals(self.ed.UndoCollection, 1)
self.ed.UndoCollection = 0
self.assertEquals(self.ed.UndoCollection, 0)
self.ed.InsertText(0, data)
self.assertEquals(self.ed.CanRedo(), 0)
self.assertEquals(self.ed.CanUndo(), 0)
self.ed.UndoCollection = 1
def testGetColumn(self):
self.ed.AddText(1, b"x")
self.assertEquals(self.ed.GetColumn(0), 0)
self.assertEquals(self.ed.GetColumn(1), 1)
# Next line caused infinite loop in 1.71
self.assertEquals(self.ed.GetColumn(2), 1)
self.assertEquals(self.ed.GetColumn(3), 1)
def testTabWidth(self):
self.assertEquals(self.ed.TabWidth, 8)
self.ed.AddText(3, b"x\tb")
self.assertEquals(self.ed.GetColumn(0), 0)
self.assertEquals(self.ed.GetColumn(1), 1)
self.assertEquals(self.ed.GetColumn(2), 8)
for col in range(10):
if col == 0:
self.assertEquals(self.ed.FindColumn(0, col), 0)
elif col == 1:
self.assertEquals(self.ed.FindColumn(0, col), 1)
elif col == 8:
self.assertEquals(self.ed.FindColumn(0, col), 2)
elif col == 9:
self.assertEquals(self.ed.FindColumn(0, col), 3)
else:
self.assertEquals(self.ed.FindColumn(0, col), 1)
self.ed.TabWidth = 4
self.assertEquals(self.ed.TabWidth, 4)
self.assertEquals(self.ed.GetColumn(0), 0)
self.assertEquals(self.ed.GetColumn(1), 1)
self.assertEquals(self.ed.GetColumn(2), 4)
def testIndent(self):
self.assertEquals(self.ed.Indent, 0)
self.assertEquals(self.ed.UseTabs, 1)
self.ed.Indent = 8
self.ed.UseTabs = 0
self.assertEquals(self.ed.Indent, 8)
self.assertEquals(self.ed.UseTabs, 0)
self.ed.AddText(3, b"x\tb")
self.assertEquals(self.ed.GetLineIndentation(0), 0)
self.ed.InsertText(0, b" ")
self.assertEquals(self.ed.GetLineIndentation(0), 1)
self.assertEquals(self.ed.GetLineIndentPosition(0), 1)
self.assertEquals(self.ed.Contents(), b" x\tb")
self.ed.SetLineIndentation(0,2)
self.assertEquals(self.ed.Contents(), b" x\tb")
self.assertEquals(self.ed.GetLineIndentPosition(0), 2)
self.ed.UseTabs = 1
self.ed.SetLineIndentation(0,8)
self.assertEquals(self.ed.Contents(), b"\tx\tb")
self.assertEquals(self.ed.GetLineIndentPosition(0), 1)
def testGetCurLine(self):
self.ed.AddText(1, b"x")
data = ctypes.create_string_buffer(b"\0" * 100)
caret = self.ed.GetCurLine(len(data), data)
self.assertEquals(caret, 1)
self.assertEquals(data.value, b"x")
def testGetLine(self):
self.ed.AddText(1, b"x")
data = ctypes.create_string_buffer(b"\0" * 100)
self.ed.GetLine(0, data)
self.assertEquals(data.value, b"x")
def testLineEnds(self):
self.ed.AddText(3, b"x\ny")
self.assertEquals(self.ed.GetLineEndPosition(0), 1)
self.assertEquals(self.ed.GetLineEndPosition(1), 3)
self.assertEquals(self.ed.LineLength(0), 2)
self.assertEquals(self.ed.LineLength(1), 1)
if sys.platform == "win32":
self.assertEquals(self.ed.EOLMode, self.ed.SC_EOL_CRLF)
else:
self.assertEquals(self.ed.EOLMode, self.ed.SC_EOL_LF)
lineEnds = [b"\r\n", b"\r", b"\n"]
for lineEndType in [self.ed.SC_EOL_CR, self.ed.SC_EOL_LF, self.ed.SC_EOL_CRLF]:
self.ed.EOLMode = lineEndType
self.assertEquals(self.ed.EOLMode, lineEndType)
self.ed.ConvertEOLs(lineEndType)
self.assertEquals(self.ed.Contents(), b"x" + lineEnds[lineEndType] + b"y")
self.assertEquals(self.ed.LineLength(0), 1 + len(lineEnds[lineEndType]))
# Several tests for unicode line ends U+2028 and U+2029
def testUnicodeLineEnds(self):
# Add two lines separated with U+2028 and ensure it is seen as two lines
# Then remove U+2028 and should be just 1 lines
self.ed.Lexer = self.ed.SCLEX_CPP
self.ed.SetCodePage(65001)
self.ed.SetLineEndTypesAllowed(1)
self.ed.AddText(5, b"x\xe2\x80\xa8y")
self.assertEquals(self.ed.LineCount, 2)
self.assertEquals(self.ed.GetLineEndPosition(0), 1)
self.assertEquals(self.ed.GetLineEndPosition(1), 5)
self.assertEquals(self.ed.LineLength(0), 4)
self.assertEquals(self.ed.LineLength(1), 1)
self.ed.TargetStart = 1
self.ed.TargetEnd = 4
self.ed.ReplaceTarget(0, b"")
self.assertEquals(self.ed.LineCount, 1)
self.assertEquals(self.ed.LineLength(0), 2)
self.assertEquals(self.ed.GetLineEndPosition(0), 2)
self.assertEquals(self.ed.LineEndTypesSupported, 1)
def testUnicodeLineEndsWithCodePage0(self):
# Try the Unicode line ends when not in Unicode mode -> should remain 1 line
self.ed.SetCodePage(0)
self.ed.AddText(5, b"x\xe2\x80\xa8y")
self.assertEquals(self.ed.LineCount, 1)
self.ed.AddText(4, b"x\xc2\x85y")
self.assertEquals(self.ed.LineCount, 1)
def testUnicodeLineEndsSwitchToUnicodeAndBack(self):
# Add the Unicode line ends when not in Unicode mode
self.ed.SetCodePage(0)
self.ed.AddText(5, b"x\xe2\x80\xa8y")
self.assertEquals(self.ed.LineCount, 1)
# Into UTF-8 mode - should now be interpreting as two lines
self.ed.Lexer = self.ed.SCLEX_CPP
self.ed.SetCodePage(65001)
self.ed.SetLineEndTypesAllowed(1)
self.assertEquals(self.ed.LineCount, 2)
# Back to code page 0 and 1 line
self.ed.SetCodePage(0)
self.assertEquals(self.ed.LineCount, 1)
def testUFragmentedEOLCompletion(self):
# Add 2 starting bytes of UTF-8 line end then complete it
self.ed.ClearAll()
self.ed.AddText(4, b"x\xe2\x80y")
self.assertEquals(self.ed.LineCount, 1)
self.assertEquals(self.ed.GetLineEndPosition(0), 4)
self.ed.SetSel(3,3)
self.ed.AddText(1, b"\xa8")
self.assertEquals(self.ed.Contents(), b"x\xe2\x80\xa8y")
self.assertEquals(self.ed.LineCount, 2)
# Add 1 starting bytes of UTF-8 line end then complete it
self.ed.ClearAll()
self.ed.AddText(3, b"x\xe2y")
self.assertEquals(self.ed.LineCount, 1)
self.assertEquals(self.ed.GetLineEndPosition(0), 3)
self.ed.SetSel(2,2)
self.ed.AddText(2, b"\x80\xa8")
self.assertEquals(self.ed.Contents(), b"x\xe2\x80\xa8y")
self.assertEquals(self.ed.LineCount, 2)
def testUFragmentedEOLStart(self):
# Add end of UTF-8 line end then insert start
self.ed.Lexer = self.ed.SCLEX_CPP
self.ed.SetCodePage(65001)
self.ed.SetLineEndTypesAllowed(1)
self.assertEquals(self.ed.LineCount, 1)
self.ed.AddText(4, b"x\x80\xa8y")
self.assertEquals(self.ed.LineCount, 1)
self.ed.SetSel(1,1)
self.ed.AddText(1, b"\xe2")
self.assertEquals(self.ed.LineCount, 2)
def testUBreakApartEOL(self):
# Add two lines separated by U+2029 then remove and add back each byte ensuring
# only one line after each removal of any byte in line end and 2 lines after reinsertion
self.ed.Lexer = self.ed.SCLEX_CPP
self.ed.SetCodePage(65001)
self.ed.SetLineEndTypesAllowed(1)
text = b"x\xe2\x80\xa9y";
self.ed.AddText(5, text)
self.assertEquals(self.ed.LineCount, 2)
for i in range(len(text)):
self.ed.TargetStart = i
self.ed.TargetEnd = i + 1
self.ed.ReplaceTarget(0, b"")
if i in [0, 4]:
# Removing text characters does not change number of lines
self.assertEquals(self.ed.LineCount, 2)
else:
# Removing byte from line end, removes 1 line
self.assertEquals(self.ed.LineCount, 1)
self.ed.TargetEnd = i
self.ed.ReplaceTarget(1, text[i:i+1])
self.assertEquals(self.ed.LineCount, 2)
def testURemoveEOLFragment(self):
# Add UTF-8 line end then delete each byte causing line end to disappear
self.ed.Lexer = self.ed.SCLEX_CPP
self.ed.SetCodePage(65001)
self.ed.SetLineEndTypesAllowed(1)
for i in range(3):
self.ed.ClearAll()
self.ed.AddText(5, b"x\xe2\x80\xa8y")
self.assertEquals(self.ed.LineCount, 2)
self.ed.TargetStart = i+1
self.ed.TargetEnd = i+2
self.ed.ReplaceTarget(0, b"")
self.assertEquals(self.ed.LineCount, 1)
# Several tests for unicode NEL line ends U+0085
def testNELLineEnds(self):
# Add two lines separated with U+0085 and ensure it is seen as two lines
# Then remove U+0085 and should be just 1 lines
self.ed.Lexer = self.ed.SCLEX_CPP
self.ed.SetCodePage(65001)
self.ed.SetLineEndTypesAllowed(1)
self.ed.AddText(4, b"x\xc2\x85y")
self.assertEquals(self.ed.LineCount, 2)
self.assertEquals(self.ed.GetLineEndPosition(0), 1)
self.assertEquals(self.ed.GetLineEndPosition(1), 4)
self.assertEquals(self.ed.LineLength(0), 3)
self.assertEquals(self.ed.LineLength(1), 1)
self.ed.TargetStart = 1
self.ed.TargetEnd = 3
self.ed.ReplaceTarget(0, b"")
self.assertEquals(self.ed.LineCount, 1)
self.assertEquals(self.ed.LineLength(0), 2)
self.assertEquals(self.ed.GetLineEndPosition(0), 2)
def testNELFragmentedEOLCompletion(self):
# Add starting byte of UTF-8 NEL then complete it
self.ed.AddText(3, b"x\xc2y")
self.assertEquals(self.ed.LineCount, 1)
self.assertEquals(self.ed.GetLineEndPosition(0), 3)
self.ed.SetSel(2,2)
self.ed.AddText(1, b"\x85")
self.assertEquals(self.ed.Contents(), b"x\xc2\x85y")
self.assertEquals(self.ed.LineCount, 2)
def testNELFragmentedEOLStart(self):
# Add end of UTF-8 NEL then insert start
self.ed.Lexer = self.ed.SCLEX_CPP
self.ed.SetCodePage(65001)
self.ed.SetLineEndTypesAllowed(1)
self.assertEquals(self.ed.LineCount, 1)
self.ed.AddText(4, b"x\x85y")
self.assertEquals(self.ed.LineCount, 1)
self.ed.SetSel(1,1)
self.ed.AddText(1, b"\xc2")
self.assertEquals(self.ed.LineCount, 2)
def testNELBreakApartEOL(self):
# Add two lines separated by U+0085 then remove and add back each byte ensuring
# only one line after each removal of any byte in line end and 2 lines after reinsertion
self.ed.Lexer = self.ed.SCLEX_CPP
self.ed.SetCodePage(65001)
self.ed.SetLineEndTypesAllowed(1)
text = b"x\xc2\x85y";
self.ed.AddText(4, text)
self.assertEquals(self.ed.LineCount, 2)
for i in range(len(text)):
self.ed.TargetStart = i
self.ed.TargetEnd = i + 1
self.ed.ReplaceTarget(0, b"")
if i in [0, 3]:
# Removing text characters does not change number of lines
self.assertEquals(self.ed.LineCount, 2)
else:
# Removing byte from line end, removes 1 line
self.assertEquals(self.ed.LineCount, 1)
self.ed.TargetEnd = i
self.ed.ReplaceTarget(1, text[i:i+1])
self.assertEquals(self.ed.LineCount, 2)
def testNELRemoveEOLFragment(self):
# Add UTF-8 NEL then delete each byte causing line end to disappear
self.ed.SetCodePage(65001)
for i in range(2):
self.ed.ClearAll()
self.ed.AddText(4, b"x\xc2\x85y")
self.assertEquals(self.ed.LineCount, 2)
self.ed.TargetStart = i+1
self.ed.TargetEnd = i+2
self.ed.ReplaceTarget(0, b"")
self.assertEquals(self.ed.LineCount, 1)
def testGoto(self):
self.ed.AddText(5, b"a\nb\nc")
self.assertEquals(self.ed.CurrentPos, 5)
self.ed.GotoLine(1)
self.assertEquals(self.ed.CurrentPos, 2)
self.ed.GotoPos(4)
self.assertEquals(self.ed.CurrentPos, 4)
def testCutCopyPaste(self):
self.ed.AddText(5, b"a1b2c")
self.ed.SetSel(1,3)
self.ed.Cut()
self.xite.DoEvents()
self.assertEquals(self.ed.CanPaste(), 1)
self.ed.SetSel(0, 0)
self.ed.Paste()
self.assertEquals(self.ed.Contents(), b"1ba2c")
self.ed.SetSel(4,5)
self.ed.Copy()
self.ed.SetSel(1,3)
self.ed.Paste()
self.assertEquals(self.ed.Contents(), b"1c2c")
self.ed.SetSel(2,4)
self.ed.Clear()
self.assertEquals(self.ed.Contents(), b"1c")
def testCopyAllowLine(self):
self.xite.DoEvents()
lineEndType = self.ed.EOLMode
self.ed.EOLMode = self.ed.SC_EOL_LF
self.ed.AddText(5, b"a1\nb2")
self.ed.SetSel(1,1)
self.ed.CopyAllowLine()
self.xite.DoEvents()
self.assertEquals(self.ed.CanPaste(), 1)
self.ed.SetSel(0, 0)
self.ed.Paste()
self.ed.EOLMode = lineEndType
self.assertEquals(self.ed.Contents(), b"a1\na1\nb2")
def testDuplicate(self):
self.ed.AddText(3, b"1b2")
self.ed.SetSel(1,2)
self.ed.SelectionDuplicate()
self.assertEquals(self.ed.Contents(), b"1bb2")
def testTransposeLines(self):
self.ed.AddText(8, b"a1\nb2\nc3")
self.ed.SetSel(3,3)
self.ed.LineTranspose()
self.assertEquals(self.ed.Contents(), b"b2\na1\nc3")
def testGetSet(self):
self.ed.SetContents(b"abc")
self.assertEquals(self.ed.TextLength, 3)
result = ctypes.create_string_buffer(b"\0" * 5)
length = self.ed.GetText(4, result)
self.assertEquals(result.value, b"abc")
def testAppend(self):
self.ed.SetContents(b"abc")
self.assertEquals(self.ed.SelectionStart, 0)
self.assertEquals(self.ed.SelectionEnd, 0)
text = b"12"
self.ed.AppendText(len(text), text)
self.assertEquals(self.ed.SelectionStart, 0)
self.assertEquals(self.ed.SelectionEnd, 0)
self.assertEquals(self.ed.Contents(), b"abc12")
def testTarget(self):
self.ed.SetContents(b"abcd")
self.ed.TargetStart = 1
self.ed.TargetEnd = 3
self.assertEquals(self.ed.TargetStart, 1)
self.assertEquals(self.ed.TargetEnd, 3)
rep = b"321"
self.ed.ReplaceTarget(len(rep), rep)
self.assertEquals(self.ed.Contents(), b"a321d")
self.ed.SearchFlags = self.ed.SCFIND_REGEXP
self.assertEquals(self.ed.SearchFlags, self.ed.SCFIND_REGEXP)
searchString = b"\([1-9]+\)"
pos = self.ed.SearchInTarget(len(searchString), searchString)
self.assertEquals(1, pos)
tagString = self.ed.GetTag(1)
self.assertEquals(tagString, b"321")
rep = b"\\1"
self.ed.TargetStart = 0
self.ed.TargetEnd = 0
self.ed.ReplaceTargetRE(len(rep), rep)
self.assertEquals(self.ed.Contents(), b"321a321d")
self.ed.SetSel(4,5)
self.ed.TargetFromSelection()
self.assertEquals(self.ed.TargetStart, 4)
self.assertEquals(self.ed.TargetEnd, 5)
def testTargetEscape(self):
# Checks that a literal \ can be in the replacement. Bug #2959876
self.ed.SetContents(b"abcd")
self.ed.TargetStart = 1
self.ed.TargetEnd = 3
rep = b"\\\\n"
self.ed.ReplaceTargetRE(len(rep), rep)
self.assertEquals(self.ed.Contents(), b"a\\nd")
def testPointsAndPositions(self):
self.ed.AddText(1, b"x")
# Start of text
self.assertEquals(self.ed.PositionFromPoint(0,0), 0)
# End of text
self.assertEquals(self.ed.PositionFromPoint(0,100), 1)
def testLinePositions(self):
text = b"ab\ncd\nef"
nl = b"\n"
if sys.version_info[0] == 3:
nl = ord(b"\n")
self.ed.AddText(len(text), text)
self.assertEquals(self.ed.LineFromPosition(-1), 0)
line = 0
for pos in range(len(text)+1):
self.assertEquals(self.ed.LineFromPosition(pos), line)
if pos < len(text) and text[pos] == nl:
line += 1
def testWordPositions(self):
text = b"ab cd\tef"
self.ed.AddText(len(text), text)
self.assertEquals(self.ed.WordStartPosition(3, 0), 2)
self.assertEquals(self.ed.WordStartPosition(4, 0), 3)
self.assertEquals(self.ed.WordStartPosition(5, 0), 3)
self.assertEquals(self.ed.WordStartPosition(6, 0), 5)
self.assertEquals(self.ed.WordEndPosition(2, 0), 3)
self.assertEquals(self.ed.WordEndPosition(3, 0), 5)
self.assertEquals(self.ed.WordEndPosition(4, 0), 5)
self.assertEquals(self.ed.WordEndPosition(5, 0), 6)
self.assertEquals(self.ed.WordEndPosition(6, 0), 8)
MODI = 1
UNDO = 2
REDO = 4
class TestContainerUndo(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
self.data = b"xy"
def UndoState(self):
return (MODI if self.ed.Modify else 0) | \
(UNDO if self.ed.CanUndo() else 0) | \
(REDO if self.ed.CanRedo() else 0)
def testContainerActNoCoalesce(self):
self.ed.InsertText(0, self.data)
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.AddUndoAction(5, 0)
self.ed.Undo()
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO | REDO)
self.ed.Redo()
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.Undo()
def testContainerActCoalesce(self):
self.ed.InsertText(0, self.data)
self.ed.AddUndoAction(5, 1)
self.ed.Undo()
self.assertEquals(self.ed.Length, 0)
self.assertEquals(self.UndoState(), REDO)
self.ed.Redo()
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO)
def testContainerMultiStage(self):
self.ed.InsertText(0, self.data)
self.ed.AddUndoAction(5, 1)
self.ed.AddUndoAction(5, 1)
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.Undo()
self.assertEquals(self.ed.Length, 0)
self.assertEquals(self.UndoState(), REDO)
self.ed.Redo()
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.AddUndoAction(5, 1)
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.Undo()
self.assertEquals(self.ed.Length, 0)
self.assertEquals(self.UndoState(), REDO)
def testContainerMultiStageNoText(self):
self.ed.AddUndoAction(5, 1)
self.ed.AddUndoAction(5, 1)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.Undo()
self.assertEquals(self.UndoState(), REDO)
self.ed.Redo()
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.AddUndoAction(5, 1)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.Undo()
self.assertEquals(self.UndoState(), REDO)
def testContainerActCoalesceEnd(self):
self.ed.AddUndoAction(5, 1)
self.assertEquals(self.ed.Length, 0)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.InsertText(0, self.data)
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.Undo()
self.assertEquals(self.ed.Length, 0)
self.assertEquals(self.UndoState(), REDO)
self.ed.Redo()
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO)
def testContainerBetweenInsertAndInsert(self):
self.assertEquals(self.ed.Length, 0)
self.ed.InsertText(0, self.data)
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.AddUndoAction(5, 1)
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.InsertText(2, self.data)
self.assertEquals(self.ed.Length, 4)
self.assertEquals(self.UndoState(), MODI | UNDO)
# Undoes both insertions and the containerAction in the middle
self.ed.Undo()
self.assertEquals(self.ed.Length, 0)
self.assertEquals(self.UndoState(), REDO)
def testContainerNoCoalesceBetweenInsertAndInsert(self):
self.assertEquals(self.ed.Length, 0)
self.ed.InsertText(0, self.data)
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.AddUndoAction(5, 0)
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.InsertText(2, self.data)
self.assertEquals(self.ed.Length, 4)
self.assertEquals(self.UndoState(), MODI | UNDO)
# Undo last insertion
self.ed.Undo()
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO | REDO)
# Undo container
self.ed.Undo()
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO | REDO)
# Undo first insertion
self.ed.Undo()
self.assertEquals(self.ed.Length, 0)
self.assertEquals(self.UndoState(), REDO)
def testContainerBetweenDeleteAndDelete(self):
self.ed.InsertText(0, self.data)
self.ed.EmptyUndoBuffer()
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), 0)
self.ed.SetSel(2,2)
self.ed.DeleteBack()
self.assertEquals(self.ed.Length, 1)
self.ed.AddUndoAction(5, 1)
self.ed.DeleteBack()
self.assertEquals(self.ed.Length, 0)
# Undoes both deletions and the containerAction in the middle
self.ed.Undo()
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), REDO)
def testContainerBetweenInsertAndDelete(self):
self.assertEquals(self.ed.Length, 0)
self.ed.InsertText(0, self.data)
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.AddUndoAction(5, 1)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.SetSel(0,1)
self.ed.Cut()
self.assertEquals(self.ed.Length, 1)
self.assertEquals(self.UndoState(), MODI | UNDO)
self.ed.Undo() # Only undoes the deletion
self.assertEquals(self.ed.Length, 2)
self.assertEquals(self.UndoState(), MODI | UNDO | REDO)
class TestKeyCommands(unittest.TestCase):
""" These commands are normally assigned to keys and take no arguments """
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
def selRange(self):
return self.ed.CurrentPos, self.ed.Anchor
def testLineMove(self):
self.ed.AddText(8, b"x1\ny2\nz3")
self.ed.SetSel(0,0)
self.ed.ChooseCaretX()
self.ed.LineDown()
self.ed.LineDown()
self.assertEquals(self.selRange(), (6, 6))
self.ed.LineUp()
self.assertEquals(self.selRange(), (3, 3))
self.ed.LineDownExtend()
self.assertEquals(self.selRange(), (6, 3))
self.ed.LineUpExtend()
self.ed.LineUpExtend()
self.assertEquals(self.selRange(), (0, 3))
def testCharMove(self):
self.ed.AddText(8, b"x1\ny2\nz3")
self.ed.SetSel(0,0)
self.ed.CharRight()
self.ed.CharRight()
self.assertEquals(self.selRange(), (2, 2))
self.ed.CharLeft()
self.assertEquals(self.selRange(), (1, 1))
self.ed.CharRightExtend()
self.assertEquals(self.selRange(), (2, 1))
self.ed.CharLeftExtend()
self.ed.CharLeftExtend()
self.assertEquals(self.selRange(), (0, 1))
def testWordMove(self):
self.ed.AddText(10, b"a big boat")
self.ed.SetSel(3,3)
self.ed.WordRight()
self.ed.WordRight()
self.assertEquals(self.selRange(), (10, 10))
self.ed.WordLeft()
self.assertEquals(self.selRange(), (6, 6))
self.ed.WordRightExtend()
self.assertEquals(self.selRange(), (10, 6))
self.ed.WordLeftExtend()
self.ed.WordLeftExtend()
self.assertEquals(self.selRange(), (2, 6))
def testHomeEndMove(self):
self.ed.AddText(10, b"a big boat")
self.ed.SetSel(3,3)
self.ed.Home()
self.assertEquals(self.selRange(), (0, 0))
self.ed.LineEnd()
self.assertEquals(self.selRange(), (10, 10))
self.ed.SetSel(3,3)
self.ed.HomeExtend()
self.assertEquals(self.selRange(), (0, 3))
self.ed.LineEndExtend()
self.assertEquals(self.selRange(), (10, 3))
def testStartEndMove(self):
self.ed.AddText(10, b"a\nbig\nboat")
self.ed.SetSel(3,3)
self.ed.DocumentStart()
self.assertEquals(self.selRange(), (0, 0))
self.ed.DocumentEnd()
self.assertEquals(self.selRange(), (10, 10))
self.ed.SetSel(3,3)
self.ed.DocumentStartExtend()
self.assertEquals(self.selRange(), (0, 3))
self.ed.DocumentEndExtend()
self.assertEquals(self.selRange(), (10, 3))
class TestMarkers(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
self.ed.AddText(5, b"x\ny\nz")
def testMarker(self):
handle = self.ed.MarkerAdd(1,1)
self.assertEquals(self.ed.MarkerLineFromHandle(handle), 1)
self.ed.MarkerDelete(1,1)
self.assertEquals(self.ed.MarkerLineFromHandle(handle), -1)
def testTwiceAddedDelete(self):
handle = self.ed.MarkerAdd(1,1)
self.assertEquals(self.ed.MarkerGet(1), 2)
handle2 = self.ed.MarkerAdd(1,1)
self.assertEquals(self.ed.MarkerGet(1), 2)
self.ed.MarkerDelete(1,1)
self.assertEquals(self.ed.MarkerGet(1), 2)
self.ed.MarkerDelete(1,1)
self.assertEquals(self.ed.MarkerGet(1), 0)
def testMarkerDeleteAll(self):
h1 = self.ed.MarkerAdd(0,1)
h2 = self.ed.MarkerAdd(1,2)
self.assertEquals(self.ed.MarkerLineFromHandle(h1), 0)
self.assertEquals(self.ed.MarkerLineFromHandle(h2), 1)
self.ed.MarkerDeleteAll(1)
self.assertEquals(self.ed.MarkerLineFromHandle(h1), -1)
self.assertEquals(self.ed.MarkerLineFromHandle(h2), 1)
self.ed.MarkerDeleteAll(-1)
self.assertEquals(self.ed.MarkerLineFromHandle(h1), -1)
self.assertEquals(self.ed.MarkerLineFromHandle(h2), -1)
def testMarkerDeleteHandle(self):
handle = self.ed.MarkerAdd(0,1)
self.assertEquals(self.ed.MarkerLineFromHandle(handle), 0)
self.ed.MarkerDeleteHandle(handle)
self.assertEquals(self.ed.MarkerLineFromHandle(handle), -1)
def testMarkerBits(self):
self.assertEquals(self.ed.MarkerGet(0), 0)
self.ed.MarkerAdd(0,1)
self.assertEquals(self.ed.MarkerGet(0), 2)
self.ed.MarkerAdd(0,2)
self.assertEquals(self.ed.MarkerGet(0), 6)
def testMarkerAddSet(self):
self.assertEquals(self.ed.MarkerGet(0), 0)
self.ed.MarkerAddSet(0,5)
self.assertEquals(self.ed.MarkerGet(0), 5)
self.ed.MarkerDeleteAll(-1)
def testMarkerNext(self):
self.assertEquals(self.ed.MarkerNext(0, 2), -1)
h1 = self.ed.MarkerAdd(0,1)
h2 = self.ed.MarkerAdd(2,1)
self.assertEquals(self.ed.MarkerNext(0, 2), 0)
self.assertEquals(self.ed.MarkerNext(1, 2), 2)
self.assertEquals(self.ed.MarkerNext(2, 2), 2)
self.assertEquals(self.ed.MarkerPrevious(0, 2), 0)
self.assertEquals(self.ed.MarkerPrevious(1, 2), 0)
self.assertEquals(self.ed.MarkerPrevious(2, 2), 2)
def testMarkerNegative(self):
self.assertEquals(self.ed.MarkerNext(-1, 2), -1)
def testLineState(self):
self.assertEquals(self.ed.MaxLineState, 0)
self.assertEquals(self.ed.GetLineState(0), 0)
self.assertEquals(self.ed.GetLineState(1), 0)
self.assertEquals(self.ed.GetLineState(2), 0)
self.ed.SetLineState(1, 100)
self.assertNotEquals(self.ed.MaxLineState, 0)
self.assertEquals(self.ed.GetLineState(0), 0)
self.assertEquals(self.ed.GetLineState(1), 100)
self.assertEquals(self.ed.GetLineState(2), 0)
def testSymbolRetrieval(self):
self.ed.MarkerDefine(1,3)
self.assertEquals(self.ed.MarkerSymbolDefined(1), 3)
class TestIndicators(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
def testSetIndicator(self):
self.assertEquals(self.ed.IndicGetStyle(0), 1)
self.assertEquals(self.ed.IndicGetFore(0), 0x007f00)
self.ed.IndicSetStyle(0, 2)
self.ed.IndicSetFore(0, 0xff0080)
self.assertEquals(self.ed.IndicGetStyle(0), 2)
self.assertEquals(self.ed.IndicGetFore(0), 0xff0080)
def testIndicatorFill(self):
self.ed.InsertText(0, b"abc")
self.ed.IndicatorCurrent = 3
self.ed.IndicatorFillRange(1,1)
self.assertEquals(self.ed.IndicatorValueAt(3, 0), 0)
self.assertEquals(self.ed.IndicatorValueAt(3, 1), 1)
self.assertEquals(self.ed.IndicatorValueAt(3, 2), 0)
self.assertEquals(self.ed.IndicatorStart(3, 0), 0)
self.assertEquals(self.ed.IndicatorEnd(3, 0), 1)
self.assertEquals(self.ed.IndicatorStart(3, 1), 1)
self.assertEquals(self.ed.IndicatorEnd(3, 1), 2)
self.assertEquals(self.ed.IndicatorStart(3, 2), 2)
self.assertEquals(self.ed.IndicatorEnd(3, 2), 3)
def testIndicatorAtEnd(self):
self.ed.InsertText(0, b"ab")
self.ed.IndicatorCurrent = 3
self.ed.IndicatorFillRange(1,1)
self.assertEquals(self.ed.IndicatorValueAt(3, 0), 0)
self.assertEquals(self.ed.IndicatorValueAt(3, 1), 1)
self.assertEquals(self.ed.IndicatorStart(3, 0), 0)
self.assertEquals(self.ed.IndicatorEnd(3, 0), 1)
self.assertEquals(self.ed.IndicatorStart(3, 1), 1)
self.assertEquals(self.ed.IndicatorEnd(3, 1), 2)
self.ed.DeleteRange(1, 1)
# Now only one character left and does not have indicator so indicator 3 is null
self.assertEquals(self.ed.IndicatorValueAt(3, 0), 0)
# Since null, remaining calls return 0
self.assertEquals(self.ed.IndicatorStart(3, 0), 0)
self.assertEquals(self.ed.IndicatorEnd(3, 0), 0)
self.assertEquals(self.ed.IndicatorStart(3, 1), 0)
self.assertEquals(self.ed.IndicatorEnd(3, 1), 0)
class TestScrolling(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
# 150 should be enough lines
self.ed.InsertText(0, b"a" * 150 + b"\n" * 150)
def testTop(self):
self.ed.GotoLine(0)
self.assertEquals(self.ed.FirstVisibleLine, 0)
def testLineScroll(self):
self.ed.GotoLine(0)
self.ed.LineScroll(0, 3)
self.assertEquals(self.ed.FirstVisibleLine, 3)
self.ed.LineScroll(0, -2)
self.assertEquals(self.ed.FirstVisibleLine, 1)
self.assertEquals(self.ed.XOffset, 0)
self.ed.LineScroll(10, 0)
self.assertGreater(self.ed.XOffset, 0)
scroll_width = float(self.ed.XOffset) / 10
self.ed.LineScroll(-2, 0)
self.assertEquals(self.ed.XOffset, scroll_width * 8)
def testVisibleLine(self):
self.ed.FirstVisibleLine = 7
self.assertEquals(self.ed.FirstVisibleLine, 7)
class TestSearch(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
self.ed.InsertText(0, b"a\tbig boat\t")
def testFind(self):
pos = self.ed.FindBytes(0, self.ed.Length, b"zzz", 0)
self.assertEquals(pos, -1)
pos = self.ed.FindBytes(0, self.ed.Length, b"big", 0)
self.assertEquals(pos, 2)
def testFindEmpty(self):
pos = self.ed.FindBytes(0, self.ed.Length, b"", 0)
self.assertEquals(pos, 0)
def testCaseFind(self):
self.assertEquals(self.ed.FindBytes(0, self.ed.Length, b"big", 0), 2)
self.assertEquals(self.ed.FindBytes(0, self.ed.Length, b"bIg", 0), 2)
self.assertEquals(self.ed.FindBytes(0, self.ed.Length, b"bIg",
self.ed.SCFIND_MATCHCASE), -1)
def testWordFind(self):
self.assertEquals(self.ed.FindBytes(0, self.ed.Length, b"bi", 0), 2)
self.assertEquals(self.ed.FindBytes(0, self.ed.Length, b"bi",
self.ed.SCFIND_WHOLEWORD), -1)
def testWordStartFind(self):
self.assertEquals(self.ed.FindBytes(0, self.ed.Length, b"bi", 0), 2)
self.assertEquals(self.ed.FindBytes(0, self.ed.Length, b"bi",
self.ed.SCFIND_WORDSTART), 2)
self.assertEquals(self.ed.FindBytes(0, self.ed.Length, b"ig", 0), 3)
self.assertEquals(self.ed.FindBytes(0, self.ed.Length, b"ig",
self.ed.SCFIND_WORDSTART), -1)
def testREFind(self):
flags = self.ed.SCFIND_REGEXP
self.assertEquals(-1, self.ed.FindBytes(0, self.ed.Length, b"b.g", 0))
self.assertEquals(2, self.ed.FindBytes(0, self.ed.Length, b"b.g", flags))
self.assertEquals(2, self.ed.FindBytes(0, self.ed.Length, b"\<b.g\>", flags))
self.assertEquals(-1, self.ed.FindBytes(0, self.ed.Length, b"b[A-Z]g",
flags | self.ed.SCFIND_MATCHCASE))
self.assertEquals(2, self.ed.FindBytes(0, self.ed.Length, b"b[a-z]g", flags))
self.assertEquals(6, self.ed.FindBytes(0, self.ed.Length, b"b[a-z]*t", flags))
self.assertEquals(0, self.ed.FindBytes(0, self.ed.Length, b"^a", flags))
self.assertEquals(10, self.ed.FindBytes(0, self.ed.Length, b"\t$", flags))
self.assertEquals(0, self.ed.FindBytes(0, self.ed.Length, b"\([a]\).*\0", flags))
def testPosixREFind(self):
flags = self.ed.SCFIND_REGEXP | self.ed.SCFIND_POSIX
self.assertEquals(-1, self.ed.FindBytes(0, self.ed.Length, b"b.g", 0))
self.assertEquals(2, self.ed.FindBytes(0, self.ed.Length, b"b.g", flags))
self.assertEquals(2, self.ed.FindBytes(0, self.ed.Length, b"\<b.g\>", flags))
self.assertEquals(-1, self.ed.FindBytes(0, self.ed.Length, b"b[A-Z]g",
flags | self.ed.SCFIND_MATCHCASE))
self.assertEquals(2, self.ed.FindBytes(0, self.ed.Length, b"b[a-z]g", flags))
self.assertEquals(6, self.ed.FindBytes(0, self.ed.Length, b"b[a-z]*t", flags))
self.assertEquals(0, self.ed.FindBytes(0, self.ed.Length, b"^a", flags))
self.assertEquals(10, self.ed.FindBytes(0, self.ed.Length, b"\t$", flags))
self.assertEquals(0, self.ed.FindBytes(0, self.ed.Length, b"([a]).*\0", flags))
def testPhilippeREFind(self):
# Requires 1.,72
flags = self.ed.SCFIND_REGEXP
self.assertEquals(0, self.ed.FindBytes(0, self.ed.Length, b"\w", flags))
self.assertEquals(1, self.ed.FindBytes(0, self.ed.Length, b"\W", flags))
self.assertEquals(-1, self.ed.FindBytes(0, self.ed.Length, b"\d", flags))
self.assertEquals(0, self.ed.FindBytes(0, self.ed.Length, b"\D", flags))
self.assertEquals(1, self.ed.FindBytes(0, self.ed.Length, b"\s", flags))
self.assertEquals(0, self.ed.FindBytes(0, self.ed.Length, b"\S", flags))
self.assertEquals(2, self.ed.FindBytes(0, self.ed.Length, b"\x62", flags))
def testRENonASCII(self):
self.ed.InsertText(0, b"\xAD")
flags = self.ed.SCFIND_REGEXP
self.assertEquals(-1, self.ed.FindBytes(0, self.ed.Length, b"\\x10", flags))
self.assertEquals(2, self.ed.FindBytes(0, self.ed.Length, b"\\x09", flags))
self.assertEquals(-1, self.ed.FindBytes(0, self.ed.Length, b"\\xAB", flags))
self.assertEquals(0, self.ed.FindBytes(0, self.ed.Length, b"\\xAD", flags))
class TestRepresentations(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
def testGetControl(self):
result = self.ed.GetRepresentation(b"\001")
self.assertEquals(result, b"SOH")
def testClearControl(self):
result = self.ed.GetRepresentation(b"\002")
self.assertEquals(result, b"STX")
self.ed.ClearRepresentation(b"\002")
result = self.ed.GetRepresentation(b"\002")
self.assertEquals(result, b"")
def testSetOhm(self):
ohmSign = b"\xe2\x84\xa6"
ohmExplained = b"U+2126 \xe2\x84\xa6"
self.ed.SetRepresentation(ohmSign, ohmExplained)
result = self.ed.GetRepresentation(ohmSign)
self.assertEquals(result, ohmExplained)
class TestProperties(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
def testSet(self):
self.ed.SetProperty(b"test", b"12")
self.assertEquals(self.ed.GetPropertyInt(b"test"), 12)
result = self.ed.GetProperty(b"test")
self.assertEquals(result, b"12")
self.ed.SetProperty(b"test.plus", b"[$(test)]")
result = self.ed.GetPropertyExpanded(b"test.plus")
self.assertEquals(result, b"[12]")
class TestTextMargin(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
self.txt = b"abcd"
self.ed.AddText(1, b"x")
def testAscent(self):
lineHeight = self.ed.TextHeight(0)
self.assertEquals(self.ed.ExtraAscent, 0)
self.assertEquals(self.ed.ExtraDescent, 0)
self.ed.ExtraAscent = 1
self.assertEquals(self.ed.ExtraAscent, 1)
self.ed.ExtraDescent = 2
self.assertEquals(self.ed.ExtraDescent, 2)
# Allow line height to recalculate
self.xite.DoEvents()
lineHeightIncreased = self.ed.TextHeight(0)
self.assertEquals(lineHeightIncreased, lineHeight + 2 + 1)
def testTextMargin(self):
self.ed.MarginSetText(0, self.txt)
result = self.ed.MarginGetText(0)
self.assertEquals(result, self.txt)
self.ed.MarginTextClearAll()
def testTextMarginStyle(self):
self.ed.MarginSetText(0, self.txt)
self.ed.MarginSetStyle(0, 33)
self.assertEquals(self.ed.MarginGetStyle(0), 33)
self.ed.MarginTextClearAll()
def testTextMarginStyles(self):
styles = b"\001\002\003\004"
self.ed.MarginSetText(0, self.txt)
self.ed.MarginSetStyles(0, styles)
result = self.ed.MarginGetStyles(0)
self.assertEquals(result, styles)
self.ed.MarginTextClearAll()
def testTextMarginStyleOffset(self):
self.ed.MarginSetStyleOffset(300)
self.assertEquals(self.ed.MarginGetStyleOffset(), 300)
class TestAnnotation(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
self.txt = b"abcd"
self.ed.AddText(1, b"x")
def testTextAnnotation(self):
self.assertEquals(self.ed.AnnotationGetLines(), 0)
self.ed.AnnotationSetText(0, self.txt)
self.assertEquals(self.ed.AnnotationGetLines(), 1)
result = self.ed.AnnotationGetText(0)
self.assertEquals(len(result), 4)
self.assertEquals(result, self.txt)
self.ed.AnnotationClearAll()
def testTextAnnotationStyle(self):
self.ed.AnnotationSetText(0, self.txt)
self.ed.AnnotationSetStyle(0, 33)
self.assertEquals(self.ed.AnnotationGetStyle(0), 33)
self.ed.AnnotationClearAll()
def testTextAnnotationStyles(self):
styles = b"\001\002\003\004"
self.ed.AnnotationSetText(0, self.txt)
self.ed.AnnotationSetStyles(0, styles)
result = self.ed.AnnotationGetStyles(0)
self.assertEquals(result, styles)
self.ed.AnnotationClearAll()
def testExtendedStyles(self):
start0 = self.ed.AllocateExtendedStyles(0)
self.assertEquals(start0, 256)
start1 = self.ed.AllocateExtendedStyles(10)
self.assertEquals(start1, 256)
start2 = self.ed.AllocateExtendedStyles(20)
self.assertEquals(start2, start1 + 10)
# Reset by changing lexer
self.ed.ReleaseAllExtendedStyles()
start0 = self.ed.AllocateExtendedStyles(0)
self.assertEquals(start0, 256)
def testTextAnnotationStyleOffset(self):
self.ed.AnnotationSetStyleOffset(300)
self.assertEquals(self.ed.AnnotationGetStyleOffset(), 300)
def testTextAnnotationVisible(self):
self.assertEquals(self.ed.AnnotationGetVisible(), 0)
self.ed.AnnotationSetVisible(2)
self.assertEquals(self.ed.AnnotationGetVisible(), 2)
self.ed.AnnotationSetVisible(0)
class TestMultiSelection(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
# 3 lines of 3 characters
t = b"xxx\nxxx\nxxx"
self.ed.AddText(len(t), t)
def testSelectionCleared(self):
self.ed.ClearSelections()
self.assertEquals(self.ed.Selections, 1)
self.assertEquals(self.ed.MainSelection, 0)
self.assertEquals(self.ed.GetSelectionNCaret(0), 0)
self.assertEquals(self.ed.GetSelectionNAnchor(0), 0)
def test1Selection(self):
self.ed.SetSelection(1, 2)
self.assertEquals(self.ed.Selections, 1)
self.assertEquals(self.ed.MainSelection, 0)
self.assertEquals(self.ed.GetSelectionNCaret(0), 1)
self.assertEquals(self.ed.GetSelectionNAnchor(0), 2)
self.assertEquals(self.ed.GetSelectionNStart(0), 1)
self.assertEquals(self.ed.GetSelectionNEnd(0), 2)
self.ed.SwapMainAnchorCaret()
self.assertEquals(self.ed.Selections, 1)
self.assertEquals(self.ed.MainSelection, 0)
self.assertEquals(self.ed.GetSelectionNCaret(0), 2)
self.assertEquals(self.ed.GetSelectionNAnchor(0), 1)
def test1SelectionReversed(self):
self.ed.SetSelection(2, 1)
self.assertEquals(self.ed.Selections, 1)
self.assertEquals(self.ed.MainSelection, 0)
self.assertEquals(self.ed.GetSelectionNCaret(0), 2)
self.assertEquals(self.ed.GetSelectionNAnchor(0), 1)
self.assertEquals(self.ed.GetSelectionNStart(0), 1)
self.assertEquals(self.ed.GetSelectionNEnd(0), 2)
def test1SelectionByStartEnd(self):
self.ed.SetSelectionNStart(0, 2)
self.ed.SetSelectionNEnd(0, 3)
self.assertEquals(self.ed.Selections, 1)
self.assertEquals(self.ed.MainSelection, 0)
self.assertEquals(self.ed.GetSelectionNAnchor(0), 2)
self.assertEquals(self.ed.GetSelectionNCaret(0), 3)
self.assertEquals(self.ed.GetSelectionNStart(0), 2)
self.assertEquals(self.ed.GetSelectionNEnd(0), 3)
def test2Selections(self):
self.ed.SetSelection(1, 2)
self.ed.AddSelection(4, 5)
self.assertEquals(self.ed.Selections, 2)
self.assertEquals(self.ed.MainSelection, 1)
self.assertEquals(self.ed.GetSelectionNCaret(0), 1)
self.assertEquals(self.ed.GetSelectionNAnchor(0), 2)
self.assertEquals(self.ed.GetSelectionNCaret(1), 4)
self.assertEquals(self.ed.GetSelectionNAnchor(1), 5)
self.assertEquals(self.ed.GetSelectionNStart(0), 1)
self.assertEquals(self.ed.GetSelectionNEnd(0), 2)
self.ed.MainSelection = 0
self.assertEquals(self.ed.MainSelection, 0)
self.ed.RotateSelection()
self.assertEquals(self.ed.MainSelection, 1)
def testRectangularSelection(self):
self.ed.RectangularSelectionAnchor = 1
self.assertEquals(self.ed.RectangularSelectionAnchor, 1)
self.ed.RectangularSelectionCaret = 10
self.assertEquals(self.ed.RectangularSelectionCaret, 10)
self.assertEquals(self.ed.Selections, 3)
self.assertEquals(self.ed.MainSelection, 2)
self.assertEquals(self.ed.GetSelectionNAnchor(0), 1)
self.assertEquals(self.ed.GetSelectionNCaret(0), 2)
self.assertEquals(self.ed.GetSelectionNAnchor(1), 5)
self.assertEquals(self.ed.GetSelectionNCaret(1), 6)
self.assertEquals(self.ed.GetSelectionNAnchor(2), 9)
self.assertEquals(self.ed.GetSelectionNCaret(2), 10)
def testVirtualSpace(self):
self.ed.SetSelection(3, 7)
self.ed.SetSelectionNCaretVirtualSpace(0, 3)
self.assertEquals(self.ed.GetSelectionNCaretVirtualSpace(0), 3)
self.ed.SetSelectionNAnchorVirtualSpace(0, 2)
self.assertEquals(self.ed.GetSelectionNAnchorVirtualSpace(0), 2)
# Does not check that virtual space is valid by being at end of line
self.ed.SetSelection(1, 1)
self.ed.SetSelectionNCaretVirtualSpace(0, 3)
self.assertEquals(self.ed.GetSelectionNCaretVirtualSpace(0), 3)
def testRectangularVirtualSpace(self):
self.ed.VirtualSpaceOptions=1
self.ed.RectangularSelectionAnchor = 3
self.assertEquals(self.ed.RectangularSelectionAnchor, 3)
self.ed.RectangularSelectionCaret = 7
self.assertEquals(self.ed.RectangularSelectionCaret, 7)
self.ed.RectangularSelectionAnchorVirtualSpace = 1
self.assertEquals(self.ed.RectangularSelectionAnchorVirtualSpace, 1)
self.ed.RectangularSelectionCaretVirtualSpace = 10
self.assertEquals(self.ed.RectangularSelectionCaretVirtualSpace, 10)
self.assertEquals(self.ed.Selections, 2)
self.assertEquals(self.ed.MainSelection, 1)
self.assertEquals(self.ed.GetSelectionNAnchor(0), 3)
self.assertEquals(self.ed.GetSelectionNAnchorVirtualSpace(0), 1)
self.assertEquals(self.ed.GetSelectionNCaret(0), 3)
self.assertEquals(self.ed.GetSelectionNCaretVirtualSpace(0), 10)
def testRectangularVirtualSpaceOptionOff(self):
# Same as previous test but virtual space option off so no virtual space in result
self.ed.VirtualSpaceOptions=0
self.ed.RectangularSelectionAnchor = 3
self.assertEquals(self.ed.RectangularSelectionAnchor, 3)
self.ed.RectangularSelectionCaret = 7
self.assertEquals(self.ed.RectangularSelectionCaret, 7)
self.ed.RectangularSelectionAnchorVirtualSpace = 1
self.assertEquals(self.ed.RectangularSelectionAnchorVirtualSpace, 1)
self.ed.RectangularSelectionCaretVirtualSpace = 10
self.assertEquals(self.ed.RectangularSelectionCaretVirtualSpace, 10)
self.assertEquals(self.ed.Selections, 2)
self.assertEquals(self.ed.MainSelection, 1)
self.assertEquals(self.ed.GetSelectionNAnchor(0), 3)
self.assertEquals(self.ed.GetSelectionNAnchorVirtualSpace(0), 0)
self.assertEquals(self.ed.GetSelectionNCaret(0), 3)
self.assertEquals(self.ed.GetSelectionNCaretVirtualSpace(0), 0)
class TestCharacterNavigation(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
self.ed.SetCodePage(65001)
def tearDown(self):
self.ed.SetCodePage(0)
def testBeforeAfter(self):
t = "aåflﬔ-"
tv = t.encode("UTF-8")
self.ed.SetContents(tv)
pos = 0
for i in range(len(t)-1):
after = self.ed.PositionAfter(pos)
self.assert_(after > i)
back = self.ed.PositionBefore(after)
self.assertEquals(pos, back)
pos = after
def testRelative(self):
# \x61 \xc3\xa5 \xef\xac\x82 \xef\xac\x94 \x2d
t = "aåflﬔ-"
tv = t.encode("UTF-8")
self.ed.SetContents(tv)
self.assertEquals(self.ed.PositionRelative(1, 2), 6)
self.assertEquals(self.ed.PositionRelative(6, -2), 1)
pos = 0
previous = 0
for i in range(1, len(t)):
after = self.ed.PositionRelative(pos, i)
self.assert_(after > pos)
self.assert_(after > previous)
previous = after
pos = len(t)
previous = pos
for i in range(1, len(t)-1):
after = self.ed.PositionRelative(pos, -i)
self.assert_(after < pos)
self.assert_(after < previous)
previous = after
class TestCaseMapping(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
def tearDown(self):
self.ed.SetCodePage(0)
self.ed.StyleSetCharacterSet(self.ed.STYLE_DEFAULT, self.ed.SC_CHARSET_DEFAULT)
def testEmpty(self):
# Trying to upper case an empty string caused a crash at one stage
t = b"x"
self.ed.SetContents(t)
self.ed.UpperCase()
self.assertEquals(self.ed.Contents(), b"x")
def testASCII(self):
t = b"x"
self.ed.SetContents(t)
self.ed.SetSel(0,1)
self.ed.UpperCase()
self.assertEquals(self.ed.Contents(), b"X")
def testLatin1(self):
t = "å".encode("Latin-1")
r = "Å".encode("Latin-1")
self.ed.SetContents(t)
self.ed.SetSel(0,1)
self.ed.UpperCase()
self.assertEquals(self.ed.Contents(), r)
def testRussian(self):
if sys.platform == "win32":
self.ed.StyleSetCharacterSet(self.ed.STYLE_DEFAULT, self.ed.SC_CHARSET_RUSSIAN)
else:
self.ed.StyleSetCharacterSet(self.ed.STYLE_DEFAULT, self.ed.SC_CHARSET_CYRILLIC)
t = "Б".encode("Windows-1251")
r = "б".encode("Windows-1251")
self.ed.SetContents(t)
self.ed.SetSel(0,1)
self.ed.LowerCase()
self.assertEquals(self.ed.Contents(), r)
def testUTF(self):
self.ed.SetCodePage(65001)
t = "å".encode("UTF-8")
r = "Å".encode("UTF-8")
self.ed.SetContents(t)
self.ed.SetSel(0,2)
self.ed.UpperCase()
self.assertEquals(self.ed.Contents(), r)
def testUTFDifferentLength(self):
self.ed.SetCodePage(65001)
t = "ı".encode("UTF-8")
r = "I".encode("UTF-8")
self.ed.SetContents(t)
self.assertEquals(self.ed.Length, 2)
self.ed.SetSel(0,2)
self.ed.UpperCase()
self.assertEquals(self.ed.Length, 1)
self.assertEquals(self.ed.Contents(), r)
def testUTFGrows(self):
# This crashed at one point in debug builds due to looking past end of shorter string
self.ed.SetCodePage(65001)
# ﬖ is a single character ligature taking 3 bytes in UTF8: EF AC 96
t = 'ﬖﬖ'.encode("UTF-8")
self.ed.SetContents(t)
self.assertEquals(self.ed.Length, 6)
self.ed.SetSel(0,self.ed.Length)
self.ed.UpperCase()
# To convert to upper case the ligature is separated into վ and ն then uppercased to Վ and Ն
# each of which takes 2 bytes in UTF-8: D5 8E D5 86
r = 'ՎՆՎՆ'.encode("UTF-8")
self.assertEquals(self.ed.Length, 8)
self.assertEquals(self.ed.Contents(), r)
self.assertEquals(self.ed.SelectionEnd, self.ed.Length)
def testUTFShrinks(self):
self.ed.SetCodePage(65001)
# fi is a single character ligature taking 3 bytes in UTF8: EF AC 81
t = 'fifi'.encode("UTF-8")
self.ed.SetContents(t)
self.assertEquals(self.ed.Length, 6)
self.ed.SetSel(0,self.ed.Length)
self.ed.UpperCase()
# To convert to upper case the ligature is separated into f and i then uppercased to F and I
# each of which takes 1 byte in UTF-8: 46 49
r = 'FIFI'.encode("UTF-8")
self.assertEquals(self.ed.Length, 4)
self.assertEquals(self.ed.Contents(), r)
self.assertEquals(self.ed.SelectionEnd, self.ed.Length)
class TestCaseInsensitiveSearch(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
def tearDown(self):
self.ed.SetCodePage(0)
self.ed.StyleSetCharacterSet(self.ed.STYLE_DEFAULT, self.ed.SC_CHARSET_DEFAULT)
def testEmpty(self):
text = b" x X"
searchString = b""
self.ed.SetContents(text)
self.ed.TargetStart = 0
self.ed.TargetEnd = self.ed.Length-1
self.ed.SearchFlags = 0
pos = self.ed.SearchInTarget(len(searchString), searchString)
self.assertEquals(0, pos)
def testASCII(self):
text = b" x X"
searchString = b"X"
self.ed.SetContents(text)
self.ed.TargetStart = 0
self.ed.TargetEnd = self.ed.Length-1
self.ed.SearchFlags = 0
pos = self.ed.SearchInTarget(len(searchString), searchString)
self.assertEquals(1, pos)
def testLatin1(self):
text = "Frånd Åå".encode("Latin-1")
searchString = "Å".encode("Latin-1")
self.ed.SetContents(text)
self.ed.TargetStart = 0
self.ed.TargetEnd = self.ed.Length-1
self.ed.SearchFlags = 0
pos = self.ed.SearchInTarget(len(searchString), searchString)
self.assertEquals(2, pos)
def testRussian(self):
self.ed.StyleSetCharacterSet(self.ed.STYLE_DEFAULT, self.ed.SC_CHARSET_RUSSIAN)
text = "=(Б tex б)".encode("Windows-1251")
searchString = "б".encode("Windows-1251")
self.ed.SetContents(text)
self.ed.TargetStart = 0
self.ed.TargetEnd = self.ed.Length-1
self.ed.SearchFlags = 0
pos = self.ed.SearchInTarget(len(searchString), searchString)
self.assertEquals(2, pos)
def testUTF(self):
self.ed.SetCodePage(65001)
text = "Frånd Åå".encode("UTF-8")
searchString = "Å".encode("UTF-8")
self.ed.SetContents(text)
self.ed.TargetStart = 0
self.ed.TargetEnd = self.ed.Length-1
self.ed.SearchFlags = 0
pos = self.ed.SearchInTarget(len(searchString), searchString)
self.assertEquals(2, pos)
def testUTFDifferentLength(self):
# Searching for a two byte string finds a single byte
self.ed.SetCodePage(65001)
# two byte string "ſ" single byte "s"
text = "Frånds Ååſ $".encode("UTF-8")
searchString = "ſ".encode("UTF-8")
firstPosition = len("Frånd".encode("UTF-8"))
self.assertEquals(len(searchString), 2)
self.ed.SetContents(text)
self.ed.TargetStart = 0
self.ed.TargetEnd = self.ed.Length-1
self.ed.SearchFlags = 0
pos = self.ed.SearchInTarget(len(searchString), searchString)
self.assertEquals(firstPosition, pos)
self.assertEquals(firstPosition+1, self.ed.TargetEnd)
class TestLexer(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
def testLexerNumber(self):
self.ed.Lexer = self.ed.SCLEX_CPP
self.assertEquals(self.ed.GetLexer(), self.ed.SCLEX_CPP)
def testLexerName(self):
self.ed.LexerLanguage = b"cpp"
self.assertEquals(self.ed.GetLexer(), self.ed.SCLEX_CPP)
name = self.ed.GetLexerLanguage(0)
self.assertEquals(name, b"cpp")
def testPropertyNames(self):
propertyNames = self.ed.PropertyNames()
self.assertNotEquals(propertyNames, b"")
# The cpp lexer has a boolean property named lexer.cpp.allow.dollars
propNameDollars = b"lexer.cpp.allow.dollars"
propertyType = self.ed.PropertyType(propNameDollars)
self.assertEquals(propertyType, self.ed.SC_TYPE_BOOLEAN)
propertyDescription = self.ed.DescribeProperty(propNameDollars)
self.assertNotEquals(propertyDescription, b"")
def testWordListDescriptions(self):
wordSet = self.ed.DescribeKeyWordSets()
self.assertNotEquals(wordSet, b"")
class TestSubStyles(unittest.TestCase):
''' These tests include knowledge of the current implementation in the cpp lexer
and may have to change when that implementation changes.
Currently supports subStyles for IDENTIFIER 11 and COMMENTDOCKEYWORD 17 '''
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
def testInfo(self):
self.ed.Lexer = self.ed.SCLEX_CPP
bases = self.ed.GetSubStyleBases()
self.assertEquals(bases, b"\x0b\x11") # 11, 17
self.assertEquals(self.ed.DistanceToSecondaryStyles(), 0x40)
def testAllocate(self):
firstSubStyle = 0x80 # Current implementation
self.ed.Lexer = self.ed.SCLEX_CPP
self.assertEquals(self.ed.GetStyleFromSubStyle(firstSubStyle), firstSubStyle)
self.assertEquals(self.ed.GetSubStylesStart(self.ed.SCE_C_IDENTIFIER), 0)
self.assertEquals(self.ed.GetSubStylesLength(self.ed.SCE_C_IDENTIFIER), 0)
numSubStyles = 5
subs = self.ed.AllocateSubStyles(self.ed.SCE_C_IDENTIFIER, numSubStyles)
self.assertEquals(subs, firstSubStyle)
self.assertEquals(self.ed.GetSubStylesStart(self.ed.SCE_C_IDENTIFIER), firstSubStyle)
self.assertEquals(self.ed.GetSubStylesLength(self.ed.SCE_C_IDENTIFIER), numSubStyles)
self.assertEquals(self.ed.GetStyleFromSubStyle(subs), self.ed.SCE_C_IDENTIFIER)
self.assertEquals(self.ed.GetStyleFromSubStyle(subs+numSubStyles-1), self.ed.SCE_C_IDENTIFIER)
self.assertEquals(self.ed.GetStyleFromSubStyle(self.ed.SCE_C_IDENTIFIER), self.ed.SCE_C_IDENTIFIER)
# Now free and check same as start
self.ed.FreeSubStyles()
self.assertEquals(self.ed.GetStyleFromSubStyle(subs), subs)
self.assertEquals(self.ed.GetSubStylesStart(self.ed.SCE_C_IDENTIFIER), 0)
self.assertEquals(self.ed.GetSubStylesLength(self.ed.SCE_C_IDENTIFIER), 0)
def testInactive(self):
firstSubStyle = 0x80 # Current implementation
inactiveDistance = self.ed.DistanceToSecondaryStyles()
self.ed.Lexer = self.ed.SCLEX_CPP
numSubStyles = 5
subs = self.ed.AllocateSubStyles(self.ed.SCE_C_IDENTIFIER, numSubStyles)
self.assertEquals(subs, firstSubStyle)
self.assertEquals(self.ed.GetStyleFromSubStyle(subs), self.ed.SCE_C_IDENTIFIER)
self.assertEquals(self.ed.GetStyleFromSubStyle(subs+inactiveDistance), self.ed.SCE_C_IDENTIFIER+inactiveDistance)
self.ed.FreeSubStyles()
def testSecondary(self):
inactiveDistance = self.ed.DistanceToSecondaryStyles()
self.assertEquals(self.ed.GetPrimaryStyleFromStyle(self.ed.SCE_C_IDENTIFIER+inactiveDistance), self.ed.SCE_C_IDENTIFIER)
class TestAutoComplete(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
# 1 line of 3 characters
t = b"xxx\n"
self.ed.AddText(len(t), t)
def testDefaults(self):
self.assertEquals(self.ed.AutoCGetSeparator(), ord(' '))
self.assertEquals(self.ed.AutoCGetMaxHeight(), 5)
self.assertEquals(self.ed.AutoCGetMaxWidth(), 0)
self.assertEquals(self.ed.AutoCGetTypeSeparator(), ord('?'))
self.assertEquals(self.ed.AutoCGetIgnoreCase(), 0)
self.assertEquals(self.ed.AutoCGetAutoHide(), 1)
self.assertEquals(self.ed.AutoCGetDropRestOfWord(), 0)
def testChangeDefaults(self):
self.ed.AutoCSetSeparator(ord('-'))
self.assertEquals(self.ed.AutoCGetSeparator(), ord('-'))
self.ed.AutoCSetSeparator(ord(' '))
self.ed.AutoCSetMaxHeight(100)
self.assertEquals(self.ed.AutoCGetMaxHeight(), 100)
self.ed.AutoCSetMaxHeight(5)
self.ed.AutoCSetMaxWidth(100)
self.assertEquals(self.ed.AutoCGetMaxWidth(), 100)
self.ed.AutoCSetMaxWidth(0)
self.ed.AutoCSetTypeSeparator(ord('@'))
self.assertEquals(self.ed.AutoCGetTypeSeparator(), ord('@'))
self.ed.AutoCSetTypeSeparator(ord('?'))
self.ed.AutoCSetIgnoreCase(1)
self.assertEquals(self.ed.AutoCGetIgnoreCase(), 1)
self.ed.AutoCSetIgnoreCase(0)
self.ed.AutoCSetAutoHide(0)
self.assertEquals(self.ed.AutoCGetAutoHide(), 0)
self.ed.AutoCSetAutoHide(1)
self.ed.AutoCSetDropRestOfWord(1)
self.assertEquals(self.ed.AutoCGetDropRestOfWord(), 1)
self.ed.AutoCSetDropRestOfWord(0)
def testAutoShow(self):
self.assertEquals(self.ed.AutoCActive(), 0)
self.ed.SetSel(0, 0)
self.ed.AutoCShow(0, b"za defn ghi")
self.assertEquals(self.ed.AutoCActive(), 1)
#~ time.sleep(2)
self.assertEquals(self.ed.AutoCPosStart(), 0)
self.assertEquals(self.ed.AutoCGetCurrent(), 0)
t = self.ed.AutoCGetCurrentText(5)
#~ self.assertEquals(l, 3)
self.assertEquals(t, b"za")
self.ed.AutoCCancel()
self.assertEquals(self.ed.AutoCActive(), 0)
def testAutoShowComplete(self):
self.assertEquals(self.ed.AutoCActive(), 0)
self.ed.SetSel(0, 0)
self.ed.AutoCShow(0, b"za defn ghi")
self.ed.AutoCComplete()
self.assertEquals(self.ed.Contents(), b"zaxxx\n")
self.assertEquals(self.ed.AutoCActive(), 0)
def testAutoShowSelect(self):
self.assertEquals(self.ed.AutoCActive(), 0)
self.ed.SetSel(0, 0)
self.ed.AutoCShow(0, b"za defn ghi")
self.ed.AutoCSelect(0, b"d")
self.ed.AutoCComplete()
self.assertEquals(self.ed.Contents(), b"defnxxx\n")
self.assertEquals(self.ed.AutoCActive(), 0)
class TestDirectAccess(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
def testGapPosition(self):
text = b"abcd"
self.ed.SetContents(text)
self.assertEquals(self.ed.GapPosition, 4)
self.ed.TargetStart = 1
self.ed.TargetEnd = 1
rep = b"-"
self.ed.ReplaceTarget(len(rep), rep)
self.assertEquals(self.ed.GapPosition, 2)
def testCharacterPointerAndRangePointer(self):
text = b"abcd"
self.ed.SetContents(text)
characterPointer = self.ed.CharacterPointer
rangePointer = self.ed.GetRangePointer(0,3)
self.assertEquals(characterPointer, rangePointer)
cpBuffer = ctypes.c_char_p(characterPointer)
self.assertEquals(cpBuffer.value, text)
# Gap will not be moved as already moved for CharacterPointer call
rangePointer = self.ed.GetRangePointer(1,3)
cpBuffer = ctypes.c_char_p(rangePointer)
self.assertEquals(cpBuffer.value, text[1:])
class TestWordChars(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
def tearDown(self):
self.ed.SetCharsDefault()
def _setChars(self, charClass, chars):
""" Wrapper to call self.ed.Set*Chars with the right type
@param charClass {str} the character class, "word", "space", etc.
@param chars {iterable of int} characters to set
"""
if sys.version_info.major == 2:
# Python 2, use latin-1 encoded str
unichars = (unichr(x) for x in chars if x != 0)
# can't use literal u"", that's a syntax error in Py3k
# uncode() doesn't exist in Py3k, but we never run it there
result = unicode("").join(unichars).encode("latin-1")
else:
# Python 3, use bytes()
result = bytes(x for x in chars if x != 0)
meth = getattr(self.ed, "Set%sChars" % (charClass.capitalize()))
return meth(None, result)
def assertCharSetsEqual(self, first, second, *args, **kwargs):
""" Assert that the two character sets are equal.
If either set are an iterable of numbers, convert them to chars
first. """
first_set = set()
for c in first:
first_set.add(chr(c) if isinstance(c, int) else c)
second_set = set()
for c in second:
second_set.add(chr(c) if isinstance(c, int) else c)
return self.assertEqual(first_set, second_set, *args, **kwargs)
def testDefaultWordChars(self):
# check that the default word chars are as expected
import string
data = self.ed.GetWordChars(None)
expected = set(string.digits + string.ascii_letters + '_') | \
set(chr(x) for x in range(0x80, 0x100))
self.assertCharSetsEqual(data, expected)
def testDefaultWhitespaceChars(self):
# check that the default whitespace chars are as expected
import string
data = self.ed.GetWhitespaceChars(None)
expected = (set(chr(x) for x in (range(0, 0x20))) | set(' ')) - \
set(['\r', '\n'])
self.assertCharSetsEqual(data, expected)
def testDefaultPunctuationChars(self):
# check that the default punctuation chars are as expected
import string
data = self.ed.GetPunctuationChars(None)
expected = set(chr(x) for x in range(0x20, 0x80)) - \
set(string.ascii_letters + string.digits + "\r\n_ ")
self.assertCharSetsEqual(data, expected)
def testCustomWordChars(self):
# check that setting things to whitespace chars makes them not words
self._setChars("whitespace", range(1, 0x100))
data = self.ed.GetWordChars(None)
expected = set()
self.assertCharSetsEqual(data, expected)
# and now set something to make sure that works too
expected = set(range(1, 0x100, 2))
self._setChars("word", expected)
data = self.ed.GetWordChars(None)
self.assertCharSetsEqual(data, expected)
def testCustomWhitespaceChars(self):
# check setting whitespace chars to non-default values
self._setChars("word", range(1, 0x100))
# we can't change chr(0) from being anything but whitespace
expected = set([0])
data = self.ed.GetWhitespaceChars(None)
self.assertCharSetsEqual(data, expected)
# now try to set it to something custom
expected = set(range(1, 0x100, 2)) | set([0])
self._setChars("whitespace", expected)
data = self.ed.GetWhitespaceChars(None)
self.assertCharSetsEqual(data, expected)
def testCustomPunctuationChars(self):
# check setting punctuation chars to non-default values
self._setChars("word", range(1, 0x100))
expected = set()
data = self.ed.GetPunctuationChars(0)
self.assertEquals(set(data), expected)
# now try to set it to something custom
expected = set(range(1, 0x100, 1))
self._setChars("punctuation", expected)
data = self.ed.GetPunctuationChars(None)
self.assertCharSetsEqual(data, expected)
if __name__ == '__main__':
uu = Xite.main("simpleTests")
#~ for x in sorted(uu.keys()):
#~ print(x, uu[x])
#~ print()
| Python |
# -*- coding: utf-8 -*-
from __future__ import with_statement
from __future__ import unicode_literals
import os, sys, unittest
import ctypes
from ctypes import wintypes
from ctypes import c_int, c_ulong, c_char_p, c_wchar_p, c_ushort, c_uint, c_long
from ctypes.wintypes import HWND, WPARAM, LPARAM, HANDLE, HBRUSH, LPCWSTR
user32=ctypes.windll.user32
gdi32=ctypes.windll.gdi32
kernel32=ctypes.windll.kernel32
from MessageNumbers import msgs, sgsm
import ScintillaCallable
import XiteMenu
scintillaDirectory = ".."
scintillaIncludeDirectory = os.path.join(scintillaDirectory, "include")
scintillaScriptsDirectory = os.path.join(scintillaDirectory, "scripts")
sys.path.append(scintillaScriptsDirectory)
import Face
scintillaBinDirectory = os.path.join(scintillaDirectory, "bin")
os.environ['PATH'] = os.environ['PATH'] + ";" + scintillaBinDirectory
#print(os.environ['PATH'])
WFUNC = ctypes.WINFUNCTYPE(c_int, HWND, c_uint, WPARAM, LPARAM)
WS_CHILD = 0x40000000
WS_CLIPCHILDREN = 0x2000000
WS_OVERLAPPEDWINDOW = 0xcf0000
WS_VISIBLE = 0x10000000
WS_HSCROLL = 0x100000
WS_VSCROLL = 0x200000
WA_INACTIVE = 0
MF_POPUP = 16
MF_SEPARATOR = 0x800
IDYES = 6
OFN_HIDEREADONLY = 4
MB_OK = 0
MB_YESNOCANCEL = 3
MF_CHECKED = 8
MF_UNCHECKED = 0
SW_SHOW = 5
PM_REMOVE = 1
VK_SHIFT = 16
VK_CONTROL = 17
VK_MENU = 18
class OPENFILENAME(ctypes.Structure):
_fields_ = (("lStructSize", c_int),
("hwndOwner", c_int),
("hInstance", c_int),
("lpstrFilter", c_wchar_p),
("lpstrCustomFilter", c_char_p),
("nMaxCustFilter", c_int),
("nFilterIndex", c_int),
("lpstrFile", c_wchar_p),
("nMaxFile", c_int),
("lpstrFileTitle", c_wchar_p),
("nMaxFileTitle", c_int),
("lpstrInitialDir", c_wchar_p),
("lpstrTitle", c_wchar_p),
("flags", c_int),
("nFileOffset", c_ushort),
("nFileExtension", c_ushort),
("lpstrDefExt", c_char_p),
("lCustData", c_int),
("lpfnHook", c_char_p),
("lpTemplateName", c_char_p),
("pvReserved", c_char_p),
("dwReserved", c_int),
("flagsEx", c_int))
def __init__(self, win, title):
ctypes.Structure.__init__(self)
self.lStructSize = ctypes.sizeof(OPENFILENAME)
self.nMaxFile = 1024
self.hwndOwner = win
self.lpstrTitle = title
self.Flags = OFN_HIDEREADONLY
trace = False
#~ trace = True
def WindowSize(w):
rc = ctypes.wintypes.RECT()
user32.GetClientRect(w, ctypes.byref(rc))
return rc.right - rc.left, rc.bottom - rc.top
def IsKeyDown(key):
return (user32.GetKeyState(key) & 0x8000) != 0
def KeyTranslate(w):
tr = { 9: "Tab", 0xD:"Enter", 0x1B: "Esc" }
if w in tr:
return tr[w]
elif ord("A") <= w <= ord("Z"):
return chr(w)
elif 0x70 <= w <= 0x7b:
return "F" + str(w-0x70+1)
else:
return "Unknown_" + hex(w)
class WNDCLASS(ctypes.Structure):
_fields_= (\
('style', c_int),
('lpfnWndProc', WFUNC),
('cls_extra', c_int),
('wnd_extra', c_int),
('hInst', HANDLE),
('hIcon', HANDLE),
('hCursor', HANDLE),
('hbrBackground', HBRUSH),
('menu_name', LPCWSTR),
('lpzClassName', LPCWSTR),
)
hinst = ctypes.windll.kernel32.GetModuleHandleW(0)
def RegisterClass(name, func, background = 0):
# register a window class for toplevel windows.
wc = WNDCLASS()
wc.style = 0
wc.lpfnWndProc = func
wc.cls_extra = 0
wc.wnd_extra = 0
wc.hInst = hinst
wc.hIcon = 0
wc.hCursor = 0
wc.hbrBackground = background
wc.menu_name = None
wc.lpzClassName = name
user32.RegisterClassW(ctypes.byref(wc))
class XiteWin():
def __init__(self, test=""):
self.face = Face.Face()
self.face.ReadFromFile(os.path.join(scintillaIncludeDirectory, "Scintilla.iface"))
self.titleDirty = True
self.fullPath = ""
self.test = test
self.appName = "xite"
self.cmds = {}
self.windowName = "XiteWindow"
self.wfunc = WFUNC(self.WndProc)
RegisterClass(self.windowName, self.wfunc)
user32.CreateWindowExW(0, self.windowName, self.appName, \
WS_VISIBLE | WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN, \
0, 0, 500, 700, 0, 0, hinst, 0)
args = sys.argv[1:]
self.SetMenus()
if args:
self.GrabFile(args[0])
self.FocusOnEditor()
self.ed.GotoPos(self.ed.Length)
if self.test:
print(self.test)
for k in self.cmds:
if self.cmds[k] == "Test":
user32.PostMessageW(self.win, msgs["WM_COMMAND"], k, 0)
def FocusOnEditor(self):
user32.SetFocus(self.sciHwnd)
def OnSize(self):
width, height = WindowSize(self.win)
user32.SetWindowPos(self.sciHwnd, 0, 0, 0, width, height, 0)
user32.InvalidateRect(self.win, 0, 0)
def OnCreate(self, hwnd):
self.win = hwnd
# Side effect: loads the DLL
x = ctypes.windll.SciLexer.Scintilla_DirectFunction
self.sciHwnd = user32.CreateWindowExW(0,
"Scintilla", "Source",
WS_CHILD | WS_VSCROLL | WS_HSCROLL | WS_CLIPCHILDREN,
0, 0, 100, 100, self.win, 0, hinst, 0)
user32.ShowWindow(self.sciHwnd, SW_SHOW)
user32.SendMessageW.restype = WPARAM
scifn = user32.SendMessageW(self.sciHwnd,
int(self.face.features["GetDirectFunction"]["Value"], 0), 0,0)
sciptr = c_char_p(user32.SendMessageW(self.sciHwnd,
int(self.face.features["GetDirectPointer"]["Value"], 0), 0,0))
self.ed = ScintillaCallable.ScintillaCallable(self.face, scifn, sciptr)
self.FocusOnEditor()
def Invalidate(self):
user32.InvalidateRect(self.win, 0, 0)
def WndProc(self, h, m, w, l):
user32.DefWindowProcW.argtypes = [HWND, c_uint, WPARAM, LPARAM]
ms = sgsm.get(m, "XXX")
if trace:
print("%s %s %s %s" % (hex(h)[2:],ms,w,l))
if ms == "WM_CLOSE":
user32.PostQuitMessage(0)
elif ms == "WM_CREATE":
self.OnCreate(h)
return 0
elif ms == "WM_SIZE":
# Work out size
if w != 1:
self.OnSize()
return 0
elif ms == "WM_COMMAND":
cmdCode = w & 0xffff
if cmdCode in self.cmds:
self.Command(self.cmds[cmdCode])
return 0
elif ms == "WM_ACTIVATE":
if w != WA_INACTIVE:
self.FocusOnEditor()
return 0
else:
return user32.DefWindowProcW(h, m, w, l)
return 0
def Command(self, name):
name = name.replace(" ", "")
method = "Cmd" + name
cmd = None
try:
cmd = getattr(self, method)
except AttributeError:
return
if cmd:
cmd()
def KeyDown(self, w, prefix = ""):
keyName = prefix
if IsKeyDown(VK_CONTROL):
keyName += "<control>"
if IsKeyDown(VK_SHIFT):
keyName += "<shift>"
keyName += KeyTranslate(w)
if trace:
print("Key:", keyName)
if keyName in self.keys:
method = "Cmd" + self.keys[keyName]
getattr(self, method)()
return True
#~ print("UKey:", keyName)
return False
def Accelerator(self, msg):
ms = sgsm.get(msg.message, "XXX")
if ms == "WM_KEYDOWN":
return self.KeyDown(msg.wParam)
elif ms == "WM_SYSKEYDOWN":
return self.KeyDown(msg.wParam, "<alt>")
return False
def AppLoop(self):
msg = ctypes.wintypes.MSG()
lpmsg = ctypes.byref(msg)
while user32.GetMessageW(lpmsg, 0, 0, 0):
if trace and msg.message != msgs["WM_TIMER"]:
print('mm', hex(msg.hWnd)[2:],sgsm.get(msg.message, "XXX"))
if not self.Accelerator(msg):
user32.TranslateMessage(lpmsg)
user32.DispatchMessageW(lpmsg)
def DoEvents(self):
msg = ctypes.wintypes.MSG()
lpmsg = ctypes.byref(msg)
cont = True
while cont:
cont = user32.PeekMessageW(lpmsg, 0, 0, 0, PM_REMOVE)
if cont:
if not self.Accelerator(msg):
user32.TranslateMessage(lpmsg)
user32.DispatchMessageW(lpmsg)
def SetTitle(self, changePath):
if changePath or self.titleDirty != self.ed.Modify:
self.titleDirty = self.ed.Modify
self.title = self.fullPath
if self.titleDirty:
self.title += " * "
else:
self.title += " - "
self.title += self.appName
if self.win:
user32.SetWindowTextW(self.win, self.title)
def Open(self):
ofx = OPENFILENAME(self.win, "Open File")
opath = "\0" * 1024
ofx.lpstrFile = opath
filters = ["Python (.py;.pyw)|*.py;*.pyw|All|*.*"]
filterText = "\0".join([f.replace("|", "\0") for f in filters])+"\0\0"
ofx.lpstrFilter = filterText
if ctypes.windll.comdlg32.GetOpenFileNameW(ctypes.byref(ofx)):
absPath = opath.replace("\0", "")
self.GrabFile(absPath)
self.FocusOnEditor()
self.ed.LexerLanguage = "python"
self.ed.Lexer = self.ed.SCLEX_PYTHON
self.ed.SetKeyWords(0, b"class def else for from if import print return while")
for style in [k for k in self.ed.k if k.startswith("SCE_P_")]:
self.ed.StyleSetFont(self.ed.k[style], b"Verdana")
if "COMMENT" in style:
self.ed.StyleSetFore(self.ed.k[style], 127 * 256)
self.ed.StyleSetFont(self.ed.k[style], b"Comic Sans MS")
elif "OPERATOR" in style:
self.ed.StyleSetBold(self.ed.k[style], 1)
self.ed.StyleSetFore(self.ed.k[style], 127 * 256 * 256)
elif "WORD" in style:
self.ed.StyleSetItalic(self.ed.k[style], 255)
self.ed.StyleSetFore(self.ed.k[style], 255 * 256 * 256)
elif "TRIPLE" in style:
self.ed.StyleSetFore(self.ed.k[style], 0xA0A0)
elif "STRING" in style or "CHARACTER" in style:
self.ed.StyleSetFore(self.ed.k[style], 0xA000A0)
else:
self.ed.StyleSetFore(self.ed.k[style], 0)
def SaveAs(self):
ofx = OPENFILENAME(self.win, "Save File")
opath = "\0" * 1024
ofx.lpstrFile = opath
if ctypes.windll.comdlg32.GetSaveFileNameW(ctypes.byref(ofx)):
self.fullPath = opath.replace("\0", "")
self.Save()
self.SetTitle(1)
self.FocusOnEditor()
def SetMenus(self):
ui = XiteMenu.MenuStructure
self.cmds = {}
self.keys = {}
cmdId = 0
self.menuBar = user32.CreateMenu()
for name, contents in ui:
cmdId += 1
menu = user32.CreateMenu()
for item in contents:
text, key = item
cmdText = text.replace("&", "")
cmdText = cmdText.replace("...", "")
cmdText = cmdText.replace(" ", "")
cmdId += 1
if key:
keyText = key.replace("<control>", "Ctrl+")
keyText = keyText.replace("<shift>", "Shift+")
text += "\t" + keyText
if text == "-":
user32.AppendMenuW(menu, MF_SEPARATOR, cmdId, text)
else:
user32.AppendMenuW(menu, 0, cmdId, text)
self.cmds[cmdId] = cmdText
self.keys[key] = cmdText
#~ print(cmdId, item)
user32.AppendMenuW(self.menuBar, MF_POPUP, menu, name)
user32.SetMenu(self.win, self.menuBar)
self.CheckMenuItem("Wrap", True)
user32.ShowWindow(self.win, SW_SHOW)
def CheckMenuItem(self, name, val):
#~ print(name, val)
if self.cmds:
for k,v in self.cmds.items():
if v == name:
#~ print(name, k)
user32.CheckMenuItem(user32.GetMenu(self.win), \
k, [MF_UNCHECKED, MF_CHECKED][val])
def Exit(self):
sys.exit(0)
def DisplayMessage(self, msg, ask):
return IDYES == user32.MessageBoxW(self.win, \
msg, self.appName, [MB_OK, MB_YESNOCANCEL][ask])
def NewDocument(self):
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
self.ed.SetSavePoint()
def SaveIfUnsure(self):
if self.ed.Modify:
msg = "Save changes to \"" + self.fullPath + "\"?"
print(msg)
decision = self.DisplayMessage(msg, True)
if decision:
self.CmdSave()
return decision
return True
def New(self):
if self.SaveIfUnsure():
self.fullPath = ""
self.overrideMode = None
self.NewDocument()
self.SetTitle(1)
self.Invalidate()
def CheckMenus(self):
pass
def MoveSelection(self, caret, anchor=-1):
if anchor == -1:
anchor = caret
self.ed.SetSelectionStart(caret)
self.ed.SetSelectionEnd(anchor)
self.ed.ScrollCaret()
self.Invalidate()
def GrabFile(self, name):
self.fullPath = name
self.overrideMode = None
self.NewDocument()
fsr = open(name, "rb")
data = fsr.read()
fsr.close()
self.ed.AddText(len(data), data)
self.ed.EmptyUndoBuffer()
self.MoveSelection(0)
self.SetTitle(1)
def Save(self):
fos = open(self.fullPath, "wb")
blockSize = 1024
length = self.ed.Length
i = 0
while i < length:
grabSize = length - i
if grabSize > blockSize:
grabSize = blockSize
#~ print(i, grabSize, length)
data = self.ed.ByteRange(i, i + grabSize)
fos.write(data)
i += grabSize
fos.close()
self.ed.SetSavePoint()
self.SetTitle(0)
# Command handlers are called by menu actions
def CmdNew(self):
self.New()
def CmdOpen(self):
self.Open()
def CmdSave(self):
if (self.fullPath == None) or (len(self.fullPath) == 0):
self.SaveAs()
else:
self.Save()
def CmdSaveAs(self):
self.SaveAs()
def CmdTest(self):
runner = unittest.TextTestRunner()
if self.test:
tests = unittest.defaultTestLoader.loadTestsFromName(self.test)
else:
tests = unittest.defaultTestLoader.loadTestsFromName("simpleTests")
results = runner.run(tests)
#~ print(results)
if self.test:
user32.PostQuitMessage(0)
def CmdExercised(self):
print()
unused = sorted(self.ed.all.difference(self.ed.used))
print("Unused", len(unused))
print()
print("\n".join(unused))
print()
print("Used", len(self.ed.used))
print()
print("\n".join(sorted(self.ed.used)))
def Uncalled(self):
print("")
unused = sorted(self.ed.all.difference(self.ed.used))
uu = {}
for u in unused:
v = self.ed.getvalue(u)
if v > 2000:
uu[v] = u
#~ for x in sorted(uu.keys())[150:]:
return uu
def CmdExit(self):
self.Exit()
def CmdUndo(self):
self.ed.Undo()
def CmdRedo(self):
self.ed.Redo()
def CmdCut(self):
self.ed.Cut()
def CmdCopy(self):
self.ed.Copy()
def CmdPaste(self):
self.ed.Paste()
def CmdDelete(self):
self.ed.Clear()
xiteFrame = None
def main(test):
global xiteFrame
xiteFrame = XiteWin(test)
xiteFrame.AppLoop()
#~ xiteFrame.CmdExercised()
return xiteFrame.Uncalled()
| Python |
# Convert all punctuation characters except '_', '*', and '.' into spaces.
def depunctuate(s):
'''A docstring'''
"""Docstring 2"""
d = ""
for ch in s:
if ch in 'abcde':
d = d + ch
else:
d = d + " "
return d
| Python |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import ctypes, os, sys
from ctypes import c_int, c_ulong, c_char_p, c_wchar_p, c_ushort, c_uint, c_long
class TEXTRANGE(ctypes.Structure):
_fields_= (\
('cpMin', c_long),
('cpMax', c_long),
('lpstrText', ctypes.POINTER(ctypes.c_char)),
)
class FINDTEXT(ctypes.Structure):
_fields_= (\
('cpMin', c_long),
('cpMax', c_long),
('lpstrText', c_char_p),
('cpMinText', c_long),
('cpMaxText', c_long),
)
class SciCall:
def __init__(self, fn, ptr, msg, stringResult=False):
self._fn = fn
self._ptr = ptr
self._msg = msg
self._stringResult = stringResult
def __call__(self, w=0, l=0):
ww = ctypes.cast(w, c_char_p)
if self._stringResult:
lengthBytes = self._fn(self._ptr, self._msg, ww, None)
if lengthBytes == 0:
return bytearray()
result = (ctypes.c_byte * lengthBytes)(0)
lengthBytes2 = self._fn(self._ptr, self._msg, ww, ctypes.cast(result, c_char_p))
assert lengthBytes == lengthBytes2
return bytearray(result)[:lengthBytes]
else:
ll = ctypes.cast(l, c_char_p)
return self._fn(self._ptr, self._msg, ww, ll)
sciFX = ctypes.CFUNCTYPE(c_long, c_char_p, c_int, c_char_p, c_char_p)
class ScintillaCallable:
def __init__(self, face, scifn, sciptr):
self.__dict__["face"] = face
self.__dict__["used"] = set()
self.__dict__["all"] = set()
# The k member is for accessing constants as a dictionary
self.__dict__["k"] = {}
for f in face.features:
self.all.add(f)
if face.features[f]["FeatureType"] == "val":
self.k[f] = int(self.face.features[f]["Value"], 0)
elif face.features[f]["FeatureType"] == "evt":
self.k["SCN_"+f] = int(self.face.features[f]["Value"], 0)
scifn = sciFX(scifn)
self.__dict__["_scifn"] = scifn
self.__dict__["_sciptr"] = sciptr
def __getattr__(self, name):
if name in self.face.features:
self.used.add(name)
feature = self.face.features[name]
value = int(feature["Value"], 0)
#~ print("Feature", name, feature)
if feature["FeatureType"] == "val":
self.__dict__[name] = value
return value
else:
if feature["Param2Type"] == "stringresult" and \
name not in ["GetText", "GetLine", "GetCurLine"]:
return SciCall(self._scifn, self._sciptr, value, True)
else:
return SciCall(self._scifn, self._sciptr, value)
elif ("Get" + name) in self.face.features:
self.used.add("Get" + name)
feature = self.face.features["Get" + name]
value = int(feature["Value"], 0)
if feature["FeatureType"] == "get" and \
not name.startswith("Get") and \
not feature["Param1Type"] and \
not feature["Param2Type"] and \
feature["ReturnType"] in ["bool", "int", "position"]:
#~ print("property", feature)
return self._scifn(self._sciptr, value, None, None)
elif name.startswith("SCN_") and name in self.k:
self.used.add(name)
feature = self.face.features[name[4:]]
value = int(feature["Value"], 0)
#~ print("Feature", name, feature)
if feature["FeatureType"] == "val":
return value
raise AttributeError(name)
def __setattr__(self, name, val):
if ("Set" + name) in self.face.features:
self.used.add("Set" + name)
feature = self.face.features["Set" + name]
value = int(feature["Value"], 0)
#~ print("setproperty", feature)
if feature["FeatureType"] == "set" and not name.startswith("Set"):
if feature["Param1Type"] in ["bool", "int", "position"]:
return self._scifn(self._sciptr, value, c_char_p(val), None)
elif feature["Param2Type"] in ["string"]:
return self._scifn(self._sciptr, value, None, c_char_p(val))
raise AttributeError(name)
raise AttributeError(name)
def getvalue(self, name):
if name in self.face.features:
feature = self.face.features[name]
if feature["FeatureType"] != "evt":
try:
return int(feature["Value"], 0)
except ValueError:
return -1
return -1
def ByteRange(self, start, end):
tr = TEXTRANGE()
tr.cpMin = start
tr.cpMax = end
length = end - start
tr.lpstrText = ctypes.create_string_buffer(length + 1)
self.GetTextRange(0, ctypes.byref(tr))
text = tr.lpstrText[:length]
text += b"\0" * (length - len(text))
return text
def StyledTextRange(self, start, end):
tr = TEXTRANGE()
tr.cpMin = start
tr.cpMax = end
length = 2 * (end - start)
tr.lpstrText = ctypes.create_string_buffer(length + 2)
self.GetStyledText(0, ctypes.byref(tr))
styledText = tr.lpstrText[:length]
styledText += b"\0" * (length - len(styledText))
return styledText
def FindBytes(self, start, end, s, flags):
ft = FINDTEXT()
ft.cpMin = start
ft.cpMax = end
ft.lpstrText = s
ft.cpMinText = 0
ft.cpMaxText = 0
pos = self.FindText(flags, ctypes.byref(ft))
#~ print(start, end, ft.cpMinText, ft.cpMaxText)
return pos
def Contents(self):
return self.ByteRange(0, self.Length)
def SetContents(self, s):
self.TargetStart = 0
self.TargetEnd = self.Length
self.ReplaceTarget(len(s), s)
| Python |
# -*- coding: utf-8 -*-
from __future__ import with_statement
from __future__ import unicode_literals
import os, string, sys, time, unittest
if sys.platform == "win32":
import XiteWin as Xite
else:
import XiteQt as Xite
class TestPerformance(unittest.TestCase):
def setUp(self):
self.xite = Xite.xiteFrame
self.ed = self.xite.ed
self.ed.ClearAll()
self.ed.EmptyUndoBuffer()
def testAddLine(self):
data = (string.ascii_letters + string.digits + "\n").encode('utf-8')
start = time.time()
for i in range(1000):
self.ed.AddText(len(data), data)
self.assertEquals(self.ed.LineCount, i + 2)
end = time.time()
duration = end - start
print("%6.3f testAddLine" % duration)
self.xite.DoEvents()
self.assert_(self.ed.Length > 0)
def testAddLineMiddle(self):
data = (string.ascii_letters + string.digits + "\n").encode('utf-8')
start = time.time()
for i in range(1000):
self.ed.AddText(len(data), data)
self.assertEquals(self.ed.LineCount, i + 2)
end = time.time()
duration = end - start
print("%6.3f testAddLineMiddle" % duration)
self.xite.DoEvents()
self.assert_(self.ed.Length > 0)
def testHuge(self):
data = (string.ascii_letters + string.digits + "\n").encode('utf-8')
data = data * 100000
start = time.time()
self.ed.AddText(len(data), data)
end = time.time()
duration = end - start
print("%6.3f testHuge" % duration)
self.xite.DoEvents()
self.assert_(self.ed.Length > 0)
def testHugeInserts(self):
data = (string.ascii_letters + string.digits + "\n").encode('utf-8')
data = data * 100000
insert = (string.digits + "\n").encode('utf-8')
self.ed.AddText(len(data), data)
start = time.time()
for i in range(1000):
self.ed.InsertText(0, insert)
end = time.time()
duration = end - start
print("%6.3f testHugeInserts" % duration)
self.xite.DoEvents()
self.assert_(self.ed.Length > 0)
def testHugeReplace(self):
oneLine = (string.ascii_letters + string.digits + "\n").encode('utf-8')
data = oneLine * 100000
insert = (string.digits + "\n").encode('utf-8')
self.ed.AddText(len(data), data)
start = time.time()
for i in range(1000):
self.ed.TargetStart = i * len(insert)
self.ed.TargetEnd = self.ed.TargetStart + len(oneLine)
self.ed.ReplaceTarget(len(insert), insert)
end = time.time()
duration = end - start
print("%6.3f testHugeReplace" % duration)
self.xite.DoEvents()
self.assert_(self.ed.Length > 0)
def testUTF8CaseSearches(self):
self.ed.SetCodePage(65001)
oneLine = "Fold Margin=折りたたみ表示用の余白(&F)\n".encode('utf-8')
manyLines = oneLine * 100000
manyLines = manyLines + "φ\n".encode('utf-8')
self.ed.AddText(len(manyLines), manyLines)
searchString = "φ".encode('utf-8')
start = time.time()
for i in range(10):
self.ed.TargetStart = 0
self.ed.TargetEnd = self.ed.Length-1
self.ed.SearchFlags = self.ed.SCFIND_MATCHCASE
pos = self.ed.SearchInTarget(len(searchString), searchString)
self.assert_(pos > 0)
end = time.time()
duration = end - start
print("%6.3f testUTF8CaseSearches" % duration)
self.xite.DoEvents()
def testUTF8Searches(self):
self.ed.SetCodePage(65001)
oneLine = "Fold Margin=折りたたみ表示用の余白(&F)\n".encode('utf-8')
manyLines = oneLine * 100000
manyLines = manyLines + "φ\n".encode('utf-8')
self.ed.AddText(len(manyLines), manyLines)
searchString = "φ".encode('utf-8')
start = time.time()
for i in range(10):
self.ed.TargetStart = 0
self.ed.TargetEnd = self.ed.Length-1
self.ed.SearchFlags = 0
pos = self.ed.SearchInTarget(len(searchString), searchString)
self.assert_(pos > 0)
end = time.time()
duration = end - start
print("%6.3f testUTF8Searches" % duration)
self.xite.DoEvents()
if __name__ == '__main__':
Xite.main("performanceTests")
| Python |
# -*- coding: utf-8 -*-
import ctypes, os, sys, unittest
from PySide.QtCore import *
from PySide.QtGui import *
import ScintillaCallable
sys.path.append("..")
from bin import ScintillaEditPy
scintillaDirectory = ".."
scintillaIncludeDirectory = os.path.join(scintillaDirectory, "include")
scintillaScriptsDirectory = os.path.join(scintillaDirectory, "scripts")
sys.path.append(scintillaScriptsDirectory)
import Face
class Form(QDialog):
def __init__(self, parent=None):
super(Form, self).__init__(parent)
self.resize(460,300)
# Create widget
self.edit = ScintillaEditPy.ScintillaEdit(self)
class XiteWin():
def __init__(self, test=""):
self.face = Face.Face()
self.face.ReadFromFile(os.path.join(scintillaIncludeDirectory, "Scintilla.iface"))
self.test = test
self.form = Form()
scifn = self.form.edit.send(int(self.face.features["GetDirectFunction"]["Value"]), 0, 0)
sciptr = ctypes.c_char_p(self.form.edit.send(
int(self.face.features["GetDirectPointer"]["Value"]), 0,0))
self.ed = ScintillaCallable.ScintillaCallable(self.face, scifn, sciptr)
self.form.show()
def DoStuff(self):
print(self.test)
self.CmdTest()
def DoEvents(self):
QApplication.processEvents()
def CmdTest(self):
runner = unittest.TextTestRunner()
tests = unittest.defaultTestLoader.loadTestsFromName(self.test)
results = runner.run(tests)
print(results)
sys.exit(0)
xiteFrame = None
def main(test):
global xiteFrame
app = QApplication(sys.argv)
xiteFrame = XiteWin(test)
xiteFrame.DoStuff()
sys.exit(app.exec_())
| Python |
# -*- coding: utf-8 -*-
import XiteWin
if __name__ == "__main__":
XiteWin.main("")
| Python |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
""" Define the menu structure used by the Pentacle applications """
MenuStructure = [
["&File", [
["&New", "<control>N"],
["&Open...", "<control>O"],
["&Save", "<control>S"],
["Save &As...", "<control><shift>S"],
["Test", ""],
["Exercised", ""],
["Uncalled", ""],
["-", ""],
["&Exit", ""]]],
[ "&Edit", [
["&Undo", "<control>Z"],
["&Redo", "<control>Y"],
["-", ""],
["Cu&t", "<control>X"],
["&Copy", "<control>C"],
["&Paste", "<control>V"],
["&Delete", "Del"],
["Select &All", "<control>A"],
]],
]
| Python |
from sys import argv
First = {}
Follow = {}
nterminais = {}
NT_SEM_SIGMA = {}
NULO = set([])
SIGMA = '%'
SEPARA_PROD = '@'
SEPARA_ALT = '|'
FIM_ENTRADA = '$'
COD_NT = {}
COD_T = {}
COD_R = {}
REGRA = {}
def first(cadeia, i):
global First, nterminais, SIGMA
if cadeia == []:
return set([])
N = len(cadeia) - 1
#print i, cadeia
simbolo = cadeia[i]
if simbolo not in nterminais:
if simbolo not in First: First[simbolo] = set([simbolo])
return First[simbolo]
else: # simbolo nao-terminal
F = First[simbolo]
if SIGMA in First[simbolo] and i < N:
# print "cadeia = ", cadeia, "i=",i,"+1 < ", len(cadeia), " F, simbolo = ", F," ",simbolo
return First[simbolo] - set([SIGMA]) | first(cadeia, i+1)
elif i == N:
F |= set(SIGMA)
return F
def calcFirst():
global First
global nterminais
global NULO
while(True):
mudou = False
for NT in nterminais.keys():
for cadeia in nterminais[NT]:
# print "pre"
F = first(cadeia, 0)
# print "pos"
if F - First[NT] != set([]):
mudou = True
First[NT] |= F
if not mudou:
return
def follow(nome, cadeia):
global Follow, First, nterminais, SIGMA, NULO
mudou = False
N = len(cadeia) - 1
for i, simbolo in enumerate(cadeia):
if simbolo in nterminais:
if i == N:
F = Follow[nome]
else:
F = first(cadeia, i+1)
if SIGMA in F:
F.remove(SIGMA)
F |= Follow[nome]
if F - Follow[simbolo] != NULO:
Follow[simbolo] |= F
mudou = True
return mudou
def calcFollow():
global First
global nterminais
global Follow
while(True):
mudou = False
for NT in nterminais.keys():
for cadeia in nterminais[NT]:
mudou |= follow(NT, cadeia)
if not mudou:
return
def code(simbolo):
if simbolo in COD_NT:
return str(COD_NT[simbolo])
else:
return str(COD_T[simbolo])
def isntSigma(x):
global SIGMA
return x != SIGMA
def leGramatica(nomeArquivo):
global SEPARA_PROD, SEPARA_ALT, COD_NT, COD_T, COD_R, REGRA, SIGMA, NT_SEM_SIGMA
global Follow, First
inFile = file(inFilePath, "r")
start = inFile.tell()
StartGram = inFile.readline().split(SEPARA_PROD)[0].strip()
inFile.seek(start)
Follow[StartGram] = set([FIM_ENTRADA])
print '============== READING ================'
nt_i = 0
for line in inFile:
print "Linha da entrada: {0}".format(line)
line = line.split(SEPARA_PROD)
nome = line[0].strip()
print line
producoes = line[1]
if nome not in First: First[nome] = set()
if nome not in COD_NT:
COD_NT[nome] = nt_i
nt_i += 1
print "CODIGO DO NAO TERMINAL {0}: {1}".format(nome, nt_i - 1)
if nome not in Follow: Follow[nome] = set()
if nome not in nterminais: nterminais[nome] = []
producoes = [ prod.split() for prod in producoes.split(SEPARA_ALT) ]
nterminais[nome].extend(producoes)
COD_T[FIM_ENTRADA] = nt_i
COD_T[SIGMA] = nt_i + 1
t_i = nt_i + 2
for NT in nterminais:
for cadeia in nterminais[NT]:
for simbolo in cadeia:
if simbolo not in COD_T and simbolo not in nterminais:
COD_T[simbolo] = t_i
t_i += 1
print "CODIGO DO TERMINAL {0}: {1}".format(simbolo, t_i - 1)
i_r = 0
NT_ordered = [x[0] for x in sorted(COD_NT.items(), key=lambda x:x[1])]
for NT in NT_ordered:
print NT
NT_SEM_SIGMA[NT] = []
for cadeia in nterminais[NT]:
regra = " ".join(map(code, cadeia))
NT_SEM_SIGMA[NT].append(cadeia)
if regra not in COD_R:
REGRA[i_r] = cadeia
COD_R[regra] = i_r
i_r += 1
print "CODIGO DA REGRA {0} -> {1}: {2}".format(NT, regra, i_r - 1)
if NT_SEM_SIGMA[NT] == []:
del(NT_SEM_SIGMA[NT])
inFile.close()
if __name__ == "__main__":
if len(argv) != 3:
print "uso:", argv[0],"gramatica.txt", "saida.txt"
exit()
inFilePath = argv[1]
outFilePath = argv[2]
leGramatica(inFilePath)
print '============== FIRSTS ================'
calcFirst()
for k in sorted(nterminais.keys()):
print k, First[k]
print '============== FOLLOWS ================'
calcFollow()
for k in sorted(nterminais.keys()):
print k, Follow[k]
print '============== TABELANDO ================'
outFile = file(outFilePath, "w")
#M = [ []*len( COD_T ) ]*len( COD_NT )
NUM_NT = len(COD_NT)
outFile.write(str(NUM_NT) + "\n")
print "ordem da saida:\nnumero de nao terminais"
print "se numero de nao terminais = {0}, proximas {0} linhas serao os nao terminais pela ordem dos indices na tabela".format(NUM_NT)
nt_ordered = [i[0] for i in sorted(COD_NT.items(), key=lambda x:x[1])]
for NT in nt_ordered:
outFile.write(NT+"\n")
for NT in nt_ordered[:3]:
print NT
print "..."
print "agora vem o numero de terminais"
NUM_T = len(COD_T)
outFile.write(str(NUM_T)+"\n")
print "proximas {0} linhas serao os terminais pela ordem dos indices na tabela".format(NUM_T)
t_ordered = [i[0] for i in sorted(COD_T.items(), key=lambda x:x[1])]
vvv = 0
for T in t_ordered:
outFile.write(T+"\n")
print vvv+len(COD_NT),T
vvv += 1
#for T in t_ordered[:3]:
# print T
print "..."
print "agora vem o numero derivacoes"
NUM_R = len(COD_R)
print "proximas {0} linhas serao as derivacoes lista de codigos dos valores da tabela".format(NUM_R)
r_ordered = [x[0] for x in sorted(COD_R.items(), key=lambda x:x[1])]
outFile.write(str(NUM_R)+"\n")
for i, R in enumerate(r_ordered):
print i, R
outFile.write(R+"\n")
#for R in r_ordered[:3]:
# print R
print "..."
print
print "por ultimo as linhas seguintes terao 3 ou mais numeros, primeiro e o indice do nao terminal, segundo o do terminal, terceiro a da regra, correspondem a M[nt,t] = regra"
print "nota: indice dos terminais serao de Maior_indice_dos_NT +1 ate Maior_indice_dos_NT + Maior_indice_dos_T + 1"
print "isso pra poder botar todos simbolos em um vetor so e usar esse indice na tabela."
deb = file("deb.txt","w")
print "asidfa\nsdlf\nuuiu\niui"
for NT in nt_ordered:
for cadeia in NT_SEM_SIGMA[NT]:
Fi = first(cadeia,0)
Fo = Follow[NT]
for terminal in t_ordered:
if terminal in Fi:
regra = " ".join(map(code, cadeia))
#M[COD_NT[NT]] [COD_T[terminal]] = COD_R[str(cadeia)]regra = " ".join(map(lamda x: str(code(x)), cadeia))
deb.write("NT: {2} terminal: {0}, regra: {1}\n".format(terminal, cadeia, NT))
outFile.write("{0} {1} {2}\n".format(COD_NT[NT], COD_T[terminal], COD_R[regra]))
if NT == "<PRODUTO>":
print("NT: {0} , regra: {1} tud {2}".format(NT,cadeia,NT_SEM_SIGMA[NT]))
#print "{0} {1} {2} x1 -".format(COD_NT[NT], COD_T[terminal], COD_R[regra])
print "M[{0}][{1}] = {2}\n".format(NT, terminal, REGRA[COD_R[regra]])
if SIGMA in Fi:
for t in Fo:
regra = " ".join(map(code, cadeia))
#M[COD_NT[NT]] [COD_T[t]] = COD_R[str(cadeia)]regra = " ".join(map(lamda x: str(code(x)), cadeia))
deb.write("NT: {2} t: {0}, regra: {1}\n".format(t, cadeia, NT))
outFile.write("{0} {1} {2}\n".format(COD_NT[NT], COD_T[t], COD_R[regra]))
if NT == "<PRODUTO>":
print("NT: {0} , regra: {1} tud {2}".format(NT,cadeia,NT_SEM_SIGMA[NT]))
#print "{0} {1} {2} x1 -".format(COD_NT[NT], COD_T[t], COD_R[regra])
print "M[{0}][{1}] = {2}\n".format(NT, t, REGRA[COD_R[regra]])
print "Dados da tabela no arquivo: {0}".format(outFilePath)
print first([SIGMA],0)
deb.close()
outFile.close()
| Python |
#!/usr/bin/python
import glob
PRE = """
<PROGRAM> @ PROGRAM id <COMMAND> ENDPROGRAM id
<COMMAND> @ <CONTROLE_INTRINSC> <COMMAND> | %
<CONTROLE_INTRINSC> @ <IF> | <DO> | <FUNC_INTR> | <READ> | <WRITE>
<IF> @ IF ( id ) <COMMAND> ENDIF
<FUNC_INTRINS> @ SQRT ( token_LitInteger ) | POW ( token_LitInteger, token_LitInteger) | MOD ( token_LitInteger, token_LitInteger)
<DO> @ DO id ( token_LitInteger) , ( token_LitInteger) , ( token_LitInteger ) <COMMAND> ENDDO
<WRITE> @ WRITE ( tokenAst , tokenAst ) <SAIDA_WRITE>
<SAIDA_WRITE> @ id | token_LitString
<READ> @ READ ( tokenAst , tokenAst ) id
"""
POS = """
P -> p i C e i
C -> C_ C | %
C_ -> I D F R W
I -> 'if' ( i ) C 'e_if'
F -> 'sqr' ( 5 ) | 'pow' ( 5 , 5 ) | 'mod' ( 5 , 5 )
D -> d i ( 5) , ( 5 ) , ( 5 ) , C , 'e_do'
W -> w ( * , * ) i
S -> i | ""
R -> r ( * , * ) i
"""
T = dict()
def preparaMapa():
for k, v in zip( PRE.split(), POS.split() ):
T[k]
T = dict.fromkeys(PRE.split(), POS.split())
if __name__ == "__main__":
filenames = glob.glob("*.rec.4f")
preparaMapa()
print T
for k in sorted(T.keys()):
print T[k]
| Python |
#!/usr/bin/python
import glob
PRE = """
<PROGRAM> @ PROGRAM id <COMMAND> ENDPROGRAM id
<COMMAND> @ <CONTROLE_INTRINSC> <COMMAND> | %
<CONTROLE_INTRINSC> @ <IF> | <DO> | <FUNC_INTR> | <READ> | <WRITE>
<IF> @ IF ( id ) <COMMAND> ENDIF
<FUNC_INTRINS> @ SQRT ( token_LitInteger ) | POW ( token_LitInteger, token_LitInteger) | MOD ( token_LitInteger, token_LitInteger)
<DO> @ DO id ( token_LitInteger) , ( token_LitInteger) , ( token_LitInteger ) <COMMAND> ENDDO
<WRITE> @ WRITE ( tokenAst , tokenAst ) <SAIDA_WRITE>
<SAIDA_WRITE> @ id | token_LitString
<READ> @ READ ( tokenAst , tokenAst ) id
"""
POS = """
P -> p i C e i
C -> C_ C | %
C_ -> I D F R W
I -> 'if' ( i ) C 'e_if'
F -> 'sqr' ( 5 ) | 'pow' ( 5 , 5 ) | 'mod' ( 5 , 5 )
D -> d i ( 5) , ( 5 ) , ( 5 ) , C , 'e_do'
W -> w ( * , * ) i
S -> i | ""
R -> r ( * , * ) i
"""
T = dict()
def preparaMapa():
for k, v in zip( PRE.split(), POS.split() ):
T[k]
T = dict.fromkeys(PRE.split(), POS.split())
if __name__ == "__main__":
filenames = glob.glob("*.rec.4f")
preparaMapa()
print T
for k in sorted(T.keys()):
print T[k]
| Python |
with open("res.t", "r") as f:
out = open("res_cons.txt", "w")
for l in f:
if l != None:
first, second = l.split()
out.write("{0} {0}\n".format(first,first))
| Python |
from twisted.application import internet, service
from nevow import appserver
from forms.examples import main
application = service.Application('examples')
service = internet.TCPServer(8000, main.makeSite(application))
service.setServiceParent(application)
| Python |
from setuptools import setup, find_packages
import forms
setup(
name='forms',
version=forms.version,
description='HTML forms framework for Nevow',
author='Matt Goodall',
author_email='matt@pollenation.net',
packages=find_packages(),
package_data={
'forms': ['forms.css', 'html/*', 'js/*'],
},
zip_safe = True,
)
| Python |
from datetime import date, time
from twisted.application import internet, service
from nevow import appserver, compy, loaders, rend, static, tags as T
import forms
import os
from shutil import copyfileobj
import mimetypes, datetime
from forms import iforms, htmleditor, converters
from fileresource import fileResource
class KeyToFileConverter( object ):
__implements__ = iforms.IFileConvertible,
def fromType( self, value, context=None ):
"""
Given a string generate a (mimetype, filelike, fileName) or None
"""
if not value or value == '':
return None
mimetype = mimetypes.guess_type( value )
filelike = open(os.path.join('images',value),'r')
return (mimetype, filelike, value)
def toType( self, value ):
"""
Given a (mimetype, filelike, filename) tuple return a string
"""
if not value:
return None
(mimetype, filelike,fileName) = value;
target = file(os.path.join('images',fileName),'w')
copyfileobj( filelike, target )
target.close()
filelike.close()
return fileName
dates = [
(date(2005,1,1), 'New year\'s day'),
(date(2005,11,6), 'My birthday'),
(date(2005,12,25), 'Christmas day'),
]
times = [
(time(5,0), 'Really early'),
(time(7,0), 'A bit too early'),
(time(8,0), 'Hmm, not bad'),
(time(10,0), 'Nice :)'),
]
class Person(object):
def __init__(self, id, firstName, lastName):
self.id = id
self.firstName = firstName
self.lastName = lastName
class PersonKeyLabelAdapter(object):
__implements__ = iforms.IKey, iforms.ILabel
def __init__(self, original):
self.original = original
def key(self):
return self.original.id
def label(self):
return '%s, %s' % (self.original.lastName, self.original.firstName)
compy.registerAdapter(PersonKeyLabelAdapter, Person, iforms.IKey)
compy.registerAdapter(PersonKeyLabelAdapter, Person, iforms.ILabel)
people = [
Person(1, 'Matt', 'Goodall'),
Person(2, 'Tim', 'Parkin'),
]
class Page(rend.Page, forms.ResourceMixin):
addSlash = True
docFactory = loaders.xmlfile('test.html')
def __init__(self, *a, **k):
rend.Page.__init__(self, *a, **k)
forms.ResourceMixin.__init__(self)
def child_self(self, ctx):
return self
def form_oneOfEach(self, ctx):
form = forms.Form(self._submit)
form.addField('hidden_string', forms.Integer(), forms.Hidden)
form.addField('string', forms.String(required=True))
form.addField('password', forms.String(), forms.CheckedPassword)
form.addField('integer', forms.Integer())
form.addField('float', forms.Float())
form.addField('boolean', forms.Boolean())
form.addField('date', forms.Date(), forms.widgetFactory(forms.MMYYDatePartsInput, cutoffYear=38))
form.addField('time', forms.Time())
form.addAction(self._submit)
form.data = {'hidden_string': 101}
return form
def form_readonlyOneOfEach(self, ctx):
form = forms.Form(self._submit)
immutable=True
form.addField('string', forms.String(immutable=immutable), forms.TextInput)
form.addField('textarea', forms.String(immutable=immutable), forms.TextArea)
form.addField('password', forms.String(immutable=immutable), forms.CheckedPassword)
form.addField('integer', forms.Integer(immutable=immutable))
form.addField('float', forms.Float(immutable=immutable))
form.addField('boolean', forms.Boolean(immutable=immutable), forms.Checkbox)
form.addField('date', forms.Date(immutable=immutable), forms.widgetFactory(forms.MMYYDatePartsInput, cutoffYear=38))
form.addField('date2', forms.Date(immutable=immutable), forms.widgetFactory(forms.DatePartsInput, dayFirst=True))
form.addField('time', forms.Time(immutable=immutable))
form.addField('author', forms.Integer(immutable=immutable), lambda original: forms.SelectChoice(original, people))
form.addField('bar', forms.Sequence(forms.String(),immutable=immutable), forms.widgetFactory(forms.CheckboxMultiChoice, zip('abc','abc')),description='store your bar here')
form.addField('file', forms.File(immutable=immutable), forms.widgetFactory(forms.FileUploadWidget, convertibleFactory=KeyToFileConverter))
form.addAction(self._submit)
form.data = {'string':'hello', 'textarea':'some long text', 'password': ['one','one'], 'integer':10, 'float':22.22, 'boolean':True, 'author': 2, 'file':'dm.gif', 'date': datetime.date(2005, 10, 1), 'bar': ['a'], 'time': datetime.time(12, 51, 30)}
return form
def form_test(self, ctx):
form = forms.Form(self._submit)
form.addField('lastName', forms.String(required=True), label='Surname', description='This should be used to store your surname.. no really!!')
form.addField('date', forms.Date(), forms.widgetFactory(forms.SelectChoice, dates))
form.addField('time', forms.Time(), lambda original: forms.SelectChoice(original, times))
form.addField('author', forms.Integer(), lambda original: forms.SelectChoice(original, people))
form.addField('notes', forms.String(), htmleditor.TinyMCE)
form.addField('foo', forms.Sequence(forms.Time()), forms.widgetFactory(forms.CheckboxMultiChoice, times))
form.addField('bar', forms.Sequence(forms.String(),required=True), forms.widgetFactory(forms.CheckboxMultiChoice, zip('abc','abc')),description='store your bar here')
form.data = {'foo': [time(10,0)]}
form.addAction(self._submit)
form.addAction(self._submit, 'another')
return form
def form_1(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addAction(self._submit)
form.data = {
'name': 'Me!'
}
return form
def form_2(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addAction(self._submit)
form.data = {
'name': 'Me!'
}
return form
def form_3(self, ctx):
''' This test needs an 'assets' folder to store files in. The widget is passed a fileResource which
is used to get a preview url and to save the upload results. commit/rollback type hooks will need
to be added to forms to allow 'clean' operation. -- tp
'''
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addField('file', forms.String(required=True), forms.widgetFactory(forms.FileUpload,fileResource(),preview='image'))
form.addAction(self._submit)
#form.data = {
# 'file': 'product.jpg'
# }
return form
def form_4(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addField('file', forms.File(required=True), forms.widgetFactory(forms.FileUploadWidget, convertibleFactory=KeyToFileConverter))
form.addAction(self._submit)
# form.data = {
# 'file': 'dm.gif'
# }
return form
def _submit(self, ctx, form, data):
print form
print data
if data.get('string') == 'error':
raise forms.FieldError('Failed the field!', 'string')
if data.get('string') == 'formerror':
raise forms.FormError('Failed the form!')
setattr(Page, 'child_nevow-forms.css', forms.defaultCSS)
setattr(Page, 'child_tiny_mce', static.File('tiny_mce'))
setattr(Page, 'child_webassets', static.File('assets'))
setattr(Page, 'child_images', static.File('images'))
setattr(Page, 'child_uploads', static.File('uploads'))
root = Page()
site = appserver.NevowSite(root, logPath='/dev/null')
application = service.Application('forms2-test')
internet.TCPServer(8000, site).setServiceParent(application)
| Python |
import os
from shutil import copyfileobj
FILESTORE_DIR='assets'
FILESTORE_URL='webassets'
class fileResource:
def getUrlForFile(self, id):
if id:
return os.path.join(FILESTORE_URL, id)
else:
return None
def storeFile( self, source, name ):
id = name
target = file(os.path.join(FILESTORE_DIR,id),'w')
copyfileobj( source, target )
target.close()
return id | Python |
"""
Form types.
"""
try:
import decimal
haveDecimal = True
except ImportError:
haveDecimal = False
from zope.interface import implements
from forms import iforms, validation
class Type(object):
implements( iforms.IType )
# Name of the instance
name = None
# Value to use if no value entered
missing = None
# Instance cannot be changed
immutable = False
# List of validators to test the value against
validators = ()
def __init__(self, name=None, required=None, missing=None, immutable=None, validators=None):
if name is not None:
self.name = name
if missing is not None:
self.missing = missing
if immutable is not None:
self.immutable = immutable
if validators is not None:
self.validators = list(validators)
else:
self.validators = list(self.validators)
if required is None:
required = self.required
if required:
self.validators.append(validation.RequiredValidator())
def validate(self, value):
for validator in self.validators:
validator.validate(self, value)
if value is None:
value = self.missing
return value
def hasValidator(self, validatorType):
"""
Check for the existance of a validator of a specific type.
"""
for v in self.validators:
if isinstance(v, validatorType):
return True
return False
def required():
def get(self):
return self.hasValidator(validation.RequiredValidator)
return get,
required = property(*required())
class String(Type):
# Strip the value before validation
strip = False
def __init__(self, **k):
strip = k.pop('strip', None)
if strip is not None:
self.strip = strip
super(String, self).__init__(**k)
def validate(self, value):
if value is not None and self.strip:
value = value.strip()
if not value:
value = None
return super(String, self).validate(value)
class Integer(Type):
pass
class Float(Type):
pass
class Boolean(Type):
pass
class Date(Type):
pass
class Time(Type):
pass
if haveDecimal:
class Decimal(Type):
"""
Forms type for Python 2.4's decimal.Decimal type.
"""
class Sequence(Type):
# Type of items in the sequence
type = None
def __init__(self, type=None, **k):
super(Sequence, self).__init__(**k)
if type is not None:
self.type = type
def validate(self, value):
# Map empty sequence to None
if not value:
value = None
return super(Sequence, self).validate(value)
class File(Type):
pass
__all__ = [
'Boolean', 'Date', 'File', 'Float', 'Integer', 'Sequence', 'String', 'Time',
]
if haveDecimal:
__all__.append('Decimal')
| Python |
"""
Form implementation and high-level renderers.
"""
from zope.interface import Interface
from twisted.internet import defer
from twisted.python.components import registerAdapter
from nevow import appserver, context, loaders, inevow, tags as T, url
from nevow.util import getPOSTCharset
from forms import iforms, util, validation
from resourcemanager import ResourceManager
from zope.interface import implements
SEPARATOR = '!!'
FORMS_KEY = '__nevow_form__'
WIDGET_RESOURCE_KEY = 'widget_resource'
def renderForm(name):
def _(ctx, data):
def _processForm( form, ctx, name ):
# Remember the form
ctx.remember(form, iforms.IForm)
# Create a keyed tag that will render the form when flattened.
tag = T.invisible(key=name)[inevow.IRenderer(form)]
# Create a new context, referencing the above tag, so that we don't
# pollute the current context with anything the form needs during
# rendering.
ctx = context.WovenContext(parent=ctx, tag=tag)
# Find errors for *this* form and remember things on the context
errors = iforms.IFormErrors(ctx, None)
if errors is not None and errors.formName == name:
ctx.remember(errors.data, iforms.IFormData)
else:
ctx.remember(None, iforms.IFormErrors)
ctx.remember(form.data or {}, iforms.IFormData)
return ctx
d = defer.succeed( ctx )
d.addCallback( locateForm, name )
d.addCallback( _processForm, ctx, name )
return d
return _
class Action(object):
"""Tracks an action that has been added to a form.
"""
def __init__(self, callback, name, validate, label):
self.callback = callback
self.name = name
self.validate = validate
if label is None:
self.label = util.titleFromName(name)
else:
self.label = label
class Form(object):
implements( iforms.IForm )
callback = None
actions = None
widgets = None
def __init__(self, callback=None):
if callback is not None:
self.callback = callback
self.resourceManager = ResourceManager()
self.data = {}
self.items = []
def addField(self, name, type, widgetFactory=None, label=None, description=None, cssClass=None):
if not util.validIdentifier(name):
raise ValueError('%r is an invalid field name'%name)
type.name = name
if label is None:
label = util.titleFromName(name)
self.items.append( (name,type,label,description,cssClass) )
if widgetFactory is not None:
if self.widgets is None:
self.widgets = {}
self.widgets[name] = widgetFactory
def addAction(self, callback, name="submit", validate=True, label=None):
if self.actions is None:
self.actions = []
if name in [action.name for action in self.actions]:
raise ValueError('Action with name %r already exists.' % name)
self.actions.append( Action(callback, name, validate, label) )
def getField(self,fieldName):
for name, type, label, description, cssClass in self.items:
if name == fieldName:
return (name, type, label, description, cssClass)
else:
return None
def widgetForItem(self, itemName):
for name, type, label, description, cssClass in self.items:
if name == itemName:
break
else:
raise KeyError()
if self.widgets is not None:
try:
widgetFactory = self.widgets[name]
except KeyError:
pass
else:
return widgetFactory(type)
return iforms.IWidget(type)
def process(self, ctx):
# Get the request args
requestArgs = inevow.IRequest(ctx).args
# Decode the request arg names
charset = getPOSTCharset(ctx)
requestArgs = dict([(k.decode(charset),v) for k,v in requestArgs.iteritems()])
# Unflatten the request into nested dicts.
args = {}
for name, value in requestArgs.iteritems():
name = name.split('.')
group, name = name[:-1], name[-1]
d = args
for g in group:
d = args.setdefault(g,{})
d[name] = value
# Find the callback to use, defaulting to the form default
callback, validate = self.callback, True
if self.actions is not None:
for action in self.actions:
if action.name in args:
# Remove it from the data
args.pop(action.name)
# Remember the callback and whether to validate
callback, validate = action.callback, action.validate
break
if callback is None:
raise Exception('The form has no callback and no action was found.')
# Store an errors object in the context
errors = FormErrors(self.name)
errors.data = args
ctx.remember(errors, iforms.IFormErrors)
# Iterate the items and collect the form data and/or errors.
data = {}
for name, type, label, description, cssClass in self.items:
try:
if not type.immutable:
data[name] = self.widgetForItem(name).processInput(ctx, name, args)
else:
data[name] = self.data.get(name)
errors.data[name] = self.data.get(name)
except validation.FieldError, e:
if validate:
if e.fieldName is None:
e.fieldName = name
errors.add(e)
if errors:
return errors
def _clearUpResources( r ):
self.resourceManager.clearUpResources()
return r
d = defer.maybeDeferred(callback, ctx, self, data)
d.addCallback( _clearUpResources )
d.addErrback(self._cbFormProcessingFailed, ctx)
return d
def _cbFormProcessingFailed(self, failure, ctx):
e = failure.value
failure.trap(validation.FormError, validation.FieldError)
errors = iforms.IFormErrors(ctx)
errors.add(failure.value)
return errors
class FormErrors(object):
implements( iforms.IFormErrors )
def __init__(self, formName):
self.formName = formName
self.errors = []
def add(self, error):
self.errors.append(error)
def getFieldError(self, name):
fieldErrors = [e for e in self.errors if isinstance(e, validation.FieldError)]
for error in fieldErrors:
if error.fieldName == name:
return error
def getFormErrors(self):
return self.errors
def __nonzero__(self):
return len(self.errors) != 0
class FormResource(object):
implements(inevow.IResource)
def locateChild(self, ctx, segments):
# The form name is the first segment
formName = segments[0]
if segments[1] == WIDGET_RESOURCE_KEY:
# Serve up file from the resource manager
d = locateForm(ctx, formName)
d.addCallback(self._fileFromWidget, ctx, segments[2:])
return d
return appserver.NotFound
def renderHTTP(self, ctx):
raise NotImplemented()
def _fileFromWidget(self, form, ctx, segments):
ctx.remember(form, iforms.IForm)
widget = form.widgetForItem(segments[0])
return widget.getResource(ctx, segments[0], segments[1:])
class FormsResourceBehaviour(object):
"""
I provide the IResource behaviour needed to process and render a page
containing a Form.
"""
def __init__(self, **k):
parent = k.pop('parent')
super(FormsResourceBehaviour, self).__init__(**k)
self.parent = parent
def locateChild(self, ctx, segments):
if segments[0] == FORMS_KEY:
self.remember(ctx)
return FormResource(), segments[1:]
return appserver.NotFound
def renderHTTP(self, ctx):
# Get hold of the request
request = inevow.IRequest(ctx)
# Intercept POST requests to see if it's for me
if request.method != 'POST':
return None
# Try to find the form name
formName = request.args.get(FORMS_KEY, [None])[0]
if formName is None:
return None
# Find the actual form and process it
self.remember(ctx)
d = defer.succeed(ctx)
d.addCallback(locateForm, formName)
d.addCallback(self._processForm, ctx)
return d
def remember(self, ctx):
ctx.remember(self.parent, iforms.IFormFactory)
def render_form(self, name):
def _(ctx, data):
self.remember(ctx)
return renderForm(name)
return _
def _processForm(self, form, ctx):
ctx.remember(form, iforms.IForm)
d = defer.maybeDeferred(form.process, ctx)
d.addCallback(self._formProcessed, ctx)
return d
def _formProcessed(self, result, ctx):
if isinstance(result, FormErrors):
return None
elif result is None:
resource = url.URL.fromContext(ctx)
else:
resource = result
return resource
class ResourceMixin(object):
implements( iforms.IFormFactory )
__formsBehaviour = None
def __behaviour(self):
if self.__formsBehaviour is None:
self.__formsBehaviour = FormsResourceBehaviour(parent=self)
return self.__formsBehaviour
def locateChild(self, ctx, segments):
def gotResult(result):
if result is not appserver.NotFound:
return result
return super(ResourceMixin, self).locateChild(ctx, segments)
self.remember(self, iforms.IFormFactory)
d = defer.maybeDeferred(self.__behaviour().locateChild, ctx, segments)
d.addCallback(gotResult)
return d
def renderHTTP(self, ctx):
def gotResult(result):
if result is not None:
return result
return super(ResourceMixin, self).renderHTTP(ctx)
self.remember(self, iforms.IFormFactory)
d = defer.maybeDeferred(self.__behaviour().renderHTTP, ctx)
d.addCallback(gotResult)
return d
def render_form(self, name):
return self.__behaviour().render_form(name)
def formFactory(self, ctx, name):
factory = getattr(self, 'form_%s'%name, None)
if factory is not None:
return factory(ctx)
s = super(ResourceMixin, self)
if hasattr(s,'formFactory'):
return s.formFactory(ctx, name)
class IKnownForms(Interface):
"""Marker interface used to locate a dict instance containing the named
forms we know about during this request.
"""
class KnownForms(dict):
implements( IKnownForms )
def locateForm(ctx, name):
"""Locate a form by name.
Initially, a form is located by calling on an IFormFactory that is found
on the context. Once a form has been found, it is remembered in an
KnownForms instance for the lifetime of the request.
This ensures that the form that is located during form processing will be
the same instance that is located when a form is rendered after validation
failure.
"""
# Get hold of the request
request = inevow.IRequest(ctx)
# Find or create the known forms instance
knownForms = request.getComponent(IKnownForms)
if knownForms is None:
knownForms = KnownForms()
request.setComponent(IKnownForms, knownForms)
# See if the form is already known
form = knownForms.get(name)
if form is not None:
return form
# Not known yet, ask a form factory to create the form
factory = ctx.locate(iforms.IFormFactory)
def cacheForm( form, name ):
if form is None:
raise Exception('Form %r not found'%name)
form.name = name
# Make it a known
knownForms[name] = form
return form
d = defer.succeed( None )
d.addCallback( lambda r : factory.formFactory( ctx, name ) )
d.addCallback( cacheForm, name )
return d
def widgetResourceURL(name):
return url.here.child(FORMS_KEY).child(name).child(WIDGET_RESOURCE_KEY)
def widgetResourceURLFromContext(ctx,name):
# Could this replace widgetResourceURL?
u = url.URL.fromContext(ctx)
if u.pathList()[-1] != FORMS_KEY:
u = u.child(FORMS_KEY)
return u.child(name).child(WIDGET_RESOURCE_KEY)
class FormRenderer(object):
implements( inevow.IRenderer )
loader = loaders.stan(
T.form(id=T.slot('id'), action=T.slot('action'), class_='nevow-form', method='post', enctype='multipart/form-data', **{'accept-charset':'utf-8'})[
T.fieldset[
T.input(type='hidden', name='_charset_'),
T.input(type='hidden', name=FORMS_KEY, value=T.slot('name')),
T.slot('errors'),
T.slot('items'),
T.div(id=T.slot('fieldId'), pattern='item', _class=T.slot('class'))[
T.label(_class='label', _for=T.slot('id'))[T.slot('label')],
T.div(_class='inputs')[T.slot('inputs')],
T.slot('description'),
T.slot('message'),
],
T.div(class_='hiddenitems')[
T.slot('hiddenitems'),
T.invisible(pattern="hiddenitem")[T.slot('inputs')]
],
T.div(class_='actions')[
T.slot('actions'),
],
],
]
)
def __init__(self, original, *a, **k):
super(FormRenderer, self).__init__(*a, **k)
self.original = original
def rend(self, ctx, data):
tag = T.invisible[self.loader.load()]
tag.fillSlots('name', self.original.name)
tag.fillSlots('id', util.keytocssid(ctx.key))
tag.fillSlots('action', url.here)
tag.fillSlots('errors', self._renderErrors)
tag.fillSlots('items', self._renderItems)
tag.fillSlots('hiddenitems', self._renderHiddenItems)
tag.fillSlots('actions', self._renderActions)
return tag
def _renderErrors(self, ctx, data):
errors = iforms.IFormErrors(ctx, None)
if errors is not None:
errors = errors.getFormErrors()
if not errors:
return ''
errorList = T.ul()
for error in errors:
if isinstance(error, validation.FormError):
errorList[ T.li[ error.message ] ]
for error in errors:
if isinstance(error, validation.FieldError):
name, type, label, description, cssClass = self.original.getField(error.fieldName)
errorList[ T.li[ T.strong[ label, ' : ' ], error.message ] ]
return T.div(class_='errors')[ T.p['Please correct the following errors:'], errorList ]
def _renderItems(self, ctx, data):
if self.original.items is None:
yield ''
return
itemPattern = inevow.IQ(ctx).patternGenerator('item')
for item in self.original.items:
widget = self.original.widgetForItem(item[0])
if getattr(widget,'inputType','') != 'hidden':
yield itemPattern(key=item[0], data=item, render=self._renderItem)
def _renderHiddenItems(self, ctx, data):
if self.original.items is None:
yield ''
return
hiddenItemPattern = inevow.IQ(ctx).patternGenerator('hiddenitem')
for item in self.original.items:
widget = self.original.widgetForItem(item[0])
if getattr(widget,'inputType','') == 'hidden':
yield hiddenItemPattern(key=item[0], data=item, render=self._renderHiddenItem)
def _renderItem(self, ctx, data):
def _(ctx, data):
name, type, label, description, cssClass = data
form = self.original
formErrors = iforms.IFormErrors(ctx, None)
formData = iforms.IFormData(ctx)
widget = form.widgetForItem(name)
if formErrors is None:
error = None
else:
error = formErrors.getFieldError(name)
# Basic classes are 'field', the type's class name and the widget's
# class name.
classes = [
'field',
type.__class__.__name__.lower(),
widget.__class__.__name__.lower(),
]
# Add a required class
if type.required:
classes.append('required')
# Add a user-specified class
if cssClass:
classes.append(cssClass)
if error is None:
message = ''
else:
classes.append('error')
message = T.div(class_='message')[error.message]
ctx.tag.fillSlots('class', ' '.join(classes))
ctx.tag.fillSlots('fieldId', '%s-field'%util.keytocssid(ctx.key))
ctx.tag.fillSlots('id', util.keytocssid(ctx.key))
ctx.tag.fillSlots('label', label)
if type.immutable:
render = widget.renderImmutable
else:
render = widget.render
ctx.tag.fillSlots('inputs', render(ctx, name, formData, formErrors))
ctx.tag.fillSlots('message', message)
ctx.tag.fillSlots('description', T.div(class_='description')[description or ''])
return ctx.tag
return _
def _renderHiddenItem(self, ctx, data):
def _(ctx, data):
name, type, label, description, cssClass = data
form = self.original
formErrors = iforms.IFormErrors(ctx, None)
formData = iforms.IFormData(ctx)
widget = form.widgetForItem(name)
ctx.tag.fillSlots('fieldId', '%s-field'%util.keytocssid(ctx.key))
ctx.tag.fillSlots('id', util.keytocssid(ctx.key))
ctx.tag.fillSlots('inputs', widget.render(ctx, name, formData, formErrors))
return ctx.tag
return _
def _renderActions(self, ctx, data):
if self.original.actions is None:
yield ''
return
for action in self.original.actions:
yield T.invisible(data=action, render=self._renderAction)
def _renderAction(self, ctx, data):
return T.input(type='submit', id='%s-action-%s'%(util.keytocssid(ctx.key), data.name), name=data.name, value=data.label)
registerAdapter(FormRenderer, Form, inevow.IRenderer)
| Python |
from nevow import tags as T, util
from forms import iforms
from zope.interface import implements
tinyMCEGlue = T.xml("""
<!-- tinyMCE -->
<script language="javascript" type="text/javascript" src="/tiny_mce/tiny_mce.js"></script>
<script language="javascript" type="text/javascript">
tinyMCE.init({
mode : "specific_textareas"
theme: 'advanced',
theme_advanced_toolbar_location: 'top',
theme_advanced_toolbar_align: 'left'
});
</script>
<!-- /tinyMCE -->
""" )
class TinyMCE(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return T.textarea(name=key, id=key, mce_editable='true')[value or '']
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
if value:
value=T.xml(value)
else:
value=''
return T.div(id=key, class_="readonly-textarea-container") [
T.div(class_='readonly-textarea readonly')[value]
]
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
| Python |
from nevow import appserver, rend
from forms.form import FormsResourceBehaviour
class FormPage(rend.Page):
"""
Base class for pages that contain a Form.
XXX This really, really needs to turn into a ComponentPage that iterates
a bunch of component behaviours looking for something that succeeded.
The components probably needs to be per-interface, i.e IResource for
locateChild/renderHTTP, IRenderer for render_, etc.
"""
def __init__(self, *a, **k):
rend.Page.__init__(self, *a, **k)
self._formsComponent = FormsResourceBehaviour(parent=self)
def locateChild(self, ctx, segments):
def gotResult(result):
if result is not appserver.NotFound:
return result
return rend.Page.locateChild(self, ctx, segments)
d = defer.maybeDeferred(self._formsComponent.locateChild, ctx, segments)
d.addCallback(gotResult)
return d
def renderHTTP(self, ctx):
def gotResult(result):
if result is not None:
return result
return rend.Page.renderHTTP(self, ctx)
d = defer.maybeDeferred(self._formsComponent.renderHTTP, ctx)
d.addCallback(gotResult)
return d
def render_form(self, name):
return self._formsComponent.render_form(name)
def formFactory(self, ctx, name):
# Find the factory method
factory = getattr(self, 'form_%s'%name, None)
if factory is not None:
return factory(ctx)
# Try the super class
s = super(FormPage, self)
if hasattr(s,'formFactory'):
return s.formFactory(ctx, name)
| Python |
import tempfile
import mimetypes
import re
import os
from shutil import copyfileobj
from exceptions import IOError, OSError
class ResourceManagerException( Exception ):
def __init__( self, *args, **kwds ):
super( ResourceManagerException, self ).__init__( *args, **kwds )
class ResourceManager( object ):
def __init__( self ):
self.widgetToID = {}
def register( self, widgetName, resourceId ):
self.widgetToID[widgetName] = resourceId
def getResourceId( self, widgetName ):
return self.widgetToID.get( widgetName )
def getResourceForWidget( self, widgetName ):
resourceId = self.getResourceId( widgetName )
if resourceId is None:
return None
(path, fileName) = self._fromResourceId( resourceId )
mimetype = mimetypes.guess_type( fileName )[0]
try:
filelike = open( path, 'r' )
return (mimetype, filelike, fileName)
except IOError:
return None
def getResourcePath( self, resourceId ):
"""
Required to create an instance of nevow.static.File
"""
(path, fileName) = self._fromResourceId( resourceId )
mimetype = mimetypes.guess_type( fileName )[0]
return (mimetype, path, fileName)
def setResource( self, widgetName, filelike, fileName ):
existingResource = self.widgetToID.get( widgetName )
if existingResource is not None:
try:
(path, ignore) = self._fromResourceId( existingResource )
os.remove( path )
except OSError:
pass
# Encode the filename to avoid any unicode filesystem errors.
fileName = self._encodeFilename(fileName)
(target, path) = tempfile.mkstemp( '__' + fileName )
# target is a file handle. We want a file object.
target = os.fdopen(target, 'w')
copyfileobj( filelike, target )
target.close()
resourceId = self._toResourceId( path )
self.widgetToID[widgetName] = resourceId
return resourceId
def _fromResourceId( self, resourceId ):
match = re.match( '^.*__(.*)$', resourceId )
if match is None:
return None
fileName = match.group( 1 )
path = os.sep.join( (tempfile.gettempdir(), resourceId) )
return path, self._decodeFilename(fileName)
def _toResourceId( self, path ):
path = path[len(tempfile.gettempdir()):]
if path[0] == os.sep:
path = path[1:]
return path
def clearUpResources( self ):
for id in self.widgetToID.values():
try:
(path, fileName) = self._fromResourceId( id )
os.remove( path )
except OSError:
pass
def _encodeFilename(self, filename):
"""
Encode the filename (which may be unicode) so it's safe to use with
the filesystem.
NOTE: the string encode('base64') can result in strings with '\n'
embedded in them. the base64.b64encode() does not appear to suffer this
problem.
"""
import base64
rv = filename.encode('utf-8')
rv = base64.b64encode(rv)
return rv
def _decodeFilename(self, filename):
"""
Undo what _encodeFilename did.
"""
import base64
rv = base64.b64decode(filename)
rv = rv.decode('utf-8')
return rv
| Python |
"""
ReST text area widget.
"""
from nevow import inevow, loaders, rend, tags as T
from forms import iforms, widget
from forms.util import keytocssid
from forms.form import widgetResourceURLFromContext
class ReSTTextArea(widget.TextArea):
"""
A large text entry area that accepts ReST and previews it as HTML
This will accept a restWriter parameter
"""
restWriter = None
def __init__(self, original, **kwds):
restWriter = kwds.pop('restWriter', None)
super(ReSTTextArea, self).__init__(original, **kwds)
if restWriter is not None:
self.restWriter = restWriter
def _renderTag(self, ctx, key, value, readonly):
tag=T.invisible()
ta=T.textarea(name=key, id=keytocssid(ctx.key), cols=self.cols, rows=self.rows)[value or '']
if readonly:
ta(class_='readonly', readonly='readonly')
tag[ta]
if not readonly:
try:
import docutils
except ImportError:
raise
else:
form = iforms.IForm( ctx )
srcId = keytocssid(ctx.key)
previewDiv = srcId + '-preview-div'
frameId = srcId + '-preview-frame'
targetURL = widgetResourceURLFromContext(ctx, form.name).child(key).child( srcId )
tag[T.br()]
tag[T.button(onClick="return Forms.Util.previewShow('%s', '%s', '%s');"%(previewDiv, frameId, targetURL))['Preview ...']]
tag[T.div(id=previewDiv, class_="preview-hidden")[
T.iframe(class_="preview-frame", name=frameId, id=frameId),
T.br(),
T.button(onClick="return Forms.Util.previewHide('%s');"%(previewDiv))['Close']
]
]
return tag
def getResource(self, ctx, key, segments):
return ReSTPreview(ctx, self.restWriter, key, segments[0]), segments[1:]
class ReSTPreview(rend.Page):
def __init__(self, ctx, restWriter, key, srcId):
self.restWriter = restWriter
form = iforms.IForm( ctx )
u = widgetResourceURLFromContext(ctx, form.name).child(key).child( srcId ).child('_submit')
self.destId=srcId + '-dest'
formId=srcId + '-form'
stan = T.html()[
T.head()[
T.script(type="text/javascript")["""
function ReSTTranslate() {
dest = document.getElementById('%(destId)s');
form = document.getElementById('%(formId)s');
src = parent.document.getElementById('%(srcId)s');
dest.value = src.value;
form.submit();
}
"""%{'srcId':srcId, 'destId':self.destId, 'formId':formId}]
],
T.body()[
T.form(id=formId, method="POST", action=u)[
T.input(type="hidden", name=self.destId, id=self.destId)
],
T.script(type="text/javascript")["ReSTTranslate();"],
],
]
self.docFactory = loaders.stan(stan)
def child__submit(self, ctx):
args = inevow.IRequest(ctx).args
value = args.get(self.destId, [''])[0]
from docutils.utils import SystemMessage
try:
if self.restWriter:
restValue = self._html_fragment(value, writer=self.restWriter)
else:
restValue = self._html_fragment(value, writer_name='html')
except SystemMessage, e:
restValue = str(e)
stan = T.html()[
T.head()[
T.style(type="text/css")["""
.system-message {border: 1px solid red; background-color: #FFFFDD; margin: 5px; padding: 5px;}
.system-message-title { font-weight: bold;}
"""
]
],
T.body()[
T.div()[
T.xml(restValue)
]
],
]
self.docFactory = loaders.stan(stan)
return self
def _html_fragment(self, input_string, writer=None, writer_name=None):
from docutils.core import publish_parts
overrides = {'input_encoding': 'utf8',
'doctitle_xform': 0,
'initial_header_level': 1}
parts = publish_parts(
source=input_string,
writer_name=writer_name, writer=writer, settings_overrides=overrides)
fragment = parts['fragment']
return fragment.encode('utf8')
__all__ = ['ReSTTextArea']
| Python |
from zope.interface import implements
from nevow import tags as T
from forms import iforms
from forms.util import keytocssid
_UNSET = object()
class MultichoiceBase(object):
"""
A base class for widgets that provide the UI to select one or more items
from a list.
Based on ChoiceBase
options:
A sequence of objects adaptable to IKey and ILabel. IKey is used as the
<option>'s value attribute; ILabel is used as the <option>'s child.
IKey and ILabel adapters for tuple are provided.
noneOption:
An object adaptable to IKey and ILabel that is used to identify when
nothing has been selected. Defaults to ('', '')
"""
options = None
noneOption = None
def __init__(self, original, options=None, noneOption=_UNSET):
self.original = original
if options is not None:
self.options = options
if noneOption is not _UNSET:
self.noneOption = noneOption
def processInput(self, ctx, key, args):
values = args.get(key, [''])
rv = []
for value in values:
value = iforms.IStringConvertible(self.original).toType(value)
if self.noneOption is not None and value == self.noneOption[0]:
value = None
rv.append(self.original.validate(value))
return rv
class MultiselectChoice(MultichoiceBase):
"""
A drop-down list of options.
<select>
<option value="...">...</option>
</select>
"""
implements( iforms.IWidget )
noneOption = ('', '')
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOptions(ctx, data):
if self.noneOption is not None:
yield T.option(value=iforms.IKey(self.noneOption).key())[iforms.ILabel(self.noneOption).label()]
if data is None:
return
for item in data:
optValue = iforms.IKey(item).key()
optLabel = iforms.ILabel(item).label()
optValue = converter.fromType(optValue)
option = T.option(value=optValue)[optLabel]
if value and optValue in value:
option = option(selected='selected')
yield option
tag=T.select(name=key, id=keytocssid(ctx.key), data=self.options, multiple="multiple")[renderOptions]
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
| Python |
"""Adapters for converting to and from a type's value according to an
IConvertible protocol.
"""
from datetime import date, time
try:
import decimal
haveDecimal = True
except ImportError:
haveDecimal = False
from forms import iforms, validation
from zope.interface import implements
class _Adapter(object):
def __init__(self, original):
self.original = original
class NullConverter(_Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value
def toType(self, value):
if value is None:
return None
return value
class NumberToStringConverter(_Adapter):
implements( iforms.IStringConvertible )
cast = None
def fromType(self, value):
if value is None:
return None
return str(value)
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
# "Cast" the value to the correct type. For some strange reason,
# Python's decimal.Decimal type raises an ArithmeticError when it's
# given a dodgy value.
try:
value = self.cast(value)
except (ValueError, ArithmeticError):
raise validation.FieldValidationError("Not a valid number")
return value
class IntegerToStringConverter(NumberToStringConverter):
cast = int
class FloatToStringConverter(NumberToStringConverter):
cast = float
if haveDecimal:
class DecimalToStringConverter(NumberToStringConverter):
cast = decimal.Decimal
class BooleanToStringConverter(_Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
if value:
return 'True'
return 'False'
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
if value not in ('True', 'False'):
raise validation.FieldValidationError('%r should be either True or False')
return value == 'True'
class DateToStringConverter(_Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value.isoformat()
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
return self.parseDate(value)
def parseDate(self, value):
try:
y, m, d = [int(p) for p in value.split('-')]
except ValueError:
raise validation.FieldValidationError('Invalid date')
try:
value = date(y, m, d)
except ValueError, e:
raise validation.FieldValidationError('Invalid date: '+str(e))
return value
class TimeToStringConverter(_Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value.isoformat()
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
return self.parseTime(value)
def parseTime(self, value):
if '.' in value:
value, ms = value.split('.')
else:
ms = 0
try:
parts = value.split(':')
if len(parts)<2 or len(parts)>3:
raise ValueError()
if len(parts) == 2:
h, m = parts
s = 0
else:
h, m, s = parts
h, m, s, ms = int(h), int(m), int(s), int(ms)
except:
raise validation.FieldValidationError('Invalid time')
try:
value = time(h, m, s, ms)
except ValueError, e:
raise validation.FieldValidationError('Invalid time: '+str(e))
return value
class DateToDateTupleConverter(_Adapter):
implements( iforms.IDateTupleConvertible )
def fromType(self, value):
if value is None:
return None, None, None
return value.year, value.month, value.day
def toType(self, value):
if value is None:
return None
try:
value = date(*value)
except (TypeError, ValueError), e:
raise validation.FieldValidationError('Invalid date: '+str(e))
return value
| Python |
import re
from zope.interface import implements
from nevow import inevow
from forms import iforms
_IDENTIFIER_REGEX = re.compile('^[a-zA-Z_][a-zA-Z0-9_]*$')
def titleFromName(name):
def _():
it = iter(name)
last = None
while 1:
ch = it.next()
if ch == '_':
if last != '_':
yield ' '
elif last in (None,'_'):
yield ch.upper()
elif ch.isupper() and not last.isupper():
yield ' '
yield ch.upper()
else:
yield ch
last = ch
return ''.join(_())
def keytocssid(key):
return '-'.join(key.split('.'))
def validIdentifier(name):
"""
Test that name is a valid Python identifier.
"""
return _IDENTIFIER_REGEX.match(name) is not None
class SequenceKeyLabelAdapter(object):
implements( iforms.IKey, iforms.ILabel )
def __init__(self, original):
self.original = original
def key(self):
return self.original[0]
def label(self):
return self.original[1]
class LazyResource(object):
implements(inevow.IResource)
def __init__(self, factory):
self.factory = factory
self._resource = None
def locateChild(self, ctx, segments):
return self.resource().locateChild(ctx, segments)
def renderHTTP(self, ctx):
return self.resource().renderHTTP(ctx)
def resource(self):
if self._resource is None:
self._resource = self.factory()
return self._resource
| Python |
"""
Widgets are small components that render form fields for inputing data in a
certain format.
"""
import itertools
from nevow import inevow, loaders, tags as T, util, url, static, rend
from nevow.i18n import _
from forms import converters, iforms, validation
from forms.util import keytocssid
from forms.form import widgetResourceURL, widgetResourceURLFromContext
from zope.interface import implements
from twisted.internet import defer
# Marker object for args that are not supplied
_UNSET = object()
class TextInput(object):
"""
A text input field.
<input type="text" ... />
"""
implements( iforms.IWidget )
inputType = 'text'
showValueOnFailure = True
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, readonly):
tag=T.input(type=self.inputType, name=key, id=keytocssid(ctx.key), value=value)
if readonly:
tag(class_='readonly', readonly='readonly')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
if not self.showValueOnFailure:
value = None
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class Checkbox(object):
"""
A checkbox input field.
<input type="checkbox" ... />
"""
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, disabled):
tag = T.input(type='checkbox', name=key, id=keytocssid(ctx.key), value='True')
if value == 'True':
tag(checked='checked')
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IBooleanConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IBooleanConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [None])[0]
if not value:
value = 'False'
value = iforms.IBooleanConvertible(self.original).toType(value)
return self.original.validate(value)
class Password(TextInput):
"""
A text input field that hides the text.
<input type="password" ... />
"""
inputType = 'password'
showValueOnFailure = False
class TextArea(object):
"""
A large text entry area that accepts newline characters.
<textarea>...</textarea>
"""
implements( iforms.IWidget )
cols = 48
rows = 6
def __init__(self, original, cols=None, rows=None):
self.original = original
if cols is not None:
self.cols = cols
if rows is not None:
self.rows = rows
def _renderTag(self, ctx, key, value, readonly):
tag=T.textarea(name=key, id=keytocssid(ctx.key), cols=self.cols, rows=self.rows)[value or '']
if readonly:
tag(class_='readonly', readonly='readonly')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).fromType(value)
return self.original.validate(value)
class CheckedPassword(object):
"""
Two password entry fields that must contain the same value to validate.
"""
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors and not errors.getFieldError(key):
values = args.get(key)
else:
values = ('', '')
return [
T.input(type='password', name=key, id=keytocssid(ctx.key), value=values[0]),
T.br,
T.label(for_='%s__confirm'%keytocssid(ctx.key))[' Confirm '],
T.input(type='password', name=key, id='%s__confirm'%keytocssid(ctx.key), value=values[1]),
]
def renderImmutable(self, ctx, key, args, errors):
values = ('', '')
return [
T.input(type='password', name=key, id=keytocssid(ctx.key), value=values[0], class_='readonly', readonly='readonly'),
T.br,
T.label(for_='%s__confirm'%keytocssid(ctx.key))[' Confirm '],
T.input(type='password', name=key, id='%s__confirm'%keytocssid(ctx.key), value=values[1], class_='readonly', readonly='readonly')
]
def processInput(self, ctx, key, args):
pwds = [pwd for pwd in args.get(key, [])]
if len(pwds) == 0:
pwd = ''
elif len(pwds) == 1:
raise validation.FieldValidationError('Please enter the password twice for confirmation.')
else:
if pwds[0] != pwds[1]:
raise validation.FieldValidationError('Passwords do not match.')
return self.original.validate(pwds[0])
class ChoiceBase(object):
"""
A base class for widgets that provide the UI to select one or more items
from a list.
options:
A sequence of objects adaptable to IKey and ILabel. IKey is used as the
<option>'s value attribute; ILabel is used as the <option>'s child.
IKey and ILabel adapters for tuple are provided.
noneOption:
An object adaptable to IKey and ILabel that is used to identify when
nothing has been selected. Defaults to ('', '')
"""
options = None
noneOption = None
def __init__(self, original, options=None, noneOption=_UNSET):
self.original = original
if options is not None:
self.options = options
if noneOption is not _UNSET:
self.noneOption = noneOption
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0]
value = iforms.IStringConvertible(self.original).toType(value)
if self.noneOption is not None and value == self.noneOption[0]:
value = None
return self.original.validate(value)
class SelectChoice(ChoiceBase):
"""
A drop-down list of options.
<select>
<option value="...">...</option>
</select>
"""
implements( iforms.IWidget )
noneOption = ('', '')
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOptions(ctx, data):
if self.noneOption is not None:
yield T.option(value=iforms.IKey(self.noneOption).key())[iforms.ILabel(self.noneOption).label()]
if data is None:
return
for item in data:
optValue = iforms.IKey(item).key()
optLabel = iforms.ILabel(item).label()
optValue = converter.fromType(optValue)
option = T.option(value=optValue)[optLabel]
if optValue == value:
option = option(selected='selected')
yield option
tag=T.select(name=key, id=keytocssid(ctx.key), data=self.options)[renderOptions]
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])[0]
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
class SelectOtherChoice(object):
"""
A <select> widget that includes an "Other ..." option. When the other
option is selected an <input> field is enabled to allow free text entry.
Unlike SelectChoice, the options items are not a (value,label) tuple
because that makes no sense with the free text entry facility.
TODO:
* Make the Other option configurable in the JS
* Refactor, refactor, refactor
"""
implements(iforms.IWidget)
options = None
noneOption = ('', '')
otherOption = ('...', 'Other ...')
template = None
def __init__(self, original, options=None):
self.original = original
if options is not None:
self.options = options
if self.template is None:
self.template = loaders.xmlfile(util.resource_filename('forms',
'html/SelectOtherChoice.html'))
def _valueFromRequestArgs(self, key, args):
value = args.get(key, [''])[0]
if value == self.otherOption[0]:
value = args.get(key+'-other', [''])[0]
return value
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = self._valueFromRequestArgs(key, args)
else:
value = converter.fromType(args.get(key))
if value is None:
value = iforms.IKey(self.noneOption).key()
optionGen = inevow.IQ(self.template).patternGenerator('option')
selectedOptionGen = inevow.IQ(self.template).patternGenerator('selectedOption')
optionTags = []
selectOther = True
if self.noneOption is not None:
noneValue = iforms.IKey(self.noneOption).key()
if value == noneValue:
tag = selectedOptionGen()
selectOther = False
else:
tag = optionGen()
tag.fillSlots('value', noneValue)
tag.fillSlots('label', iforms.ILabel(self.noneOption).label())
optionTags.append(tag)
if self.options is not None:
for item in self.options:
if value == item:
tag = selectedOptionGen()
selectOther = False
else:
tag = optionGen()
tag.fillSlots('value', item)
tag.fillSlots('label', item)
optionTags.append(tag)
if selectOther:
tag = selectedOptionGen()
otherValue = value
else:
tag = optionGen()
otherValue = ''
tag.fillSlots('value', self.otherOption[0])
tag.fillSlots('label', self.otherOption[1])
optionTags.append(tag)
tag = T.invisible[self.template.load(ctx)]
tag.fillSlots('key', key)
tag.fillSlots('id', keytocssid(ctx.key))
tag.fillSlots('options', optionTags)
tag.fillSlots('otherValue', otherValue)
return tag
def renderImmutable(self, ctx, key, args, errors):
raise NotImplemented
def processInput(self, ctx, key, args):
value = self._valueFromRequestArgs(key, args)
value = iforms.IStringConvertible(self.original).toType(value)
if self.noneOption is not None and value == self.noneOption[0]:
value = None
return self.original.validate(value)
class RadioChoice(ChoiceBase):
"""
A list of options in the form of radio buttons.
<input type="radio" ... value="..."/><label>...</label><br />
<input type="radio" ... value="..."/><label>...</label><br />
"""
implements( iforms.IWidget )
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOption(ctx, itemKey, itemLabel, num, selected):
cssid = (keytocssid(ctx.key),'-',num)
tag = T.input(name=key, type='radio', id=cssid, value=itemKey)
if selected:
tag = tag(checked='checked')
return tag, ' ', T.label(for_=cssid)[itemLabel], T.br
def renderOptions(ctx, data):
# A counter to assign unique ids to each input
idCounter = itertools.count()
if self.noneOption is not None:
itemKey = iforms.IKey(self.noneOption).key()
itemLabel = iforms.ILabel(self.noneOption).label()
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(), itemKey==value)
if not data:
return
for item in data:
itemKey = iforms.IKey(item).key()
itemLabel = iforms.ILabel(item).label()
itemKey = converter.fromType(itemKey)
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(), itemKey==value)
return T.invisible(data=self.options)[renderOptions]
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])[0]
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
class DatePartsInput(object):
"""
A date entry widget that uses three <input> elements for the day, month and
year parts.
The default entry format is the US (month, day, year) but can be switched to
the more common (day, month, year) by setting the dayFirst attribute to
True.
By default the widget is designed to only accept unambiguous years, i.e.
the user must enter 4 character dates.
Many people find it convenient or even necessary to allow a 2 character
year. This can be allowed by setting the twoCharCutoffYear attribute to an
integer value between 0 and 99. Anything greater than or equal to the cutoff
year will be considered part of the 20th century (1900 + year); anything
less the cutoff year is a 21st century (2000 + year) date.
A typical twoCharCutoffYear value is 70 (i.e. 1970). However, that value is
somewhat arbitrary. It's the year that time began according to the PC, but
it doesn't mean much to your non-techie user.
dayFirst:
Make the day the first input field, i.e. day, month, year
twoCharCutoffYear:
Allow 2 char years and set the year where the century flips between
20th and 21st century.
"""
implements( iforms.IWidget )
dayFirst = False
twoCharCutoffYear = None
def __init__(self, original, dayFirst=None, twoCharCutoffYear=None):
self.original = original
if dayFirst is not None:
self.dayFirst = dayFirst
if twoCharCutoffYear is not None:
self.twoCharCutoffYear = twoCharCutoffYear
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, year, month, day, namer, readonly):
yearTag = T.input(type="text", name=namer('year'), value=year, size=4)
monthTag = T.input(type="text", name=namer('month'), value=month, size=2)
dayTag = T.input(type="text", name=namer('day'), value=day, size=2)
if readonly:
tags = (yearTag, monthTag, dayTag)
for tag in tags:
tag(class_='readonly', readonly='readonly')
if self.dayFirst:
return dayTag, ' / ', monthTag, ' / ', yearTag, ' ', _('(day/month/year)')
else:
return monthTag, ' / ', dayTag, ' / ', yearTag, ' ', _('(month/day/year)')
def render(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
if errors:
year = args.get(namer('year'), [''])[0]
month = args.get(namer('month'), [''])[0]
day = args.get(namer('day'), [''])[0]
else:
year, month, day = converter.fromType(args.get(key))
return self._renderTag(ctx, year, month, day, namer, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
year, month, day = converter.fromType(args.get(key))
return self._renderTag(ctx, year, month, day, namer, True)
def processInput(self, ctx, key, args):
namer = self._namer(key)
# Get the form field values as a (y,m,d) tuple
ymd = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month', 'day')]
# Remove parts that were not entered.
ymd = [p for p in ymd if p]
# Nothing entered means None otherwise we need all three.
if not ymd:
ymd = None
elif len(ymd) != 3:
raise validation.FieldValidationError("Invalid date")
# So, we have what looks like a good attempt to enter a date.
if ymd is not None:
# If a 2-char year is allowed then prepend the century.
if self.twoCharCutoffYear is not None and len(ymd[0]) == 2:
try:
if int(ymd[0]) >= self.twoCharCutoffYear:
century = '19'
else:
century = '20'
ymd[0] = century + ymd[0]
except ValueError:
pass
# By now, we should have a year of at least 4 characters.
if len(ymd[0]) < 4:
if self.twoCharCutoffYear is not None:
msg = "Please enter a 2 or 4 digit year"
else:
msg = "Please enter a 4 digit year"
raise validation.FieldValidationError(msg)
# Map to integers
try:
ymd = [int(p) for p in ymd]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
ymd = iforms.IDateTupleConvertible(self.original).toType(ymd)
return self.original.validate(ymd)
class MMYYDatePartsInput(object):
"""
Two input fields for entering the month and year.
"""
implements( iforms.IWidget )
cutoffYear = 70
def __init__(self, original, cutoffYear=None):
self.original = original
if cutoffYear is not None:
self.cutoffYear = cutoffYear
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, year, month, namer, readonly):
yearTag = T.input(type="text", name=namer('year'), value=year, size=2)
monthTag = T.input(type="text", name=namer('month'), value=month, size=2)
if readonly:
tags=(yearTag, monthTag)
for tag in tags:
tag(class_='readonly', readonly='readonly')
return monthTag, ' / ', yearTag, ' (mm/yy)'
def render(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
if errors:
year = args.get(namer('year'), [''])[0]
month = args.get(namer('month'), [''])[0]
# return a blank for the day
day = ''
else:
year, month, day = converter.fromType(args.get(key))
# if we have a year as default data, stringify it and only use last two digits
if year is not None:
year = str(year)[2:]
return self._renderTag(ctx, year, month, namer, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
year, month, day = converter.fromType(args.get(key))
namer = self._namer(key)
# if we have a year as default data, stringify it and only use last two digits
if year is not None:
year = str(year)[2:]
return self._renderTag(ctx, year, month, namer, True)
def processInput(self, ctx, key, args):
namer = self._namer(key)
value = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month')]
value = [p for p in value if p]
if not value:
value = None
elif len(value) != 2:
raise validation.FieldValidationError("Invalid date")
if value is not None:
try:
value = [int(p) for p in value]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
if value[1] < 0 or value[1] > 99:
raise validation.FieldValidationError("Invalid year. Please enter a two-digit year.")
if value[0] > self.cutoffYear:
value[0] = 1900 + value[0]
else:
value[0] = 2000 + value[0]
value.append(1)
value = iforms.IDateTupleConvertible(self.original).toType( value )
return self.original.validate(value)
class CheckboxMultiChoice(object):
"""
Multiple choice list, rendered as a list of checkbox fields.
"""
implements( iforms.IWidget )
options = None
def __init__(self, original, options=None):
self.original = original
if options is not None:
self.options = options
def _renderTag(self, ctx, key, values, converter, disabled):
def renderer(ctx, options):
# loops through checkbox options and renders
for n,item in enumerate(options):
optValue = iforms.IKey(item).key()
optLabel = iforms.ILabel(item).label()
optValue = converter.fromType(optValue)
optid = (keytocssid(ctx.key),'-',n)
checkbox = T.input(type='checkbox', name=key, value=optValue, id=optid )
if optValue in values:
checkbox = checkbox(checked='checked')
if disabled:
checkbox = checkbox(class_='disabled', disabled='disabled')
yield checkbox, T.label(for_=optid)[optLabel], T.br()
# Let Nevow worry if self.options is not already a list.
return T.invisible(data=self.options)[renderer]
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original.type)
if errors:
values = args.get(key, [])
else:
values = args.get(key)
if values is not None:
values = [converter.fromType(v) for v in values]
else:
values = []
return self._renderTag(ctx, key, values, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original.type)
values = args.get(key)
if values is not None:
values = [converter.fromType(v) for v in values]
else:
values = []
return self._renderTag(ctx, key, values, converter, True)
def processInput(self, ctx, key, args):
values = args.get(key, [])
converter = iforms.IStringConvertible(self.original.type)
values = [converter.toType(v) for v in values]
return self.original.validate(values)
class FileUploadRaw(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, disabled):
tag=T.input(name=key, id=keytocssid(ctx.key),type='file')
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IFileConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IFileConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, True)
def processInput(self, ctx, key, args):
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
value = (name, fileitem.file)
value = iforms.IFileConvertible(self.original).fromType(value)
return self.original.validate(value)
class FileUpload(object):
implements( iforms.IWidget )
def __init__(self, original, fileHandler, preview=None):
self.original = original
self.fileHandler = fileHandler
self.preview = preview
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, key, value, namer, disabled):
name = self.fileHandler.getUrlForFile(value)
if name:
if self.preview == 'image':
yield T.p[value,T.img(src=self.fileHandler.getUrlForFile(value))]
else:
yield T.p[value]
else:
yield T.p[T.strong['nothing uploaded']]
yield T.input(name=namer('value'),value=value,type='hidden')
tag=T.input(name=key, id=keytocssid(ctx.key),type='file')
if disabled:
tag(class_='disabled', disabled='disabled')
yield tag
def render(self, ctx, key, args, errors):
namer = self._namer(key)
if errors:
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
value = name
else:
namer = self._namer(key)
value = args.get(namer('value'))[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, namer, False)
def renderImmutable(self, ctx, key, args, errors):
namer = self._namer(key)
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, namer, True)
def processInput(self, ctx, key, args):
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
value = self.fileHandler.storeFile( fileitem.file, name )
else:
namer = self._namer(key)
value = args.get(namer('value'))[0]
value = iforms.IStringConvertible(self.original).fromType(value)
return self.original.validate(value)
class FileUploadWidget(object):
"""
File upload widget that carries the uploaded file around until the form
validates.
The widget uses the resource manager to save the file to temporary storage
until the form validates. This makes file uploads behave like most of the
other widgets, i.e. the value is kept when a form is redisplayed due to
validation errors.
"""
implements( iforms.IWidget )
FROM_RESOURCE_MANAGER = 'rm'
FROM_CONVERTIBLE = 'cf'
convertibleFactory = converters.NullConverter
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def __init__( self, original, convertibleFactory=None, originalKeyIsURL=False ):
self.original = original
if convertibleFactory is not None:
self.convertibleFactory = convertibleFactory
self.originalKeyIsURL = originalKeyIsURL
def _blankField( self, field ):
"""
Convert empty strings into None.
"""
if field and field == '':
return None
return field
def _getFromArgs( self, args, name ):
"""
Get the first value of 'name' from 'args', or None.
"""
rv = args.get( name )
if rv:
rv = rv[0]
return rv
def render(self, ctx, key, args, errors):
"""
Render the data.
This either renders a link to the original file, if specified, and
no new file has been uploaded. Or a link to the uploaded file.
The request to get the data should be routed to the getResouce
method.
"""
form = iforms.IForm( ctx )
namer = self._namer( key )
resourceIdName = namer( 'resource_id' )
originalIdName = namer( 'original_id' )
# get the resource id first from the resource manager
# then try the request
resourceId = form.resourceManager.getResourceId( key )
if resourceId is None:
resourceId = self._getFromArgs( args, resourceIdName )
resourceId = self._blankField( resourceId )
# Get the original key from a hidden field in the request,
# then try the request file.data initial data.
originalKey = self._getFromArgs( args, originalIdName )
if not errors and not originalKey:
originalKey = args.get( key )
originalKey = self._blankField( originalKey )
if resourceId:
# Have an uploaded file, so render a URL to the uploaded file
tmpURL = widgetResourceURL(form.name).child(key).child( self.FROM_RESOURCE_MANAGER ).child(resourceId)
yield T.p[T.img(src=tmpURL)]
elif originalKey:
# The is no uploaded file, but there is an original, so render a
# URL to it
if self.originalKeyIsURL:
tmpURL = originalKey
else:
tmpURL = widgetResourceURL(form.name).child(key).child( self.FROM_CONVERTIBLE ).child( originalKey )
yield T.p[T.img(src=tmpURL)]
else:
# No uploaded file, no original
yield T.p[T.strong['Nothing uploaded']]
yield T.input(name=key, id=keytocssid(ctx.key),type='file')
# Id of uploaded file in the resource manager
yield T.input(name=resourceIdName,value=resourceId,type='hidden')
if originalKey:
# key of the original that can be used to get a file later
yield T.input(name=originalIdName,value=originalKey,type='hidden')
def renderImmutable(self, ctx, key, args, errors):
form = iforms.IForm(ctx)
namer = self._namer(key)
originalIdName = namer('original_id')
# Get the original key from a hidden field in the request,
# then try the request form.data initial data.
originalKey = self._getFromArgs( args, originalIdName )
if not errors and not originalKey:
originalKey = args.get( key )
originalKey = self._blankField( originalKey )
if originalKey:
# The is no uploaded file, but there is an original, so render a
# URL to it
if self.originalKeyIsURL:
tmpURL = originalKey
else:
tmpURL = widgetResourceURL(form.name).child(key).child(self.FROM_CONVERTIBLE).child(originalKey)
yield T.p[T.img(src=tmpURL)]
else:
# No uploaded file, no original
yield T.p[T.strong['Nothing uploaded']]
if originalKey:
# key of the original that can be used to get a file later
yield T.input(name=originalIdName,value=originalKey,type='hidden')
def processInput(self, ctx, key, args):
"""
Process the request, storing any uploaded file in the
resource manager.
"""
resourceManager = iforms.IForm( ctx ).resourceManager
# Ping the resource manager with any resource ids that I know
self._registerWithResourceManager( key, args, resourceManager )
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
# Store the uploaded file in the resource manager
resourceManager.setResource( key, fileitem.file, name )
# Validating against an uploaded file. Should the fact that there is
# original file meet a required field validation?
value = resourceManager.getResourceForWidget( key )
value = self.convertibleFactory(self.original).toType( value )
return self.original.validate( value )
def _registerWithResourceManager( self, key, args, resourceManager ):
"""
If there is a resource id in the request, then let the
resource manager know about it.
"""
namer = self._namer( key )
resourceIdName = namer( 'resource_id' )
resourceId = self._getFromArgs( args, resourceIdName )
resourceId = self._blankField( resourceId )
if resourceId:
resourceManager.register( key, resourceId )
def getResource( self, ctx, key, segments ):
"""
Return an Resource that contains the image, either a file
from the resource manager, or a data object from the convertible.
"""
if segments[0] == self.FROM_RESOURCE_MANAGER:
# Resource manager can provide a path so return a static.File
# instance that points to the file
rm = iforms.IForm( ctx ).resourceManager
(mimetype, path, fileName) = rm.getResourcePath( segments[1] )
return static.File( path, mimetype ), []
elif segments[0] == self.FROM_CONVERTIBLE:
# The convertible can provide a file like object so create a
# static.Data instance with the data from the convertible.
def _( result ):
mimetype, filelike, fileName = result
data = filelike.read()
filelike.close()
return static.Data( data, mimetype ), []
d = defer.maybeDeferred( self.convertibleFactory(self.original).fromType, segments[1], context=ctx )
d.addCallback( _ )
return d
else:
return None
class Hidden(object):
"""
A hidden form field.
"""
__implements__ = iforms.IWidget,
inputType = 'hidden'
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])
if isinstance(value, list):
value = value[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return T.input(type=self.inputType, name=key, id=keytocssid(ctx.key), value=value)
def renderImmutable(self, ctx, key, args, errors):
return self.render(ctx, key, args, errors)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
__all__ = [
'Checkbox', 'CheckboxMultiChoice', 'CheckedPassword', 'FileUploadRaw',
'Password', 'SelectChoice', 'TextArea', 'TextInput', 'DatePartsInput',
'MMYYDatePartsInput', 'Hidden', 'RadioChoice', 'SelectOtherChoice',
'FileUpload', 'FileUploadWidget',
]
| Python |
import re
from zope.interface import implements
from forms import iforms
class FormsError(Exception):
"""
Base class for all Forms errors. A single string, message, is accepted and
stored as an attribute.
The message is not passed on to the Exception base class because it doesn't
seem to be able to handle unicode at all.
"""
def __init__(self, message):
Exception.__init__(self, message)
self.message = message
class FormError(FormsError):
"""
Form validation error. Raise this, typically from a submit callback, to
signal that the form (not an individual field) failed to validate.
"""
pass
class FieldError(FormsError):
"""
Base class for field-related exceptions. The failure message and the failing
field name are stored as attributes.
"""
def __init__(self, message, fieldName=None):
FormsError.__init__(self, message)
self.fieldName = fieldName
class FieldValidationError(FieldError):
"""
Exception that signals that a field failed to validate.
"""
pass
class FieldRequiredError(FieldValidationError):
"""
Exception that signals that a field that is marked as required was not
entered.
"""
pass
class RequiredValidator(object):
implements(iforms.IValidator)
def validate(self, field, value):
if value is None:
raise FieldRequiredError, 'Required'
class LengthValidator(object):
"""Validate the length of the value is within a given range.
"""
implements(iforms.IValidator)
def __init__(self, min=None, max=None):
self.min = min
self.max = max
assert self.min is not None or self.max is not None
def validationErrorMessage(self, field):
if self.min is not None and self.max is None:
return 'Must be longer than %r characters'%(self.min,)
if self.min is None and self.max is not None:
return 'Must be shorter than %r characters'%(self.max,)
return 'Must be between %r and %r characters'%(self.min, self.max)
def validate(self, field, value):
if value is None:
return
length = len(value)
if self.min is not None and length < self.min:
raise FieldValidationError, self.validationErrorMessage(field)
if self.max is not None and length > self.max:
raise FieldValidationError, self.validationErrorMessage(field)
class RangeValidator(object):
"""Validate the size of the value is within is given range.
"""
implements(iforms.IValidator)
def __init__(self, min=None, max=None):
self.min = min
self.max = max
assert self.min is not None or self.max is not None
def validationErrorMessage(self, field):
if self.min is not None and self.max is None:
return 'Must be greater than %r'%(self.min,)
if self.min is None and self.max is not None:
return 'Must be less than %r'%(self.max,)
return 'Must be between %r and %r'%(self.min, self.max)
def validate(self, field, value):
if value is None:
return
if self.min is not None and value < self.min:
raise FieldValidationError, self.validationErrorMessage(field)
if self.max is not None and value > self.max:
raise FieldValidationError, self.validationErrorMessage(field)
class PatternValidator(object):
"""Validate the value is a certain pattern.
The required pattern is defined as a regular expression. The regex will be
compiled automatically if necessary.
"""
implements(iforms.IValidator)
def __init__(self, regex):
self.regex = regex
def validate(self, field, value):
if value is None:
return
# If it doesn't look like a regex object then compile it now
if not hasattr(self.regex, 'match'):
self.regex = re.compile(self.regex)
if self.regex.match(value) is None:
raise FieldValidationError, 'Invalid format'
__all__ = [
'FormError', 'FieldError', 'FieldValidationError', 'FieldRequiredError',
'RequiredValidator', 'LengthValidator', 'RangeValidator', 'PatternValidator',
]
| Python |
from nevow import url
import forms
from forms.examples import main
class ActionButtonsPage(main.FormExamplePage):
title = 'Action Button'
description = 'Example of non-validating button, buttons with non-default labels, etc'
def form_example(self, ctx):
form = forms.Form()
form.addField('aString', forms.String(required=True))
form.addAction(self.submitted, label="Click, click, clickety-click!")
form.addAction(self.redirect, 'back', validate=False)
return form
def submitted(self, ctx, form, data):
print form, data
def redirect(self, ctx, form, data):
return url.rootaccessor(ctx)
| Python |
import forms
from forms.examples import main
# Let the examples run if docutils is not installed
try:
import docutils
except ImportError:
import warnings
warnings.warn("docutils is not installed")
docutilsAvailable = False
else:
docutilsAvailable = True
if docutilsAvailable:
from docutils.writers.html4css1 import Writer, HTMLTranslator
from docutils import nodes
class CustomisedHTMLTranslator(HTMLTranslator):
def visit_newdirective_node(self, node):
self.body.append('<div>Some HTML with a %s parameter</div>\n'%(node.attributes['parameter'],))
def depart_newdirective_node(self, node):
pass
class newdirective_node(nodes.General, nodes.Inline, nodes.TextElement):
pass
def newdirective(name, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
return [newdirective_node('', parameter=arguments[0])]
newdirective.arguments = (1, 0, 0)
newdirective.options = None
from docutils.parsers.rst import directives
directives.register_directive('newdirective', newdirective)
class ReSTWidgetFormPage(main.FormExamplePage):
title = 'ReST widget'
description = 'The ReST widget captures ReST and previews as HTML.'
def form_example(self, ctx):
form = forms.Form()
form.addField('restString', forms.String(required=True),
widgetFactory=forms.ReSTTextArea)
if docutilsAvailable:
w = Writer()
w.translator_class = CustomisedHTMLTranslator
form.addField('customRestString', forms.String(required=True),
forms.widgetFactory(forms.ReSTTextArea, restWriter=w))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
from zope.interface import implements
import forms
from forms import iforms
from forms.examples import main
# A not-too-good regex for matching an IP address.
IP_ADDRESS_PATTERN = '^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$'
class ValidatorFormPage(main.FormExamplePage):
title = 'Custom form validation'
description = 'Example of installing additional validators and writing a new one'
def form_example(self, ctx):
form = forms.Form()
# This actually installs a RequiredValidator for you.
form.addField('required', forms.String(required=True))
# Exactly the same as above, only with a "manually" installed validator.
form.addField('required2', forms.String(validators=[forms.RequiredValidator()]))
# Check for a minimum length, if anything entered.
form.addField('atLeastFiveChars', forms.String(validators=[forms.LengthValidator(min=5)]))
# Check for a minimum length, if anything entered.
form.addField('ipAddress', forms.String(strip=True, validators=[forms.PatternValidator(regex=IP_ADDRESS_PATTERN)]))
# Check for the word 'silly'
form.addField('silly', forms.String(validators=[SillyValidator()]))
# Check age is between 18 and 30
form.addField('ohToBeYoungAgain', forms.Integer(validators=[forms.RangeValidator(min=18, max=30)]))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
class SillyValidator(object):
"""
A pointless example that checks a specific word, 'silly', is entered.
"""
implements(iforms.IValidator)
word = u'silly'
def validate(self, field, value):
if value is None:
return
if value.lower() != self.word.lower():
raise forms.FieldValidationError(u'You must enter \'%s\''%self.word)
| Python |
import forms
from forms.examples import main
class SimpleFormPage(main.FormExamplePage):
title = 'Simple Form'
description = 'Probably the simplest form possible.'
def form_example(self, ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
try:
import decimal
haveDecimal = True
except ImportError:
haveDecimal = False
import forms
from forms.examples import main
class TypesFormPage(main.FormExamplePage):
title = 'Form Types'
description = 'Example of using different typed fields.'
def form_example(self, ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aInteger', forms.Integer())
form.addField('aFloat', forms.Float())
if haveDecimal:
form.addField('aDecimal', forms.Decimal())
form.addField('aBoolean', forms.Boolean())
form.addField('aDate', forms.Date())
form.addField('aTime', forms.Time())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print data
| Python |
from datetime import date
import forms
from forms.examples import main
class MissingFormPage(main.FormExamplePage):
title = 'Missing Values'
description = 'Providing default values when missing'
def form_example(self, ctx):
form = forms.Form()
form.addField('aString', forms.String(missing='<nothing>'))
form.addField('aDate', forms.Date(missing=date(2005, 8, 1)))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print data
| Python |
import forms
from forms.examples import main
class FileUploadFormPage(main.FormExamplePage):
title = 'File Upload'
description = 'Uploading a file'
def form_example(self, ctx):
form = forms.Form()
form.addField('file', forms.File())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
import pkg_resources
from zope.interface import implements
from twisted.python import reflect
from nevow import appserver, inevow, loaders, rend, static, tags as T, url
import forms
DOCTYPE = T.xml('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">')
CHARSET = T.xml('<meta http-equiv="content-type" content="text/html; charset=utf-8" />')
examples = [
'forms.examples.simple.SimpleFormPage',
'forms.examples.types.TypesFormPage',
'forms.examples.required.RequiredFormPage',
'forms.examples.missing.MissingFormPage',
'forms.examples.prepopulate.PrepopulateFormPage',
'forms.examples.fileupload.FileUploadFormPage',
'forms.examples.smartupload.SmartUploadFormPage',
'forms.examples.selections.SelectionFormPage',
'forms.examples.datestimes.DatesTimesFormPage',
'forms.examples.actionbuttons.ActionButtonsPage',
'forms.examples.validator.ValidatorFormPage',
'forms.examples.restwidget.ReSTWidgetFormPage',
'forms.examples.nofields.NoFieldsFormPage',
]
def makeSite(application):
root = RootPage()
site = appserver.NevowSite(root, logPath='web.log')
return site
class RootPage(rend.Page):
"""
Main page that lists the examples and makes the example page a child
resource.
"""
docFactory = loaders.stan(
T.invisible[
DOCTYPE,
T.html[
T.head[
CHARSET,
T.title['Forms Examples'],
T.link(rel='stylesheet', type='text/css', href=url.root.child('examples.css')),
],
T.body[
T.directive('examples'),
],
],
],
)
def render_examples(self, ctx, data):
for name in examples:
cls = reflect.namedAny(name)
yield T.div(class_='example')[
T.h1[T.a(href=url.here.child(name))[cls.title]],
T.p[cls.description],
]
def childFactory(self, ctx, name):
if name in examples:
cls = reflect.namedAny(name)
return cls()
class FormExamplePage(forms.ResourceMixin, rend.Page):
"""
A base page for the actual examples. The page renders something sensible,
including the title example and description. It also include the "example"
form in an appropriate place.
Each example page is expected to provide the title and description
attributes as well as a form_example method that builds and returns a
forms.Form instance.
"""
docFactory = loaders.stan(
T.invisible[
DOCTYPE,
T.html[
T.head[
CHARSET,
T.title(data=T.directive('title'), render=rend.data),
T.link(rel='stylesheet', type='text/css', href=url.root.child('examples.css')),
T.link(rel='stylesheet', type='text/css', href=url.root.child('forms.css')),
T.script(type='text/javascript', src='js/forms.js'),
],
T.body[
T.h1(data=T.directive('title'), render=rend.data),
T.p(data=T.directive('description'), render=rend.data),
T.directive('form example'),
],
],
],
)
def data_title(self, ctx, data):
return self.title
def data_description(self, ctx, data):
return self.description
# Add child_ attributes
examples_css = pkg_resources.resource_filename('forms.examples', 'examples.css')
setattr(RootPage, 'child_examples.css', static.File(examples_css))
setattr(RootPage, 'child_forms.css', forms.defaultCSS)
setattr(RootPage, 'child_js', forms.formsJS)
| Python |
import forms
from forms.examples import main
class SmartUploadFormPage(main.FormExamplePage):
title = 'Smart File Upload'
description = 'Smart uploading of files where the file is "carried across" when the validation fails'
def form_example(self, ctx):
form = forms.Form()
form.addField('required', forms.String(required=True))
form.addField('file', forms.File(), forms.FileUploadWidget)
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
from datetime import datetime
import forms
from forms.examples import main
class PrepopulateFormPage(main.FormExamplePage):
title = 'Prepopulate'
description = 'Example of prepopulating form fields'
def form_example(self, ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aTime', forms.Time())
form.addAction(self.submitted)
form.data = {
'aTime': datetime.utcnow().time(),
}
return form
def submitted(self, ctx, form, data):
print data
| Python |
import forms
from forms.examples import main
class DatesTimesFormPage(main.FormExamplePage):
title = 'Dates'
description = 'Date entry examples'
def form_example(self, ctx):
form = forms.Form()
form.addField('isoFormatDate', forms.Date(), forms.TextInput)
form.addField('monthFirstDate', forms.Date(), forms.DatePartsInput)
form.addField('dayFirstDate', forms.Date(), forms.widgetFactory(forms.DatePartsInput, dayFirst=True))
form.addField('monthYearDate', forms.Date(), forms.MMYYDatePartsInput)
form.addField('twoCharYearDate', forms.Date(), forms.widgetFactory(forms.DatePartsInput, twoCharCutoffYear=70))
form.addField('time', forms.Time())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
from twisted.internet import defer
from datetime import date
import forms
from forms.examples import main
# A boring list of (value, label) pairs.
strings = [
('foo', 'Foo'),
('bar', 'Bar'),
]
# A list of dates with meaningful names.
dates = [
(date(2005, 01, 01), 'New Year Day'),
(date(2005, 11, 06), 'My Birthday'),
(date(2005, 12, 25), 'Christmas Day'),
]
def data_strings(ctx, data):
# Let's defer it, just for fun.
return defer.succeed(strings)
# A different "none" option tuple
differentNone = ('none value', '- select -')
class SelectionFormPage(main.FormExamplePage):
title = 'Selection widgets'
description = 'Example of the various selection widgets'
def form_example(self, ctx):
form = forms.Form()
form.addField('required', forms.String(required=True))
form.addField('oneString', forms.String(),
forms.widgetFactory(forms.SelectChoice, options=strings))
form.addField('anotherString', forms.String(),
forms.widgetFactory(forms.SelectChoice, options=data_strings))
form.addField('oneMoreString', forms.String(required=True),
forms.widgetFactory(forms.RadioChoice, options=data_strings))
form.addField('oneDate', forms.Date(),
forms.widgetFactory(forms.SelectChoice, options=dates))
form.addField('multipleStrings', forms.Sequence(forms.String()),
forms.widgetFactory(forms.CheckboxMultiChoice,
options=data_strings))
form.addField('multipleDates', forms.Sequence(forms.Date()),
forms.widgetFactory(forms.CheckboxMultiChoice, options=dates))
form.addField('differentNoneSelect', forms.String(),
forms.widgetFactory(forms.SelectChoice, options=strings,
noneOption=differentNone))
form.addField('differentNoneRadios', forms.String(),
forms.widgetFactory(forms.RadioChoice, options=data_strings,
noneOption=differentNone))
form.addField('selectOther', forms.String(),
forms.widgetFactory(forms.SelectOtherChoice, options=['Mr',
'Mrs']))
form.addField('selectOtherRequired', forms.String(required=True),
forms.widgetFactory(forms.SelectOtherChoice, options=['Mr',
'Mrs']))
form.addField('multiselect', forms.String(),
forms.widgetFactory(forms.MultiselectChoice, options=strings))
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
import forms
from forms.examples import main
class NoFieldsFormPage(main.FormExamplePage):
title = 'Form With no Fields'
description = 'A form with no fields, just button(s). (Just to prove ' \
'it works.)'
def form_example(self, ctx):
form = forms.Form()
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print form, data
| Python |
import forms
from forms.examples import main
class RequiredFormPage(main.FormExamplePage):
title = 'Required Fields'
description = 'Demonstration of required fields'
def form_example(self, ctx):
form = forms.Form()
form.addField('name', forms.String(required=True))
form.addField('age', forms.Integer())
form.addAction(self.submitted)
return form
def submitted(self, ctx, form, data):
print data
| Python |
"""A package (for Nevow) for defining the schema, validation and rendering of
HTML forms.
"""
version_info = (0, 8, 0)
version = '.'.join([str(i) for i in version_info])
from nevow import static
from forms.types import *
from forms.validation import *
from forms.widget import *
from forms.widgets.restwidget import *
from forms.widgets.multiselect import *
from forms.form import Form, ResourceMixin, renderForm
from forms import iforms
def widgetFactory(widgetClass, *a, **k):
def _(original):
return widgetClass(original, *a, **k)
return _
try:
import pkg_resources
except ImportError:
import os.path
defaultCSS = static.File(os.path.join(os.path.split(__file__)[0], 'forms.css'))
formsJS = static.File(os.path.join(os.path.split(__file__)[0], 'js'))
else:
from forms.util import LazyResource
defaultCSS = LazyResource(lambda: static.File(pkg_resources.resource_filename('forms', 'forms.css')))
formsJS = LazyResource(lambda: static.File(pkg_resources.resource_filename('forms', 'js')))
del LazyResource
# Register standard adapters
from twisted.python.components import registerAdapter
from forms import converters
from forms.util import SequenceKeyLabelAdapter
registerAdapter(TextInput, String, iforms.IWidget)
registerAdapter(TextInput, Integer, iforms.IWidget)
registerAdapter(TextInput, Float, iforms.IWidget)
registerAdapter(Checkbox, Boolean, iforms.IWidget)
registerAdapter(DatePartsInput, Date, iforms.IWidget)
registerAdapter(TextInput, Time, iforms.IWidget)
registerAdapter(FileUploadRaw, File, iforms.IWidget)
registerAdapter(SequenceKeyLabelAdapter, tuple, iforms.IKey)
registerAdapter(SequenceKeyLabelAdapter, tuple, iforms.ILabel)
registerAdapter(converters.NullConverter, String, iforms.IStringConvertible)
registerAdapter(converters.DateToDateTupleConverter, Date, iforms.IDateTupleConvertible)
registerAdapter(converters.BooleanToStringConverter, Boolean, iforms.IBooleanConvertible)
registerAdapter(converters.IntegerToStringConverter, Integer, iforms.IStringConvertible)
registerAdapter(converters.FloatToStringConverter, Float, iforms.IStringConvertible)
registerAdapter(converters.DateToStringConverter, Date, iforms.IStringConvertible)
registerAdapter(converters.TimeToStringConverter, Time, iforms.IStringConvertible)
registerAdapter(converters.NullConverter, File, iforms.IFileConvertible)
registerAdapter(converters.NullConverter, Sequence, iforms.ISequenceConvertible)
try:
Decimal
except NameError:
pass
else:
registerAdapter(TextInput, Decimal, iforms.IWidget)
registerAdapter(converters.DecimalToStringConverter, Decimal, iforms.IStringConvertible)
del SequenceKeyLabelAdapter
del registerAdapter
| Python |
from zope.interface import Interface
class IType(Interface):
def validate(self, value):
pass
class IStructure(Interface):
pass
class IWidget(Interface):
def render(self, ctx, key, args, errors):
pass
def renderImmutable(self, ctx, key, args, errors):
pass
def processInput(self, ctx, key, args):
pass
class IFormFactory(Interface):
def formFactory(self, ctx, name):
pass
class IFormData(Interface):
pass
class IFormErrors(Interface):
pass
class IKey(Interface):
def key(self):
pass
class ILabel(Interface):
def label(self):
pass
class IConvertible(Interface):
def fromType(self, value):
pass
def toType(self, value):
pass
class IStringConvertible(IConvertible):
pass
class IBooleanConvertible(IConvertible):
pass
class IDateTupleConvertible(IConvertible):
pass
class IFileConvertible(IConvertible):
pass
class ISequenceConvertible(IConvertible):
pass
class IForm( Interface ):
pass
class IValidator(Interface):
def validate(self, field, value):
pass
| Python |
from twisted.application import internet, service
from nevow import appserver
from forms.examples import main
application = service.Application('examples')
service = internet.TCPServer(8000, main.makeSite(application))
service.setServiceParent(application)
| Python |
from setuptools import setup, find_packages
import forms
setup(
name='forms',
version=forms.version,
description='HTML forms framework for Nevow',
author='Matt Goodall',
author_email='matt@pollenation.net',
packages=find_packages(),
package_data={
'forms': ['forms.css'],
}
)
| Python |
from datetime import date, time
from twisted.application import internet, service
from nevow import appserver, compy, loaders, rend, static, tags as T
import forms
import os
from shutil import copyfileobj
import mimetypes, datetime
from forms import iforms, htmleditor, converters
from fileresource import fileResource
class KeyToFileConverter( object ):
__implements__ = iforms.IFileConvertible,
def fromType( self, value, context=None ):
"""
Given a string generate a (mimetype, filelike, fileName) or None
"""
if not value or value == '':
return None
mimetype = mimetypes.guess_type( value )
filelike = open(os.path.join('images',value),'r')
return (mimetype, filelike, value)
def toType( self, value ):
"""
Given a (mimetype, filelike, filename) tuple return a string
"""
if not value:
return None
(mimetype, filelike,fileName) = value;
target = file(os.path.join('images',fileName),'w')
copyfileobj( filelike, target )
target.close()
filelike.close()
return fileName
dates = [
(date(2005,1,1), 'New year\'s day'),
(date(2005,11,6), 'My birthday'),
(date(2005,12,25), 'Christmas day'),
]
times = [
(time(5,0), 'Really early'),
(time(7,0), 'A bit too early'),
(time(8,0), 'Hmm, not bad'),
(time(10,0), 'Nice :)'),
]
class Person(object):
def __init__(self, id, firstName, lastName):
self.id = id
self.firstName = firstName
self.lastName = lastName
class PersonKeyLabelAdapter(object):
__implements__ = iforms.IKey, iforms.ILabel
def __init__(self, original):
self.original = original
def key(self):
return self.original.id
def label(self):
return '%s, %s' % (self.original.lastName, self.original.firstName)
compy.registerAdapter(PersonKeyLabelAdapter, Person, iforms.IKey)
compy.registerAdapter(PersonKeyLabelAdapter, Person, iforms.ILabel)
people = [
Person(1, 'Matt', 'Goodall'),
Person(2, 'Tim', 'Parkin'),
]
class Page(rend.Page, forms.ResourceMixin):
addSlash = True
docFactory = loaders.xmlfile('test.html')
def __init__(self, *a, **k):
rend.Page.__init__(self, *a, **k)
forms.ResourceMixin.__init__(self)
def child_self(self, ctx):
return self
def form_oneOfEach(self, ctx):
form = forms.Form(self._submit)
form.addField('hidden_string', forms.Integer(), forms.Hidden)
form.addField('string', forms.String(required=True))
form.addField('password', forms.String(), forms.CheckedPassword)
form.addField('integer', forms.Integer())
form.addField('float', forms.Float())
form.addField('boolean', forms.Boolean())
form.addField('date', forms.Date(), forms.widgetFactory(forms.MMYYDatePartsInput, cutoffYear=38))
form.addField('time', forms.Time())
form.addAction(self._submit)
form.data = {'hidden_string': 101}
return form
def form_readonlyOneOfEach(self, ctx):
form = forms.Form(self._submit)
immutable=True
form.addField('string', forms.String(immutable=immutable), forms.TextInput)
form.addField('textarea', forms.String(immutable=immutable), forms.TextArea)
form.addField('password', forms.String(immutable=immutable), forms.CheckedPassword)
form.addField('integer', forms.Integer(immutable=immutable))
form.addField('float', forms.Float(immutable=immutable))
form.addField('boolean', forms.Boolean(immutable=immutable), forms.Checkbox)
form.addField('date', forms.Date(immutable=immutable), forms.widgetFactory(forms.MMYYDatePartsInput, cutoffYear=38))
form.addField('date2', forms.Date(immutable=immutable), forms.widgetFactory(forms.DatePartsInput, dayFirst=True))
form.addField('time', forms.Time(immutable=immutable))
form.addField('author', forms.Integer(immutable=immutable), lambda original: forms.SelectChoice(original, people))
form.addField('bar', forms.Sequence(forms.String(),immutable=immutable), forms.widgetFactory(forms.CheckboxMultiChoice, zip('abc','abc')),description='store your bar here')
form.addField('file', forms.File(immutable=immutable), forms.widgetFactory(forms.FileUploadWidget, convertibleFactory=KeyToFileConverter))
form.addAction(self._submit)
form.data = {'string':'hello', 'textarea':'some long text', 'password': ['one','one'], 'integer':10, 'float':22.22, 'boolean':True, 'author': 2, 'file':'dm.gif', 'date': datetime.date(2005, 10, 1), 'bar': ['a'], 'time': datetime.time(12, 51, 30)}
return form
def form_test(self, ctx):
form = forms.Form(self._submit)
form.addField('lastName', forms.String(required=True), label='Surname', description='This should be used to store your surname.. no really!!')
form.addField('date', forms.Date(), forms.widgetFactory(forms.SelectChoice, dates))
form.addField('time', forms.Time(), lambda original: forms.SelectChoice(original, times))
form.addField('author', forms.Integer(), lambda original: forms.SelectChoice(original, people))
form.addField('notes', forms.String(), htmleditor.TinyMCE)
form.addField('foo', forms.Sequence(forms.Time()), forms.widgetFactory(forms.CheckboxMultiChoice, times))
form.addField('bar', forms.Sequence(forms.String(),required=True), forms.widgetFactory(forms.CheckboxMultiChoice, zip('abc','abc')),description='store your bar here')
form.data = {'foo': [time(10,0)]}
form.addAction(self._submit)
form.addAction(self._submit, 'another')
return form
def form_1(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addAction(self._submit)
form.data = {
'name': 'Me!'
}
return form
def form_2(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addAction(self._submit)
form.data = {
'name': 'Me!'
}
return form
def form_3(self, ctx):
''' This test needs an 'assets' folder to store files in. The widget is passed a fileResource which
is used to get a preview url and to save the upload results. commit/rollback type hooks will need
to be added to forms to allow 'clean' operation. -- tp
'''
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addField('file', forms.String(required=True), forms.widgetFactory(forms.FileUpload,fileResource(),preview='image'))
form.addAction(self._submit)
#form.data = {
# 'file': 'product.jpg'
# }
return form
def form_4(self, ctx):
form = forms.Form(self._submit)
form.addField('name', forms.String(required=True))
form.addField('file', forms.File(required=True), forms.widgetFactory(forms.FileUploadWidget, convertibleFactory=KeyToFileConverter))
form.addAction(self._submit)
# form.data = {
# 'file': 'dm.gif'
# }
return form
def _submit(self, ctx, form, data):
print form
print data
if data.get('string') == 'error':
raise forms.FieldError('Failed the field!', 'string')
if data.get('string') == 'formerror':
raise forms.FormError('Failed the form!')
setattr(Page, 'child_nevow-forms.css', forms.defaultCSS)
setattr(Page, 'child_tiny_mce', static.File('tiny_mce'))
setattr(Page, 'child_webassets', static.File('assets'))
setattr(Page, 'child_images', static.File('images'))
setattr(Page, 'child_uploads', static.File('uploads'))
root = Page()
site = appserver.NevowSite(root, logPath='/dev/null')
application = service.Application('forms2-test')
internet.TCPServer(8000, site).setServiceParent(application)
| Python |
import os
from shutil import copyfileobj
FILESTORE_DIR='assets'
FILESTORE_URL='webassets'
class fileResource:
def getUrlForFile(self, id):
if id:
return os.path.join(FILESTORE_URL, id)
else:
return None
def storeFile( self, source, name ):
id = name
target = file(os.path.join(FILESTORE_DIR,id),'w')
copyfileobj( source, target )
target.close()
return id | Python |
"""
Form types.
"""
from forms import iforms, validation
from zope.interface import implements
class Type(object):
implements( iforms.IType )
# Name of the instance
name = None
# Instance is required
required = False
# Value to use if no value entered
missing = None
# Instance cannot be changed
immutable = False
# List of validators to test the value against
validators = []
def __init__(self, name=None, required=None, missing=None, immutable=None, validators=None):
if name is not None:
self.name = name
if missing is not None:
self.missing = missing
if immutable is not None:
self.immutable = immutable
if validators is not None:
self.validators = validators[:]
else:
self.validators = self.validators[:]
if required is None:
required = self.required
if required:
self.validators.append(validation.RequiredValidator())
def validate(self, value):
for validator in self.validators:
validator.validate(self, value)
if value is None:
value = self.missing
return value
class String(Type):
# Strip the value before validation
strip = False
def __init__(self, **k):
strip = k.pop('strip', None)
if strip is not None:
self.strip = strip
super(String, self).__init__(**k)
def validate(self, value):
if value is not None and self.strip:
value = value.strip()
if not value:
value = None
return super(String, self).validate(value)
class Integer(Type):
pass
class Float(Type):
pass
class Boolean(Type):
pass
class Date(Type):
pass
class Time(Type):
pass
class Sequence(Type):
# Type of items in the sequence
type = None
def __init__(self, type=None, **k):
super(Sequence, self).__init__(**k)
if type is not None:
self.type = type
def validate(self, value):
# Map empty sequence to None
if not value:
value = None
return super(Sequence, self).validate(value)
class File(Type):
pass
__all__ = [
'Boolean', 'Date', 'File', 'Float', 'Integer', 'Sequence', 'String', 'Time',
]
| Python |
"""
Form implementation and high-level renderers.
"""
from twisted.internet import defer
from nevow import context, loaders, inevow, tags as T, url
from nevow.compy import registerAdapter, Interface
from forms import iforms, util, validation
from resourcemanager import ResourceManager
from zope.interface import implements
ACTION_SEP = '!!'
FORM_ACTION = '__nevow_form__'
WIDGET_RESOURCE = '__widget_res__'
def renderForm(name):
def _(ctx, data):
def _processForm( form, ctx, name ):
# Find the form
ctx.remember(form, iforms.IForm)
# Create a keyed tag that will render the form when flattened.
tag = T.invisible(key=name)[inevow.IRenderer(form)]
# Create a new context, referencing the above tag, so that we don't
# pollute the current context with anything the form needs during
# rendering.
ctx = context.WovenContext(parent=ctx, tag=tag)
# Find errors for *this* form and remember things on the context
errors = iforms.IFormErrors(ctx, None)
if errors is not None and errors.formName == name:
ctx.remember(errors.data, iforms.IFormData)
else:
ctx.remember(None, iforms.IFormErrors)
ctx.remember(form.data or {}, iforms.IFormData)
return ctx
d = defer.succeed( ctx )
d.addCallback( locateForm, name )
d.addCallback( _processForm, ctx, name )
return d
return _
class Action(object):
"""Tracks an action that has been added to a form.
"""
def __init__(self, callback, name, validate):
self.callback = callback
self.name = name
self.validate = validate
class Form(object):
implements( iforms.IForm )
callback = None
items = None
actions = None
widgets = None
data = None
def __init__(self, callback=None):
if callback is not None:
self.callback = callback
self.resourceManager = ResourceManager()
def addField(self, name, type, widgetFactory=None, label=None, description=None, cssClass=None):
if self.items is None:
self.items = []
type.name = name
if label is None:
label = util.titleFromName(name)
self.items.append( (name,type,label,description,cssClass) )
if widgetFactory is not None:
if self.widgets is None:
self.widgets = {}
self.widgets[name] = widgetFactory
def addAction(self, callback, name="submit", validate=True):
if self.actions is None:
self.actions = []
if name in [action.name for action in self.actions]:
raise ValueError('Action with name %r already exists.' % name)
self.actions.append( Action(callback, name, validate) )
def widgetForItem(self, itemName):
for name, type, label, description, cssClass in self.items:
if name == itemName:
break
else:
raise KeyError()
if self.widgets is not None:
try:
widgetFactory = self.widgets[name]
except KeyError:
pass
else:
return widgetFactory(type)
return iforms.IWidget(type)
def process(self, ctx):
# Unflatten the request into nested dicts.
args = {}
for name, value in inevow.IRequest(ctx).args.iteritems():
name = name.split('.')
group, name = name[:-1], name[-1]
d = args
for g in group:
d = args.setdefault(g,{})
d[name] = value
# Find the callback to use, defaulting to the form default
callback, validate = self.callback, True
if self.actions is not None:
for action in self.actions:
if action.name in args:
# Remove it from the data
args.pop(action.name)
# Remember the callback and whether to validate
callback, validate = action.callback, action.validate
break
if callback is None:
raise Exception('The form has no callback and no action was found.')
# Store an errors object in the context
errors = FormErrors(self.name)
errors.data = args
ctx.remember(errors, iforms.IFormErrors)
# Iterate the items and collect the form data and/or errors.
data = {}
for name, type, label, description, cssClass in self.items:
try:
if not type.immutable:
data[name] = self.widgetForItem(name).processInput(ctx, name, args)
else:
data[name] = self.data.get(name)
errors.data[name] = self.data.get(name)
except validation.FieldError, e:
if e.fieldName is None:
e.fieldName = name
errors.add(e)
if errors:
return errors
# toType
for name, type, label, description, cssClass in self.items:
widget = self.widgetForItem(name)
if hasattr( widget, 'convertibleFactory' ) and not type.immutable:
data[name] = widget.convertibleFactory(type).toType( data.get(name) )
def _clearUpResources( r ):
self.resourceManager.clearUpResources()
return r
d = defer.maybeDeferred(callback, ctx, self, data)
d.addCallback( _clearUpResources )
d.addErrback(self._cbFormProcessingFailed, ctx)
return d
def _cbFormProcessingFailed(self, failure, ctx):
e = failure.value
failure.trap(validation.FormError, validation.FieldError)
errors = iforms.IFormErrors(ctx)
errors.add(failure.value)
return errors
class FormErrors(object):
implements( iforms.IFormErrors )
def __init__(self, formName):
self.formName = formName
self.errors = []
def add(self, error):
self.errors.append(error)
def getFieldError(self, name):
fieldErrors = [e for e in self.errors if isinstance(e, validation.FieldError)]
for error in fieldErrors:
if error.fieldName == name:
return error
def getFormErrors(self):
return [e for e in self.errors if isinstance(e, validation.FormError)]
def __nonzero__(self):
return len(self.errors) != 0
class ResourceMixin(object):
implements( iforms.IFormFactory )
def __init__(self, *a, **k):
super(ResourceMixin, self).__init__(*a, **k)
self.remember(self, iforms.IFormFactory)
def render_form(self, name):
def _(ctx, data):
return renderForm(name)
return _
def formFactory(self, ctx, name):
factory = getattr(self, 'form_%s'%name, None)
if factory is not None:
return factory(ctx)
s = super(ResourceMixin, self)
if hasattr(s,'formFactory'):
return s.formFactory(ctx, name)
def locateChild(self, ctx, segments):
# Leave now if this it not meant for me.
if not segments[0].startswith(FORM_ACTION) and not segments[0].startswith(WIDGET_RESOURCE):
return super(ResourceMixin, self).locateChild(ctx, segments)
# Find the form name, the form and remember them.
formName = segments[0].split(ACTION_SEP)[1]
d = defer.succeed( ctx )
d.addCallback( locateForm, formName )
d.addCallback( self._processForm, ctx, segments )
return d
def _processForm( self, form, ctx, segments ):
ctx.remember(form, iforms.IForm)
# Serve up file from the resource manager
if segments[0].startswith( WIDGET_RESOURCE ):
return self._fileFromWidget( ctx, form, segments[1:] )
# Process the form.
d = defer.maybeDeferred(form.process, ctx)
d.addCallback(self._formProcessed, ctx)
return d
def _fileFromWidget( self, ctx, form, segments ):
widget = form.widgetForItem( segments[0] )
return widget.getResource( ctx, segments[1:] )
def _formProcessed(self, r, ctx):
if isinstance(r, FormErrors):
if r:
return NoAddSlashHack(self), ()
else:
r = None
if r is None:
r = url.URL.fromContext(ctx)
return r, ()
class IKnownForms(Interface):
"""Marker interface used to locate a dict instance containing the named
forms we know about during this request.
"""
class KnownForms(dict):
implements( IKnownForms )
def locateForm(ctx, name):
"""Locate a form by name.
Initially, a form is located by calling on an IFormFactory that is found
on the context. Once a form has been found, it is remembered in an
KnownForms instance for the lifetime of the request.
This ensures that the form that is located during form processing will be
the same instance that is located when a form is rendered after validation
failure.
"""
# Get hold of the request
request = inevow.IRequest(ctx)
# Find or create the known forms instance
knownForms = request.getComponent(IKnownForms)
if knownForms is None:
knownForms = KnownForms()
request.setComponent(IKnownForms, knownForms)
# See if the form is already known
form = knownForms.get(name)
if form is not None:
return form
# Not known yet, ask a form factory to create the form
factory = iforms.IFormFactory(ctx)
def cacheForm( form, name ):
if form is None:
raise Exception('Form %r not found'%name)
form.name = name
# Make it a known
knownForms[name] = form
return form
d = defer.succeed( None )
d.addCallback( lambda r : factory.formFactory( ctx, name ) )
d.addCallback( cacheForm, name )
return d
def formAction(name):
return '%s%s%s' % (FORM_ACTION, ACTION_SEP, name)
def formWidgetResource(name):
return '%s%s%s' % (WIDGET_RESOURCE, ACTION_SEP, name)
class FormRenderer(object):
implements( inevow.IRenderer )
loader = loaders.stan(
T.form(id=T.slot('id'), action=T.slot('action'), class_='nevow-form', method='post', enctype='multipart/form-data', **{'accept-charset':'utf-8'})[
T.fieldset[
T.input(type='hidden', name='_charset_'),
T.slot('errors'),
T.slot('items'),
T.div(id=T.slot('fieldId'), pattern='item', _class=T.slot('class'))[
T.label(_class='label', _for=T.slot('id'))[T.slot('label')],
T.div(_class='inputs')[T.slot('inputs')],
T.slot('description'),
T.slot('message'),
],
T.div(class_='hiddenitems')[
T.slot('hiddenitems'),
T.invisible(pattern="hiddenitem")[T.slot('inputs')]
],
T.div(class_='actions')[
T.slot('actions'),
],
],
]
)
def __init__(self, original, *a, **k):
super(FormRenderer, self).__init__(*a, **k)
self.original = original
def rend(self, ctx, data):
segs = inevow.ICurrentSegments(ctx)
if segs and segs[-1].startswith(FORM_ACTION):
urlFactory = url.here.sibling
else:
urlFactory = url.here.child
tag = T.invisible[self.loader.load()]
tag.fillSlots('id', util.keytocssid(ctx.key))
tag.fillSlots('action', urlFactory(formAction(self.original.name)))
tag.fillSlots('errors', self._renderErrors)
tag.fillSlots('items', self._renderItems)
tag.fillSlots('hiddenitems', self._renderHiddenItems)
tag.fillSlots('actions', self._renderActions)
return tag
def _renderErrors(self, ctx, data):
errors = iforms.IFormErrors(ctx, None)
if errors is not None:
errors = errors.getFormErrors()
if not errors:
return ''
return T.div(class_='errors')[
T.p['Please correct the following errors:'],
T.ul[[T.li[str(error)] for error in errors]],
]
def _renderItems(self, ctx, data):
if self.original.items is None:
yield ''
return
itemPattern = inevow.IQ(ctx).patternGenerator('item')
for item in self.original.items:
widget = self.original.widgetForItem(item[0])
if getattr(widget,'inputType','') != 'hidden':
yield itemPattern(key=item[0], data=item, render=self._renderItem)
def _renderHiddenItems(self, ctx, data):
if self.original.items is None:
yield ''
return
hiddenItemPattern = inevow.IQ(ctx).patternGenerator('hiddenitem')
for item in self.original.items:
widget = self.original.widgetForItem(item[0])
if getattr(widget,'inputType','') == 'hidden':
yield hiddenItemPattern(key=item[0], data=item, render=self._renderHiddenItem)
def _renderItem(self, ctx, data):
def _(ctx, data):
name, type, label, description, cssClass = data
form = self.original
formErrors = iforms.IFormErrors(ctx, None)
formData = iforms.IFormData(ctx)
widget = form.widgetForItem(name)
if formErrors is None:
error = None
else:
error = formErrors.getFieldError(name)
classes = [
'field',
type.__class__.__name__.lower(),
widget.__class__.__name__.lower(),
]
if cssClass:
classes.append(cssClass)
if error is None:
message = ''
else:
classes.append('error')
message = T.div(class_='message')[str(error)]
ctx.tag.fillSlots('class', ' '.join(classes))
ctx.tag.fillSlots('fieldId', '%s-field'%util.keytocssid(ctx.key))
ctx.tag.fillSlots('id', util.keytocssid(ctx.key))
ctx.tag.fillSlots('label', label)
if type.immutable:
render = widget.renderImmutable
else:
render = widget.render
ctx.tag.fillSlots('inputs', render(ctx, name, formData, formErrors))
ctx.tag.fillSlots('message', message)
ctx.tag.fillSlots('description', T.div(class_='description')[description or ''])
return ctx.tag
return _
def _renderHiddenItem(self, ctx, data):
def _(ctx, data):
name, type, label, description, cssClass = data
form = self.original
formErrors = iforms.IFormErrors(ctx, None)
formData = iforms.IFormData(ctx)
widget = form.widgetForItem(name)
ctx.tag.fillSlots('fieldId', '%s-field'%util.keytocssid(ctx.key))
ctx.tag.fillSlots('id', util.keytocssid(ctx.key))
ctx.tag.fillSlots('inputs', widget.render(ctx, name, formData, formErrors))
return ctx.tag
return _
def _renderActions(self, ctx, data):
if self.original.actions is None:
yield ''
return
for action in self.original.actions:
yield T.invisible(data=action, render=self._renderAction)
def _renderAction(self, ctx, data):
return T.input(type='submit', id='%s-action-%s'%(util.keytocssid(ctx.key), data.name), name=data.name, value=util.titleFromName(data.name))
class NoAddSlashHack:
implements( inevow.IResource )
def __init__(self, wrapped):
self.wrapped = wrapped
def __getattr__(self, name):
return getattr(self.wrapped, name)
def renderHTTP(self, ctx):
MISSING = object()
addSlash = getattr(self.wrapped, 'addSlash', MISSING)
if addSlash:
self.wrapped.addSlash = False
try:
r = self.wrapped.renderHTTP(ctx)
finally:
if addSlash is not MISSING:
self.wrapped.addSlash = addSlash
else:
del self.wrapped.addSlash
return r
registerAdapter(FormRenderer, Form, inevow.IRenderer)
| Python |
from nevow import tags as T, util
from forms import iforms
from zope.interface import implements
tinyMCEGlue = T.xml("""
<!-- tinyMCE -->
<script language="javascript" type="text/javascript" src="/tiny_mce/tiny_mce.js"></script>
<script language="javascript" type="text/javascript">
tinyMCE.init({
mode : "specific_textareas"
theme: 'advanced',
theme_advanced_toolbar_location: 'top',
theme_advanced_toolbar_align: 'left'
});
</script>
<!-- /tinyMCE -->
""" )
class TinyMCE(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return T.textarea(name=key, id=key, mce_editable='true')[value or '']
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
if value:
value=T.xml(value)
else:
value=''
return T.div(id=key, class_="readonly-textarea-container") [
T.div(class_='readonly-textarea readonly')[value]
]
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
| Python |
import tempfile
import mimetypes
import re
import os
from shutil import copyfileobj
from exceptions import IOError, OSError
class ResourceManagerException( Exception ):
def __init__( self, *args, **kwds ):
super( ResourceManagerException, self ).__init__( *args, **kwds )
class ResourceManager( object ):
def __init__( self ):
self.widgetToID = {}
def register( self, widgetName, resourceId ):
self.widgetToID[widgetName] = resourceId
def getResourceId( self, widgetName ):
return self.widgetToID.get( widgetName )
def getResourceForWidget( self, widgetName ):
resourceId = self.getResourceId( widgetName )
if resourceId is None:
return None
(path, fileName) = self._fromResourceId( resourceId )
mimetype = mimetypes.guess_type( fileName )[0]
try:
filelike = open( path, 'r' )
return (mimetype, filelike, fileName)
except IOError:
return None
def getResourcePath( self, resourceId ):
"""
Required to create an instance of nevow.static.File
"""
(path, fileName) = self._fromResourceId( resourceId )
mimetype = mimetypes.guess_type( fileName )[0]
return (mimetype, path, fileName)
def setResource( self, widgetName, filelike, fileName ):
existingResource = self.widgetToID.get( widgetName )
if existingResource is not None:
try:
(path, ignore) = self._fromResourceId( existingResource )
os.remove( path )
except OSError:
pass
# Encode the filename to avoid any unicode filesystem errors.
fileName = self._encodeFilename(fileName)
(target, path) = tempfile.mkstemp( '__' + fileName )
# target is a file handle. We want a file object.
target = os.fdopen(target, 'w')
copyfileobj( filelike, target )
target.close()
resourceId = self._toResourceId( path )
self.widgetToID[widgetName] = resourceId
return resourceId
def _fromResourceId( self, resourceId ):
match = re.match( '^.*__(.*)$', resourceId )
if match is None:
return None
fileName = match.group( 1 )
path = os.sep.join( (tempfile.gettempdir(), resourceId) )
return path, self._decodeFilename(fileName)
def _toResourceId( self, path ):
path = path[len(tempfile.gettempdir()):]
if path[0] == os.sep:
path = path[1:]
return path
def clearUpResources( self ):
for id in self.widgetToID.values():
try:
(path, fileName) = self._fromResourceId( id )
os.remove( path )
except OSError:
pass
def _encodeFilename(self, filename):
"""
Encode the filename (which may be unicode) so it's safe to use with
the filesystem.
"""
return filename.encode('utf-8').encode('base64')[:-1]
def _decodeFilename(self, filename):
"""
Undo what _encodeFilename did.
"""
filename = filename + '\n'
return filename.decode('base64').decode('utf-8')
| Python |
"""Adapters for converting to and from a type's value according to an
IConvertible protocol.
"""
from datetime import date, time
from nevow.compy import Adapter
from forms import iforms, validation
from zope.interface import implements
class NullConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value
def toType(self, value):
if value is None:
return None
return value
class NumberToStringConverter(Adapter):
implements( iforms.IStringConvertible )
cast = None
def fromType(self, value):
if value is None:
return None
return str(value)
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
try:
value = self.cast(value)
except ValueError:
raise validation.FieldValidationError("Not a valid number")
return value
class IntegerToStringConverter(NumberToStringConverter):
cast = int
class FloatToStringConverter(NumberToStringConverter):
cast = float
class BooleanToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
if value:
return 'True'
return 'False'
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
if value not in ('True', 'False'):
raise validation.FieldValidationError('%r should be either True or False')
return value == 'True'
class DateToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value.isoformat()
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
return self.parseDate(value)
def parseDate(self, value):
try:
y, m, d = [int(p) for p in value.split('-')]
except ValueError:
raise validation.FieldValidationError('Invalid date')
try:
value = date(y, m, d)
except ValueError, e:
raise validation.FieldValidationError('Invalid date: '+str(e))
return value
class TimeToStringConverter(Adapter):
implements( iforms.IStringConvertible )
def fromType(self, value):
if value is None:
return None
return value.isoformat()
def toType(self, value):
if value is not None:
value = value.strip()
if not value:
return None
return self.parseTime(value)
def parseTime(self, value):
if '.' in value:
value, ms = value.split('.')
else:
ms = 0
try:
parts = value.split(':')
if len(parts)<2 or len(parts)>3:
raise ValueError()
if len(parts) == 2:
h, m = parts
s = 0
else:
h, m, s = parts
h, m, s, ms = int(h), int(m), int(s), int(ms)
except:
raise validation.FieldValidationError('Invalid time')
try:
value = time(h, m, s, ms)
except ValueError, e:
raise validation.FieldValidationError('Invalid time: '+str(e))
return value
class DateToDateTupleConverter(Adapter):
implements( iforms.IDateTupleConvertible )
def fromType(self, value):
if value is None:
return None, None, None
return value.year, value.month, value.day
def toType(self, value):
if value is None:
return None
try:
value = date(*value)
except (TypeError, ValueError), e:
raise validation.FieldValidationError('Invalid date: '+str(e))
return value
| Python |
from forms import iforms
from zope.interface import implements
def titleFromName(name):
def _():
it = iter(name)
last = None
while 1:
ch = it.next()
if ch == '_':
if last != '_':
yield ' '
elif last in (None,'_'):
yield ch.upper()
elif ch.isupper() and not last.isupper():
yield ' '
yield ch.upper()
else:
yield ch
last = ch
return ''.join(_())
def keytocssid(key):
return '-'.join(key.split('.'))
class SequenceKeyLabelAdapter(object):
implements( iforms.IKey, iforms.ILabel )
def __init__(self, original):
self.original = original
def key(self):
return self.original[0]
def label(self):
return self.original[1]
| Python |
"""
Widgets are small components that render form fields for inputing data in a
certain format.
"""
import itertools
from nevow import inevow, tags as T, util, url, static
from forms import converters, iforms, validation
from forms.util import keytocssid
from forms.form import formWidgetResource
from zope.interface import implements
from twisted.internet import defer
# Marker object for args that are not supplied
_UNSET = object()
class TextInput(object):
"""
A text input field.
<input type="text" ... />
"""
implements( iforms.IWidget )
inputType = 'text'
showValueOnFailure = True
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, readonly):
tag=T.input(type=self.inputType, name=key, id=keytocssid(ctx.key), value=value)
if readonly:
tag(class_='readonly', readonly='readonly')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
if not self.showValueOnFailure:
value = None
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class Checkbox(object):
"""
A checkbox input field.
<input type="checkbox" ... />
"""
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, value, disabled):
tag = T.input(type='checkbox', name=key, id=keytocssid(ctx.key), value='True')
if value == 'True':
tag(checked='checked')
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IBooleanConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IBooleanConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [None])[0]
if not value:
value = 'False'
value = iforms.IBooleanConvertible(self.original).toType(value)
return self.original.validate(value)
class Password(TextInput):
"""
A text input field that hides the text.
<input type="password" ... />
"""
inputType = 'password'
showValueOnFailure = False
class TextArea(object):
"""
A large text entry area that accepts newline characters.
<textarea>...</textarea>
"""
implements( iforms.IWidget )
cols = 48
rows = 6
def __init__(self, original, cols=None, rows=None):
self.original = original
if cols is not None:
self.cols = cols
if rows is not None:
self.rows = rows
def _renderTag(self, ctx, key, value, readonly):
tag=T.textarea(name=key, id=keytocssid(ctx.key), cols=self.cols, rows=self.rows)[value or '']
if readonly:
tag(class_='readonly', readonly='readonly')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).fromType(value)
return self.original.validate(value)
class CheckedPassword(object):
"""
Two password entry fields that must contain the same value to validate.
"""
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors and not errors.getFieldError(key):
values = args.get(key)
else:
values = ('', '')
return [
T.input(type='password', name=key, id=keytocssid(ctx.key), value=values[0]),
T.br,
T.label(for_='%s__confirm'%keytocssid(ctx.key))[' Confirm '],
T.input(type='password', name=key, id='%s__confirm'%keytocssid(ctx.key), value=values[1]),
]
def renderImmutable(self, ctx, key, args, errors):
values = ('', '')
return [
T.input(type='password', name=key, id=keytocssid(ctx.key), value=values[0], class_='readonly', readonly='readonly'),
T.br,
T.label(for_='%s__confirm'%keytocssid(ctx.key))[' Confirm '],
T.input(type='password', name=key, id='%s__confirm'%keytocssid(ctx.key), value=values[1], class_='readonly', readonly='readonly')
]
def processInput(self, ctx, key, args):
pwds = [pwd for pwd in args.get(key, [])]
if len(pwds) == 0:
pwd = ''
elif len(pwds) == 1:
raise validation.FieldValidationError('Please enter the password twice for confirmation.')
else:
if pwds[0] != pwds[1]:
raise validation.FieldValidationError('Passwords do not match.')
return self.original.validate(pwds[0])
class ChoiceBase(object):
"""
A base class for widgets that provide the UI to select one or more items
from a list.
options:
A sequence of objects adaptable to IKey and ILabel. IKey is used as the
<option>'s value attribute; ILabel is used as the <option>'s child.
IKey and ILabel adapters for tuple are provided.
noneOption:
An object adaptable to IKey and ILabel that is used to identify when
nothing has been selected. Defaults to ('', '')
"""
options = None
noneOption = None
def __init__(self, original, options=None, noneOption=_UNSET):
self.original = original
if options is not None:
self.options = options
if noneOption is not _UNSET:
self.noneOption = noneOption
class SelectChoice(ChoiceBase):
"""
A drop-down list of options.
<select>
<option value="...">...</option>
</select>
"""
implements( iforms.IWidget )
noneOption = ('', '')
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOptions(ctx, data):
if self.noneOption is not None:
yield T.option(value=iforms.IKey(self.noneOption).key())[iforms.ILabel(self.noneOption).label()]
if data is None:
return
for item in data:
optValue = iforms.IKey(item).key()
optLabel = iforms.ILabel(item).label()
optValue = converter.fromType(optValue)
option = T.option(value=optValue)[optLabel]
if optValue == value:
option = option(selected='selected')
yield option
tag=T.select(name=key, id=keytocssid(ctx.key), data=self.options)[renderOptions]
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])[0]
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0]
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class RadioChoice(ChoiceBase):
"""
A list of options in the form of radio buttons.
<input type="radio" ... value="..."/><label>...</label><br />
<input type="radio" ... value="..."/><label>...</label><br />
"""
implements( iforms.IWidget )
def _renderTag(self, ctx, key, value, converter, disabled):
def renderOption(ctx, itemKey, itemLabel, num, selected):
cssid = (keytocssid(ctx.key),'-',num)
tag = T.input(name=key, type='radio', id=cssid, value=itemKey)
if selected:
tag = tag(checked='checked')
return tag, ' ', T.label(for_=cssid)[itemLabel], T.br
def renderOptions(ctx, data):
# A counter to assign unique ids to each input
idCounter = itertools.count()
if self.noneOption is not None:
itemKey = iforms.IKey(self.noneOption).key()
itemLabel = iforms.ILabel(self.noneOption).label()
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(), itemKey==value)
if not data:
return
for item in data:
itemKey = iforms.IKey(item).key()
itemLabel = iforms.ILabel(item).label()
itemKey = converter.fromType(itemKey)
yield renderOption(ctx, itemKey, itemLabel, idCounter.next(), itemKey==value)
return T.invisible(data=self.options)[renderOptions]
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
if errors:
value = args.get(key, [''])[0]
else:
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original)
value = converter.fromType(args.get(key))
return self._renderTag(ctx, key, value, converter, True)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0]
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
class DatePartsInput(object):
"""
Three text input fields for entering a date in parts.
Default format is mm/dd/yyyy
dayFirst:
Make the day the first input field. dd/mm/yyyy
"""
implements( iforms.IWidget )
dayFirst = False
def __init__(self, original, dayFirst=None):
self.original = original
if dayFirst is not None:
self.dayFirst = dayFirst
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, year, month, day, namer, readonly):
yearTag = T.input(type="text", name=namer('year'), value=year, size=4)
monthTag = T.input(type="text", name=namer('month'), value=month, size=2)
dayTag = T.input(type="text", name=namer('day'), value=day, size=2)
if readonly:
tags = (yearTag, monthTag, dayTag)
for tag in tags:
tag(class_='readonly', readonly='readonly')
if self.dayFirst:
return dayTag, ' / ', monthTag, ' / ', yearTag, ' (dd/mm/yyyy)'
else:
return monthTag, ' / ', dayTag, ' / ', yearTag, ' (mm/dd/yyyy)'
def render(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
if errors:
year = args.get(namer('year'), [''])[0]
month = args.get(namer('month'), [''])[0]
day = args.get(namer('day'), [''])[0]
else:
year, month, day = converter.fromType(args.get(key))
return self._renderTag(ctx, year, month, day, namer, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
year, month, day = converter.fromType(args.get(key))
return self._renderTag(ctx, year, month, day, namer, True)
def processInput(self, ctx, key, args):
namer = self._namer(key)
value = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month', 'day')]
value = [p for p in value if p]
if not value:
value = None
elif len(value) != 3:
raise validation.FieldValidationError("Invalid date")
if value is not None:
try:
value = [int(p) for p in value]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
value = iforms.IDateTupleConvertible(self.original).toType(value)
return self.original.validate(value)
class MMYYDatePartsInput(object):
"""
Two input fields for entering the month and year.
"""
implements( iforms.IWidget )
cutoffYear = 70
def __init__(self, original, cutoffYear=None):
self.original = original
if cutoffYear is not None:
self.cutoffYear = cutoffYear
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, year, month, namer, readonly):
yearTag = T.input(type="text", name=namer('year'), value=year, size=2)
monthTag = T.input(type="text", name=namer('month'), value=month, size=2)
if readonly:
tags=(yearTag, monthTag)
for tag in tags:
tag(class_='readonly', readonly='readonly')
return monthTag, ' / ', yearTag, ' (mm/yy)'
def render(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
namer = self._namer(key)
if errors:
year = args.get(namer('year'), [''])[0]
month = args.get(namer('month'), [''])[0]
# return a blank for the day
day = ''
else:
year, month, day = converter.fromType(args.get(key))
# if we have a year as default data, stringify it and only use last two digits
if year is not None:
year = str(year)[2:]
return self._renderTag(ctx, year, month, namer, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IDateTupleConvertible(self.original)
year, month, day = converter.fromType(args.get(key))
namer = self._namer(key)
# if we have a year as default data, stringify it and only use last two digits
if year is not None:
year = str(year)[2:]
return self._renderTag(ctx, year, month, namer, True)
def processInput(self, ctx, key, args):
namer = self._namer(key)
value = [args.get(namer(part), [''])[0].strip() for part in ('year', 'month')]
value = [p for p in value if p]
if not value:
value = None
elif len(value) != 2:
raise validation.FieldValidationError("Invalid date")
if value is not None:
try:
value = [int(p) for p in value]
except ValueError, e:
raise validation.FieldValidationError("Invalid date")
if value[1] < 0 or value[1] > 99:
raise validation.FieldValidationError("Invalid year. Please enter a two-digit year.")
if value[0] > self.cutoffYear:
value[0] = 1900 + value[0]
else:
value[0] = 2000 + value[0]
value.append(1)
value = iforms.IDateTupleConvertible(self.original).toType( value )
return self.original.validate(value)
class CheckboxMultiChoice(object):
"""
Multiple choice list, rendered as a list of checkbox fields.
"""
implements( iforms.IWidget )
options = None
def __init__(self, original, options=None):
self.original = original
if options is not None:
self.options = options
def _renderTag(self, ctx, key, values, converter, disabled):
# loops through checkbox options and renders
for n,item in enumerate(self.options):
optValue = iforms.IKey(item).key()
optLabel = iforms.ILabel(item).label()
optValue = converter.fromType(optValue)
optid = (keytocssid(ctx.key),'-',n)
checkbox = T.input(type='checkbox', name=key, value=optValue, id=optid )
if optValue in values:
checkbox = checkbox(checked='checked')
if disabled:
checkbox = checkbox(class_='disabled', disabled='disabled')
yield checkbox, T.label(for_=optid)[optLabel], T.br()
def render(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original.type)
if errors:
values = args.get(key, [])
else:
values = args.get(key)
if values is not None:
values = [converter.fromType(v) for v in values]
else:
values = []
return self._renderTag(ctx, key, values, converter, False)
def renderImmutable(self, ctx, key, args, errors):
converter = iforms.IStringConvertible(self.original.type)
values = args.get(key)
if values is not None:
values = [converter.fromType(v) for v in values]
else:
values = []
return self._renderTag(ctx, key, values, converter, True)
def processInput(self, ctx, key, args):
values = args.get(key, [])
converter = iforms.IStringConvertible(self.original.type)
values = [converter.toType(v) for v in values]
return self.original.validate(values)
class FileUploadRaw(object):
implements( iforms.IWidget )
def __init__(self, original):
self.original = original
def _renderTag(self, ctx, key, disabled):
tag=T.input(name=key, id=keytocssid(ctx.key),type='file')
if disabled:
tag(class_='disabled', disabled='disabled')
return tag
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IFileConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, False)
def renderImmutable(self, ctx, key, args, errors):
value = iforms.IFileConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, True)
def processInput(self, ctx, key, args):
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
value = (name, fileitem.file)
value = iforms.IFileConvertible(self.original).fromType(value)
return self.original.validate(value)
class FileUpload(object):
implements( iforms.IWidget )
def __init__(self, original, fileHandler, preview=None):
self.original = original
self.fileHandler = fileHandler
self.preview = preview
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def _renderTag(self, ctx, key, value, namer, disabled):
name = self.fileHandler.getUrlForFile(value)
if name:
if self.preview == 'image':
yield T.p[value,T.img(src=self.fileHandler.getUrlForFile(value))]
else:
yield T.p[value]
else:
yield T.p[T.strong['nothing uploaded']]
yield T.input(name=namer('value'),value=value,type='hidden')
tag=T.input(name=key, id=keytocssid(ctx.key),type='file')
if disabled:
tag(class_='disabled', disabled='disabled')
yield tag
def render(self, ctx, key, args, errors):
namer = self._namer(key)
if errors:
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
value = name
else:
namer = self._namer(key)
value = args.get(namer('value'))[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, namer, False)
def renderImmutable(self, ctx, key, args, errors):
namer = self._namer(key)
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return self._renderTag(ctx, key, value, namer, True)
def processInput(self, ctx, key, args):
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
value = self.fileHandler.storeFile( fileitem.file, name )
else:
namer = self._namer(key)
value = args.get(namer('value'))[0]
value = iforms.IStringConvertible(self.original).fromType(value)
return self.original.validate(value)
class FileUploadWidget(object):
"""
File upload widget that carries the uploaded file around until the form
validates.
The widget uses the resource manager to save the file to temporary storage
until the form validates. This makes file uploads behave like most of the
other widgets, i.e. the value is kept when a form is redisplayed due to
validation errors.
"""
implements( iforms.IWidget )
FROM_RESOURCE_MANAGER = 'rm'
FROM_CONVERTIBLE = 'cf'
convertibleFactory = converters.NullConverter
def _namer(self, prefix):
def _(part):
return '%s__%s' % (prefix,part)
return _
def __init__( self, original, convertibleFactory=None, originalKeyIsURL=False ):
self.original = original
if convertibleFactory is not None:
self.convertibleFactory = convertibleFactory
self.originalKeyIsURL = originalKeyIsURL
def _blankField( self, field ):
"""
Convert empty strings into None.
"""
if field and field == '':
return None
return field
def _getFromArgs( self, args, name ):
"""
Get the first value of 'name' from 'args', or None.
"""
rv = args.get( name )
if rv:
rv = rv[0]
return rv
def render(self, ctx, key, args, errors):
"""
Render the data.
This either renders a link to the original file, if specified, and
no new file has been uploaded. Or a link to the uploaded file.
The request to get the data should be routed to the getResouce
method.
"""
form = iforms.IForm( ctx )
namer = self._namer( key )
resourceIdName = namer( 'resource_id' )
originalIdName = namer( 'original_id' )
# get the resource id first from the resource manager
# then try the request
resourceId = form.resourceManager.getResourceId( key )
if resourceId is None:
resourceId = self._getFromArgs( args, resourceIdName )
resourceId = self._blankField( resourceId )
# Get the original key from a hidden field in the request,
# then try the request file.data initial data.
originalKey = self._getFromArgs( args, originalIdName )
if not errors and not originalKey:
originalKey = args.get( key )
originalKey = self._blankField( originalKey )
if errors:
urlFactory = url.URL.fromContext( ctx ).sibling
else:
urlFactory = url.URL.fromContext( ctx ).child
if resourceId:
# Have an uploaded file, so render a URL to the uploaded file
tmpURL = urlFactory(formWidgetResource(form.name)).child(key).child( self.FROM_RESOURCE_MANAGER ).child( resourceId )
yield T.p[T.img(src=tmpURL)]
elif originalKey:
# The is no uploaded file, but there is an original, so render a
# URL to it
if self.originalKeyIsURL:
tmpURL = originalKey
else:
tmpURL = urlFactory(formWidgetResource(form.name)).child(key).child( self.FROM_CONVERTIBLE ).child( originalKey )
yield T.p[T.img(src=tmpURL)]
else:
# No uploaded file, no original
yield T.p[T.strong['Nothing uploaded']]
yield T.input(name=key, id=keytocssid(ctx.key),type='file')
# Id of uploaded file in the resource manager
yield T.input(name=resourceIdName,value=resourceId,type='hidden')
if originalKey:
# key of the original that can be used to get a file later
yield T.input(name=originalIdName,value=originalKey,type='hidden')
def renderImmutable(self, ctx, key, args, errors):
form = iforms.IForm(ctx)
namer = self._namer(key)
originalIdName = namer('original_id')
# Get the original key from a hidden field in the request,
# then try the request form.data initial data.
originalKey = self._getFromArgs( args, originalIdName )
if not errors and not originalKey:
originalKey = args.get( key )
originalKey = self._blankField( originalKey )
if errors:
urlFactory = url.URL.fromContext( ctx ).sibling
else:
urlFactory = url.URL.fromContext( ctx ).child
if originalKey:
# The is no uploaded file, but there is an original, so render a
# URL to it
if self.originalKeyIsURL:
tmpURL = originalKey
else:
tmpURL = urlFactory(formWidgetResource(form.name)).child(key).child(self.FROM_CONVERTIBLE).child(originalKey)
yield T.p[T.img(src=tmpURL)]
else:
# No uploaded file, no original
yield T.p[T.strong['Nothing uploaded']]
if originalKey:
# key of the original that can be used to get a file later
yield T.input(name=originalIdName,value=originalKey,type='hidden')
def processInput(self, ctx, key, args):
"""
Process the request, storing any uploaded file in the
resource manager.
"""
resourceManager = iforms.IForm( ctx ).resourceManager
# Ping the resource manager with any resource ids that I know
self._registerWithResourceManager( key, args, resourceManager )
fileitem = inevow.IRequest(ctx).fields[key]
name = fileitem.filename.decode(util.getPOSTCharset(ctx))
if name:
# Store the uploaded file in the resource manager
resourceManager.setResource( key, fileitem.file, name )
# Validating against an uploaded file. Should the fact that there is
# original file meet a required field validation?
return self.original.validate( resourceManager.getResourceForWidget( key ) )
def _registerWithResourceManager( self, key, args, resourceManager ):
"""
If there is a resource id in the request, then let the
resource manager know about it.
"""
namer = self._namer( key )
resourceIdName = namer( 'resource_id' )
resourceId = self._getFromArgs( args, resourceIdName )
resourceId = self._blankField( resourceId )
if resourceId:
resourceManager.register( key, resourceId )
def getResource( self, ctx, segments ):
"""
Return an Resource that contains the image, either a file
from the resource manager, or a data object from the convertible.
"""
if segments[0] == self.FROM_RESOURCE_MANAGER:
# Resource manager can provide a path so return a static.File
# instance that points to the file
rm = iforms.IForm( ctx ).resourceManager
(mimetype, path, fileName) = rm.getResourcePath( segments[1] )
return static.File( path, mimetype ), []
elif segments[0] == self.FROM_CONVERTIBLE:
# The convertible can provide a file like object so create a
# static.Data instance with the data from the convertible.
def _( result ):
mimetype, filelike, fileName = result
data = filelike.read()
filelike.close()
return static.Data( data, mimetype ), []
d = defer.maybeDeferred( self.convertibleFactory(self.original).fromType, segments[1], context=ctx )
d.addCallback( _ )
return d
else:
return None
class Hidden(object):
"""
A hidden form field.
"""
__implements__ = iforms.IWidget,
inputType = 'hidden'
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iforms.IStringConvertible(self.original).fromType(args.get(key))
return T.input(type=self.inputType, name=key, id=keytocssid(ctx.key), value=value)
def renderImmutable(self, ctx, key, args, errors):
return self.render(ctx, key, args, errors)
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iforms.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
__all__ = [
'Checkbox', 'CheckboxMultiChoice', 'CheckedPassword','FileUploadRaw', 'FileUpload', 'FileUploadWidget',
'Password', 'SelectChoice', 'TextArea', 'TextInput', 'DatePartsInput',
'MMYYDatePartsInput', 'Hidden', 'RadioChoice',
]
| Python |
import re
from zope.interface import implements
from forms import iforms
class FormError(Exception):
pass
class FieldError(Exception):
def __init__(self, message, fieldName=None):
Exception.__init__(self, message)
self.message = message
self.fieldName = fieldName
class FieldValidationError(FieldError):
pass
class FieldRequiredError(FieldValidationError):
pass
class RequiredValidator(object):
implements(iforms.IValidator)
def validate(self, field, value):
if value is None:
raise FieldRequiredError, 'Required'
class LengthValidator(object):
"""Validate the length of the value is within a given range.
"""
implements(iforms.IValidator)
def __init__(self, min=None, max=None):
self.min = min
self.max = max
assert self.min is not None or self.max is not None
def validationErrorMessage(self, field):
if self.min is not None and self.max is None:
return 'Must be longer than %r characters'%(self.min,)
if self.min is None and self.max is not None:
return 'Must be shorter than %r characters'%(self.max,)
return 'Must be between %r and %r characters'%(self.min, self.max)
def validate(self, field, value):
if value is None:
return
length = len(value)
if self.min is not None and length < self.min:
raise FieldValidationError, self.validationErrorMessage(field)
if self.max is not None and length > self.max:
raise FieldValidationError, self.validationErrorMessage(field)
class RangeValidator(object):
"""Validate the size of the value is within is given range.
"""
implements(iforms.IValidator)
def __init__(self, min=None, max=None):
self.min = min
self.max = max
assert self.min is not None or self.max is not None
def validationErrorMessage(self, field):
if self.min is not None and self.max is None:
return 'Must be greater than %r'%(self.min,)
if self.min is None and self.max is not None:
return 'Must be less than %r'%(self.max,)
return 'Must be between %r and %r'%(self.min, self.max)
def validate(self, field, value):
if value is None:
return
if self.min is not None and value < self.min:
raise FieldValidationError, self.validationErrorMessage(field)
if self.max is not None and value > self.max:
raise FieldValidationError, self.validationErrorMessage(field)
class PatternValidator(object):
"""Validate the value is a certain pattern.
The required pattern is defined as a regular expression. The regex will be
compiled automatically if necessary.
"""
implements(iforms.IValidator)
def __init__(self, regex):
self.regex = regex
def validate(self, field, value):
if value is None:
return
# If it doesn't look like a regex object then compile it now
if not hasattr(self.regex, 'match'):
self.regex = re.compile(self.regex)
if self.regex.match(value) is None:
raise FieldValidationError, 'Invalid format'
__all__ = [
'FormError', 'FieldError', 'FieldValidationError', 'FieldRequiredError',
'RequiredValidator', 'LengthValidator', 'RangeValidator', 'PatternValidator',
]
| Python |
import forms
title = 'Dates'
description = 'Date entry examples'
def makeForm(ctx):
form = forms.Form()
form.addField('isoFormat', forms.Date(), forms.TextInput)
form.addField('monthFirst', forms.Date(), forms.DatePartsInput)
form.addField('dayFirst', forms.Date(), forms.widgetFactory(forms.DatePartsInput, dayFirst=True))
form.addField('monthAndYear', forms.Date(), forms.MMYYDatePartsInput)
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
import forms
title = 'Simple Form'
description = 'Probably the simplest form possible.'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
import forms
title = 'Form Types'
description = 'Example of using different typed fields.'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aInteger', forms.Integer())
form.addField('aFloat', forms.Float())
form.addField('aBoolean', forms.Boolean())
form.addField('aDate', forms.Date())
form.addField('aTime', forms.Time())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
from datetime import date
import forms
title = 'Missing Values'
description = 'Providing default values when missing'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String(missing='<nothing>'))
form.addField('aDate', forms.Date(missing=date(2005, 8, 1)))
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
import forms
title = 'File Upload'
description = 'Uploading a file'
def makeForm(ctx):
form = forms.Form()
form.addField('file', forms.File())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
import pkg_resources
from twisted.python import reflect
from nevow import appserver, loaders, rend, static, tags as T, url
import forms
DOCTYPE = T.xml('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">')
CHARSET = T.xml('<meta http-equiv="content-type" content="text/html; charset=utf-8" />')
examples = [
'forms.examples.simple',
'forms.examples.types',
'forms.examples.required',
'forms.examples.missing',
'forms.examples.prepopulate',
'forms.examples.fileupload',
'forms.examples.smartupload',
'forms.examples.selections',
'forms.examples.dates',
]
def makeSite(application):
root = RootPage()
site = appserver.NevowSite(root, logPath='web.log')
return site
class RootPage(rend.Page):
docFactory = loaders.stan(
T.invisible[
DOCTYPE,
T.html[
T.head[
CHARSET,
T.title['Forms Examples'],
T.link(rel='stylesheet', type='text/css', href=url.root.child('examples.css')),
],
T.body[
T.directive('examples'),
],
],
],
)
def render_examples(self, ctx, data):
for name in examples:
module = reflect.namedAny(name)
yield T.div(class_='example')[
T.h1[T.a(href=url.here.child(name))[module.title]],
T.p[module.description],
]
def childFactory(self, ctx, name):
if name in examples:
return FormPage(reflect.namedAny(name))
class FormPage(forms.ResourceMixin, rend.Page):
docFactory = loaders.stan(
T.invisible[
DOCTYPE,
T.html[
T.head[
CHARSET,
T.title(data=T.directive('title'), render=rend.data),
T.link(rel='stylesheet', type='text/css', href=url.root.child('examples.css')),
T.link(rel='stylesheet', type='text/css', href=url.root.child('forms.css')),
],
T.body[
T.h1(data=T.directive('title'), render=rend.data),
T.p(data=T.directive('description'), render=rend.data),
T.directive('form example'),
],
],
],
)
def data_title(self, ctx, data):
return self.original.title
def data_description(self, ctx, data):
return self.original.description
def form_example(self, ctx):
return self.original.makeForm(ctx)
# Add child_ attributes
examples_css = pkg_resources.resource_filename('forms.examples', 'examples.css')
setattr(RootPage, 'child_examples.css', static.File(examples_css))
setattr(RootPage, 'child_forms.css', forms.defaultCSS)
| Python |
import forms
title = 'Smart File Upload'
description = 'Smart uploading of files where the file is "carried across" when the validation fails'
def makeForm(ctx):
form = forms.Form()
form.addField('required', forms.String(required=True))
form.addField('file', forms.File(), forms.FileUploadWidget)
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
| Python |
from datetime import datetime
import forms
title = 'Prepopulate'
description = 'Example of prepopulating form fields'
def makeForm(ctx):
form = forms.Form()
form.addField('aString', forms.String())
form.addField('aTime', forms.Time())
form.addAction(formSubmitted)
form.data = {
'aTime': datetime.utcnow().time(),
}
return form
def formSubmitted(ctx, form, data):
print data
| Python |
from twisted.internet import defer
from datetime import date
import forms
title = 'Selection widgets'
description = 'Example of the various selection widgets'
def makeForm(ctx):
form = forms.Form()
form.addField('required', forms.String(required=True))
form.addField('oneString', forms.String(), forms.widgetFactory(forms.SelectChoice, options=strings))
form.addField('anotherString', forms.String(), forms.widgetFactory(forms.SelectChoice, options=data_strings))
form.addField('oneMoreString', forms.String(required=True), forms.widgetFactory(forms.RadioChoice, options=data_strings))
form.addField('oneDate', forms.Date(), forms.widgetFactory(forms.SelectChoice, options=dates))
form.addField('multipleStrings', forms.Sequence(forms.String()), forms.widgetFactory(forms.CheckboxMultiChoice, options=strings))
form.addField('multipleDates', forms.Sequence(forms.Date()), forms.widgetFactory(forms.CheckboxMultiChoice, options=dates))
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print form, data
# A boring list of (value, label) pairs.
strings = [
('foo', 'Foo'),
('bar', 'Bar'),
]
# A list of dates with meaningful names.
dates = [
(date(2005, 01, 01), 'New Year Day'),
(date(2005, 11, 06), 'My Birthday'),
(date(2005, 12, 25), 'Christmas Day'),
]
def data_strings(ctx, data):
# Let's defer it, just for fun.
return defer.succeed(strings)
| Python |
import forms
title = 'Required Fields'
description = 'Demonstration of required fields'
def makeForm(ctx):
form = forms.Form()
form.addField('name', forms.String(required=True))
form.addField('age', forms.Integer())
form.addAction(formSubmitted)
return form
def formSubmitted(ctx, form, data):
print data
| Python |
"""A package (for Nevow) for defining the schema, validation and rendering of
HTML forms.
"""
version_info = (0, 2, 3)
version = '.'.join([str(i) for i in version_info])
from nevow import static
from forms.types import *
from forms.validation import *
from forms.widget import *
from forms.form import Form, ResourceMixin, renderForm
from forms import iforms
def widgetFactory(widgetClass, *a, **k):
def _(original):
return widgetClass(original, *a, **k)
return _
try:
import pkg_resources
except ImportError:
import os.path
defaultCSS = static.File(os.path.join(os.path.split(__file__)[0], 'forms.css'))
else:
defaultCSS = static.File(pkg_resources.resource_filename('forms', 'forms.css'))
# Register standard adapters
from nevow.compy import registerAdapter
from forms import converters
registerAdapter(TextInput, String, iforms.IWidget)
registerAdapter(TextInput, Integer, iforms.IWidget)
registerAdapter(TextInput, Float, iforms.IWidget)
registerAdapter(Checkbox, Boolean, iforms.IWidget)
registerAdapter(DatePartsInput, Date, iforms.IWidget)
registerAdapter(TextInput, Time, iforms.IWidget)
registerAdapter(FileUploadRaw, File, iforms.IWidget)
from forms import util
registerAdapter(util.SequenceKeyLabelAdapter, tuple, iforms.IKey)
registerAdapter(util.SequenceKeyLabelAdapter, tuple, iforms.ILabel)
registerAdapter(converters.NullConverter, String, iforms.IStringConvertible)
registerAdapter(converters.DateToDateTupleConverter, Date, iforms.IDateTupleConvertible)
registerAdapter(converters.BooleanToStringConverter, Boolean, iforms.IBooleanConvertible)
registerAdapter(converters.IntegerToStringConverter, Integer, iforms.IStringConvertible)
registerAdapter(converters.FloatToStringConverter, Float, iforms.IStringConvertible)
registerAdapter(converters.DateToStringConverter, Date, iforms.IStringConvertible)
registerAdapter(converters.TimeToStringConverter, Time, iforms.IStringConvertible)
registerAdapter(converters.NullConverter, File, iforms.IFileConvertible)
registerAdapter(converters.NullConverter, Sequence, iforms.ISequenceConvertible)
del registerAdapter
| Python |
from nevow.compy import Interface
class IType(Interface):
def validate(self, value):
pass
class IStructure(Interface):
pass
class IWidget(Interface):
def render(self, ctx, key, args, errors):
pass
def renderImmutable(self, ctx, key, args, errors):
pass
def processInput(self, ctx, key, args):
pass
class IFormFactory(Interface):
def formFactory(self, ctx, name):
pass
class IFormData(Interface):
pass
class IFormErrors(Interface):
pass
class IKey(Interface):
def key(self):
pass
class ILabel(Interface):
def label(self):
pass
class IConvertible(Interface):
def fromType(self, value):
pass
def toType(self, value):
pass
class IStringConvertible(IConvertible):
pass
class IBooleanConvertible(IConvertible):
pass
class IDateTupleConvertible(IConvertible):
pass
class IFileConvertible(IConvertible):
pass
class ISequenceConvertible(IConvertible):
pass
class IForm( Interface ):
pass
class IValidator(Interface):
def validate(self, field, value):
pass
| Python |
"""
Form types.
"""
try:
import decimal
haveDecimal = True
except ImportError:
haveDecimal = False
from zope.interface import implements
from formal import iformal, validation
class Type(object):
implements( iformal.IType )
# Name of the instance
name = None
# Value to use if no value entered
missing = None
# Instance cannot be changed
immutable = False
# List of validators to test the value against
validators = ()
def __init__(self, name=None, required=None, missing=None, immutable=None, validators=None):
if name is not None:
self.name = name
if missing is not None:
self.missing = missing
if immutable is not None:
self.immutable = immutable
if validators is not None:
self.validators = list(validators)
else:
self.validators = list(self.validators)
if required is None:
required = self.required
if required:
self.validators.append(validation.RequiredValidator())
def validate(self, value):
for validator in self.validators:
validator.validate(self, value)
if value is None:
value = self.missing
return value
def hasValidator(self, validatorType):
"""
Check for the existance of a validator of a specific type.
"""
for v in self.validators:
if isinstance(v, validatorType):
return True
return False
def required():
def get(self):
return self.hasValidator(validation.RequiredValidator)
return get,
required = property(*required())
class String(Type):
# Strip the value before validation
strip = False
def __init__(self, **k):
strip = k.pop('strip', None)
if strip is not None:
self.strip = strip
super(String, self).__init__(**k)
def validate(self, value):
if value is not None and self.strip:
value = value.strip()
if not value:
value = None
return super(String, self).validate(value)
class Integer(Type):
pass
class Float(Type):
pass
class Boolean(Type):
pass
class Date(Type):
pass
class Time(Type):
pass
if haveDecimal:
class Decimal(Type):
"""
Forms type for Python 2.4's decimal.Decimal type.
"""
class Sequence(Type):
# Type of items in the sequence
type = None
def __init__(self, type=None, **k):
super(Sequence, self).__init__(**k)
if type is not None:
self.type = type
def validate(self, value):
# Map empty sequence to None
if not value:
value = None
return super(Sequence, self).validate(value)
class File(Type):
pass
__all__ = [
'Boolean', 'Date', 'File', 'Float', 'Integer', 'Sequence', 'String', 'Time',
]
if haveDecimal:
__all__.append('Decimal')
| Python |
"""
Form implementation and high-level renderers.
"""
from zope.interface import Interface
from twisted.internet import defer
from twisted.python.components import registerAdapter
from nevow import appserver, context, loaders, inevow, rend, tags as T, url
from nevow.util import getPOSTCharset
from formal import iformal, util, validation
from resourcemanager import ResourceManager
from zope.interface import implements
SEPARATOR = '!!'
FORMS_KEY = '__nevow_form__'
WIDGET_RESOURCE_KEY = 'widget_resource'
def renderForm(name):
def _(ctx, data):
def _processForm( form, ctx, name ):
# Remember the form
ctx.remember(form, iformal.IForm)
# Create a keyed tag that will render the form when flattened.
tag = T.invisible(key=name)[inevow.IRenderer(form)]
# Create a new context, referencing the above tag, so that we don't
# pollute the current context with anything the form needs during
# rendering.
ctx = context.WovenContext(parent=ctx, tag=tag)
# Find errors for *this* form and remember things on the context
errors = iformal.IFormErrors(ctx, None)
if errors is not None and errors.formName == name:
ctx.remember(errors.data, iformal.IFormData)
else:
ctx.remember(None, iformal.IFormErrors)
ctx.remember(form.data or {}, iformal.IFormData)
return ctx
d = defer.succeed( ctx )
d.addCallback( locateForm, name )
d.addCallback( _processForm, ctx, name )
return d
return _
class Action(object):
"""Tracks an action that has been added to a form.
"""
def __init__(self, callback, name, validate, label):
if not util.validIdentifier(name):
import warnings
warnings.warn('[0.9] Invalid action name %r. This will become an error in the future.' %
name, FutureWarning, stacklevel=3)
self.callback = callback
self.name = name
self.validate = validate
if label is None:
self.label = util.titleFromName(name)
else:
self.label = label
class Field(object):
itemParent = None
def __init__(self, name, type, widgetFactory=None, label=None,
description=None, cssClass=None):
if not util.validIdentifier(name):
raise ValueError('%r is an invalid field name'%name)
if label is None:
label = util.titleFromName(name)
if widgetFactory is None:
widgetFactory = iformal.IWidget
self.name = name
self.type = type
self.widgetFactory = widgetFactory
self.label = label
self.description = description
self.cssClass = cssClass
def setItemParent(self, itemParent):
self.itemParent = itemParent
def _getKey(self):
parts = [self.name]
parent = self.itemParent
while parent is not None:
parts.append(parent.name)
parent = parent.itemParent
parts.reverse()
return '.'.join(parts)
key = property(_getKey)
def makeWidget(self):
return self.widgetFactory(self.type)
def process(self, ctx, form, args, errors):
# If the type is immutable then copy the original value to args in case
# another validation error causes this field to be re-rendered.
if self.type.immutable:
args[self.key] = form.data.get(self.key)
return
# Process the input using the widget, storing the data back on the form.
try:
form.data[self.key] = self.makeWidget().processInput(ctx, self.key, args)
except validation.FieldError, e:
if e.fieldName is None:
e.fieldName = self.key
errors.add(e)
class FieldFragment(rend.Fragment):
implements(inevow.IRenderer)
docFactory = loaders.stan(
T.div(id=T.slot('fieldId'), _class=T.slot('class'),
render=T.directive('field'))[
T.label(_class='label', _for=T.slot('id'))[T.slot('label')],
T.div(_class='inputs')[T.slot('inputs')],
T.slot('description'),
T.slot('message'),
])
hiddenDocFactory = loaders.stan(
T.invisible(render=T.directive('field'))[T.slot('inputs')])
def __init__(self, field):
self.field = field
# Nasty hack to work out if this is a hidden field. Keep the widget
# for later anyway.
self.widget = field.makeWidget()
if getattr(self.widget, 'inputType', None) == 'hidden':
self.docFactory = self.hiddenDocFactory
def render_field(self, ctx, data):
# The field we're rendering
field = self.field
# Get stuff from the context
formData = iformal.IFormData(ctx)
formErrors = iformal.IFormErrors(ctx, None)
# Find any error
if formErrors is None:
error = None
else:
error = formErrors.getFieldError(field.key)
# Build the error message
if error is None:
message = ''
else:
message = T.div(class_='message')[error.message]
# Create the widget (it's created in __init__ as a hack)
widget = self.widget
# Build the list of CSS classes
classes = [
'field',
field.type.__class__.__name__.lower(),
widget.__class__.__name__.lower(),
]
if field.type.required:
classes.append('required')
if field.cssClass:
classes.append(field.cssClass)
if error:
classes.append('error')
# Create the widget and decide the method that should be called
if field.type.immutable:
render = widget.renderImmutable
else:
render = widget.render
# Fill the slots
ctx.tag.fillSlots('id', util.render_cssid(field.key))
ctx.tag.fillSlots('fieldId', [util.render_cssid(field.key), '-field'])
ctx.tag.fillSlots('class', ' '.join(classes))
ctx.tag.fillSlots('label', field.label)
ctx.tag.fillSlots('inputs', render(ctx, field.key, formData,
formErrors))
ctx.tag.fillSlots('message', message)
ctx.tag.fillSlots('description',
T.div(class_='description')[field.description or ''])
return ctx.tag
registerAdapter(FieldFragment, Field, inevow.IRenderer)
class Group(object):
itemParent = None
def __init__(self, name, label=None, description=None):
if label is None:
label = util.titleFromName(name)
self.name = name
self.label = label
self.description = description
self.items = FormItems(self)
# Forward to FormItems methods
self.add = self.items.add
self.getItemByName = self.items.getItemByName
def setItemParent(self, itemParent):
self.itemParent = itemParent
def process(self, ctx, form, args, errors):
for item in self.items:
item.process(ctx, form, args, errors)
class GroupFragment(rend.Fragment):
docFactory = loaders.stan(
T.fieldset(id=T.slot('id'), render=T.directive('group'))[
T.legend[T.slot('label')],
T.div(class_='description')[T.slot('description')],
T.slot('items'),
]
)
def __init__(self, group):
super(GroupFragment, self).__init__()
self.group = group
def render_group(self, ctx, data):
group = self.group
ctx.tag.fillSlots('id', util.render_cssid(group.name))
ctx.tag.fillSlots('label', group.label)
ctx.tag.fillSlots('description', group.description or '')
ctx.tag.fillSlots('items', [inevow.IRenderer(item) for item in
group.items])
return ctx.tag
registerAdapter(GroupFragment, Group, inevow.IRenderer)
class Form(object):
implements( iformal.IForm )
callback = None
actions = None
def __init__(self, callback=None):
if callback is not None:
self.callback = callback
self.resourceManager = ResourceManager()
self.data = {}
self.items = FormItems(None)
# Forward to FormItems methods
self.add = self.items.add
self.getItemByName = self.items.getItemByName
def addField(self, name, type, widgetFactory=None, label=None,
description=None, cssClass=None):
self.add(Field(name, type, widgetFactory, label, description, cssClass))
def addAction(self, callback, name="submit", validate=True, label=None):
if self.actions is None:
self.actions = []
if name in [action.name for action in self.actions]:
raise ValueError('Action with name %r already exists.' % name)
self.actions.append( Action(callback, name, validate, label) )
def process(self, ctx):
# Get the request args
requestArgs = inevow.IRequest(ctx).args
# Decode the request arg names
charset = getPOSTCharset(ctx)
args = dict([(k.decode(charset),v) for k,v in requestArgs.iteritems()])
# Find the callback to use, defaulting to the form default
callback, validate = self.callback, True
if self.actions is not None:
for action in self.actions:
if action.name in args:
# Remove it from the data
args.pop(action.name)
# Remember the callback and whether to validate
callback, validate = action.callback, action.validate
break
if callback is None:
raise Exception('The form has no callback and no action was found.')
# Store an errors object in the context
errors = FormErrors(self.name)
errors.data = args
ctx.remember(errors, iformal.IFormErrors)
# Iterate the items and collect the form data and/or errors.
for item in self.items:
item.process(ctx, self, args, errors)
if errors and validate:
return errors
def _clearUpResources( r ):
if not errors:
self.resourceManager.clearUpResources()
return r
d = defer.maybeDeferred(callback, ctx, self, self.data)
d.addCallback( _clearUpResources )
d.addErrback(self._cbFormProcessingFailed, ctx)
return d
def _cbFormProcessingFailed(self, failure, ctx):
e = failure.value
failure.trap(validation.FormError, validation.FieldError)
errors = iformal.IFormErrors(ctx)
errors.add(failure.value)
return errors
class FormItems(object):
"""
A managed collection of form items.
"""
def __init__(self, itemParent):
self.items = []
self.itemParent = itemParent
def __iter__(self):
return iter(self.items)
def add(self, item):
# Check the item name is unique
if item.name in [i.name for i in self.items]:
raise ValueError('Item named %r already added to %r' %
(item.name, self))
# Add to child items and set self the parent
self.items.append(item)
item.setItemParent(self.itemParent)
def getItemByName(self, name):
name = name.split('.', 1)
if len(name) == 1:
name, rest = name[0], None
else:
name, rest = name[0], name[1]
for item in self.items:
if item.name == name:
if rest is None:
return item
return item.getItemByName(rest)
raise KeyError("No item called %r" % name)
class FormErrors(object):
implements( iformal.IFormErrors )
def __init__(self, formName):
self.formName = formName
self.errors = []
def add(self, error):
self.errors.append(error)
def getFieldError(self, name):
fieldErrors = [e for e in self.errors if isinstance(e, validation.FieldError)]
for error in fieldErrors:
if error.fieldName == name:
return error
def getFormErrors(self):
return self.errors
def __nonzero__(self):
return len(self.errors) != 0
class FormResource(object):
implements(inevow.IResource)
def locateChild(self, ctx, segments):
# The form name is the first segment
formName = segments[0]
if segments[1] == WIDGET_RESOURCE_KEY:
# Serve up file from the resource manager
d = locateForm(ctx, formName)
d.addCallback(self._fileFromWidget, ctx, segments[2:])
return d
return appserver.NotFound
def renderHTTP(self, ctx):
raise NotImplemented()
def _fileFromWidget(self, form, ctx, segments):
ctx.remember(form, iformal.IForm)
widget = form.getItemByName(segments[0]).makeWidget()
return widget.getResource(ctx, segments[0], segments[1:])
class FormsResourceBehaviour(object):
"""
I provide the IResource behaviour needed to process and render a page
containing a Form.
"""
def __init__(self, **k):
parent = k.pop('parent')
super(FormsResourceBehaviour, self).__init__(**k)
self.parent = parent
def locateChild(self, ctx, segments):
if segments[0] == FORMS_KEY:
self.remember(ctx)
return FormResource(), segments[1:]
return appserver.NotFound
def renderHTTP(self, ctx):
# Get hold of the request
request = inevow.IRequest(ctx)
# Intercept POST requests to see if it's for me
if request.method != 'POST':
return None
# Try to find the form name
formName = request.args.get(FORMS_KEY, [None])[0]
if formName is None:
return None
# Find the actual form and process it
self.remember(ctx)
d = defer.succeed(ctx)
d.addCallback(locateForm, formName)
d.addCallback(self._processForm, ctx)
return d
def remember(self, ctx):
ctx.remember(self.parent, iformal.IFormFactory)
def render_form(self, name):
def _(ctx, data):
self.remember(ctx)
return renderForm(name)
return _
def _processForm(self, form, ctx):
ctx.remember(form, iformal.IForm)
d = defer.maybeDeferred(form.process, ctx)
d.addCallback(self._formProcessed, ctx)
return d
def _formProcessed(self, result, ctx):
if isinstance(result, FormErrors):
return None
elif result is None:
resource = url.URL.fromContext(ctx)
else:
resource = result
return resource
class ResourceMixin(object):
implements( iformal.IFormFactory )
__formsBehaviour = None
def __behaviour(self):
if self.__formsBehaviour is None:
self.__formsBehaviour = FormsResourceBehaviour(parent=self)
return self.__formsBehaviour
def locateChild(self, ctx, segments):
def gotResult(result):
if result is not appserver.NotFound:
return result
return super(ResourceMixin, self).locateChild(ctx, segments)
self.remember(self, iformal.IFormFactory)
d = defer.maybeDeferred(self.__behaviour().locateChild, ctx, segments)
d.addCallback(gotResult)
return d
def renderHTTP(self, ctx):
def gotResult(result):
if result is not None:
return result
return super(ResourceMixin, self).renderHTTP(ctx)
self.remember(self, iformal.IFormFactory)
d = defer.maybeDeferred(self.__behaviour().renderHTTP, ctx)
d.addCallback(gotResult)
return d
def render_form(self, name):
return self.__behaviour().render_form(name)
def formFactory(self, ctx, name):
factory = getattr(self, 'form_%s'%name, None)
if factory is not None:
return factory(ctx)
s = super(ResourceMixin, self)
if hasattr(s,'formFactory'):
return s.formFactory(ctx, name)
class IKnownForms(Interface):
"""Marker interface used to locate a dict instance containing the named
forms we know about during this request.
"""
class KnownForms(dict):
implements( IKnownForms )
def locateForm(ctx, name):
"""Locate a form by name.
Initially, a form is located by calling on an IFormFactory that is found
on the context. Once a form has been found, it is remembered in an
KnownForms instance for the lifetime of the request.
This ensures that the form that is located during form processing will be
the same instance that is located when a form is rendered after validation
failure.
"""
# Get hold of the request
request = inevow.IRequest(ctx)
# Find or create the known forms instance
knownForms = request.getComponent(IKnownForms)
if knownForms is None:
knownForms = KnownForms()
request.setComponent(IKnownForms, knownForms)
# See if the form is already known
form = knownForms.get(name)
if form is not None:
return form
# Not known yet, ask a form factory to create the form
factory = ctx.locate(iformal.IFormFactory)
def cacheForm( form, name ):
if form is None:
raise Exception('Form %r not found'%name)
form.name = name
# Make it a known
knownForms[name] = form
return form
d = defer.succeed( None )
d.addCallback( lambda r : factory.formFactory( ctx, name ) )
d.addCallback( cacheForm, name )
return d
def widgetResourceURL(name):
return url.here.child(FORMS_KEY).child(name).child(WIDGET_RESOURCE_KEY)
def widgetResourceURLFromContext(ctx,name):
# Could this replace widgetResourceURL?
u = url.URL.fromContext(ctx)
if u.pathList()[-1] != FORMS_KEY:
u = u.child(FORMS_KEY)
return u.child(name).child(WIDGET_RESOURCE_KEY)
class FormRenderer(object):
implements( inevow.IRenderer )
loader = loaders.stan(
T.form(**{'id': T.slot('formId'), 'action': T.slot('formAction'),
'class': 'nevow-form', 'method': 'post', 'enctype':
'multipart/form-data', 'accept-charset': 'utf-8'})[
T.div[
T.input(type='hidden', name='_charset_'),
T.input(type='hidden', name=FORMS_KEY, value=T.slot('formName')),
T.slot('formErrors'),
T.slot('formItems'),
T.div(class_='actions')[
T.slot('formActions'),
],
],
]
)
def __init__(self, original, *a, **k):
super(FormRenderer, self).__init__(*a, **k)
self.original = original
def rend(self, ctx, data):
tag = T.invisible[self.loader.load()]
tag.fillSlots('formName', self.original.name)
tag.fillSlots('formId', util.keytocssid(ctx.key))
tag.fillSlots('formAction', url.here)
tag.fillSlots('formErrors', self._renderErrors)
tag.fillSlots('formItems', self._renderItems)
tag.fillSlots('formActions', self._renderActions)
return tag
def _renderErrors(self, ctx, data):
errors = iformal.IFormErrors(ctx, None)
if errors is not None:
errors = errors.getFormErrors()
if not errors:
return ''
errorList = T.ul()
for error in errors:
if isinstance(error, validation.FormError):
errorList[ T.li[ error.message ] ]
for error in errors:
if isinstance(error, validation.FieldError):
item = self.original.getItemByName(error.fieldName)
errorList[ T.li[ T.strong[ item.label, ' : ' ], error.message ] ]
return T.div(class_='errors')[ T.p['Please correct the following errors:'], errorList ]
def _renderItems(self, ctx, data):
if self.original.items is None:
yield ''
return
for item in self.original.items:
yield inevow.IRenderer(item)
def _renderActions(self, ctx, data):
if self.original.actions is None:
yield ''
return
for action in self.original.actions:
yield T.invisible(data=action, render=self._renderAction)
def _renderAction(self, ctx, data):
return T.input(type='submit', id='%s-action-%s'%(util.keytocssid(ctx.key), data.name), name=data.name, value=data.label)
registerAdapter(FormRenderer, Form, inevow.IRenderer)
| Python |
import warnings
warnings.warn(
"The htmleditor module is deprecated. To use an HTML editor with " \
"formal, render your field as a formal.TextArea and use JavaScript " \
"to turn the textarea into a HTML editor.",
DeprecationWarning,
stacklevel=2)
from nevow import tags as T, util
from formal import iformal
from zope.interface import implements
tinyMCEGlue = T.xml("""
<!-- tinyMCE -->
<script language="javascript" type="text/javascript" src="/tiny_mce/tiny_mce.js"></script>
<script language="javascript" type="text/javascript">
tinyMCE.init({
mode : "specific_textareas"
theme: 'advanced',
theme_advanced_toolbar_location: 'top',
theme_advanced_toolbar_align: 'left'
});
</script>
<!-- /tinyMCE -->
""" )
class TinyMCE(object):
implements( iformal.IWidget )
def __init__(self, original):
self.original = original
def render(self, ctx, key, args, errors):
if errors:
value = args.get(key, [''])[0]
else:
value = iformal.IStringConvertible(self.original).fromType(args.get(key))
return T.textarea(name=key, id=key, mce_editable='true')[value or '']
def renderImmutable(self, ctx, key, args, errors):
value = iformal.IStringConvertible(self.original).fromType(args.get(key))
if value:
value=T.xml(value)
else:
value=''
return T.div(id=key, class_="readonly-textarea-container") [
T.div(class_='readonly-textarea readonly')[value]
]
def processInput(self, ctx, key, args):
value = args.get(key, [''])[0].decode(util.getPOSTCharset(ctx))
value = iformal.IStringConvertible(self.original).toType(value)
return self.original.validate(value)
| Python |
from nevow import appserver, rend
from formal.form import FormsResourceBehaviour
class FormPage(rend.Page):
"""
Base class for pages that contain a Form.
XXX This really, really needs to turn into a ComponentPage that iterates
a bunch of component behaviours looking for something that succeeded.
The components probably needs to be per-interface, i.e IResource for
locateChild/renderHTTP, IRenderer for render_, etc.
"""
def __init__(self, *a, **k):
rend.Page.__init__(self, *a, **k)
self._formsComponent = FormsResourceBehaviour(parent=self)
def locateChild(self, ctx, segments):
def gotResult(result):
if result is not appserver.NotFound:
return result
return rend.Page.locateChild(self, ctx, segments)
d = defer.maybeDeferred(self._formsComponent.locateChild, ctx, segments)
d.addCallback(gotResult)
return d
def renderHTTP(self, ctx):
def gotResult(result):
if result is not None:
return result
return rend.Page.renderHTTP(self, ctx)
d = defer.maybeDeferred(self._formsComponent.renderHTTP, ctx)
d.addCallback(gotResult)
return d
def render_form(self, name):
return self._formsComponent.render_form(name)
def formFactory(self, ctx, name):
# Find the factory method
factory = getattr(self, 'form_%s'%name, None)
if factory is not None:
return factory(ctx)
# Try the super class
s = super(FormPage, self)
if hasattr(s,'formFactory'):
return s.formFactory(ctx, name)
| Python |
Subsets and Splits
SQL Console for ajibawa-2023/Python-Code-Large
Provides a useful breakdown of language distribution in the training data, showing which languages have the most samples and helping identify potential imbalances across different language groups.