walters 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (25) hide show
  1. data/LICENSE +28 -0
  2. data/README.md +20 -0
  3. data/Rakefile +6 -0
  4. data/ext/Rakefile +5 -0
  5. data/ext/houdini/buffer.c +249 -0
  6. data/ext/houdini/buffer.h +113 -0
  7. data/ext/houdini/houdini.h +44 -0
  8. data/ext/houdini/houdini_href_e.c +115 -0
  9. data/ext/houdini/houdini_html_e.c +90 -0
  10. data/ext/houdini/houdini_html_u.c +122 -0
  11. data/ext/houdini/houdini_js_e.c +90 -0
  12. data/ext/houdini/houdini_js_u.c +60 -0
  13. data/ext/houdini/houdini_uri_e.c +101 -0
  14. data/ext/houdini/houdini_uri_u.c +65 -0
  15. data/ext/houdini/houdini_xml_e.c +136 -0
  16. data/ext/houdini/html_unescape.h +754 -0
  17. data/ext/walters.cpp +105 -0
  18. data/ext/walters_buffer.cpp +113 -0
  19. data/ext/x86_64-darwin/__xni_walters.cpp +450 -0
  20. data/ext/x86_64-darwin/walters.h +43 -0
  21. data/lib/walters.rb +2 -0
  22. data/lib/walters/version.rb +3 -0
  23. data/lib/walters/walters.rb +87 -0
  24. data/walters.gemspec +21 -0
  25. metadata +134 -0
data/LICENSE ADDED
@@ -0,0 +1,28 @@
1
+ Licensed under the Apache License, Version 2.0 (the "License");
2
+ you may not use this file except in compliance with the License.
3
+ You may obtain a copy of the License at
4
+
5
+ http://www.apache.org/licenses/LICENSE-2.0
6
+
7
+ Unless required by applicable law or agreed to in writing, software
8
+ distributed under the License is distributed on an "AS IS" BASIS,
9
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10
+ See the License for the specific language governing permissions and
11
+ limitations under the License.
12
+
13
+
14
+ Alternatively, you can redistribute it and/or modify it under
15
+ the terms of the GNU Lesser General Public License as published by
16
+ the Free Software Foundation, either version 3 of the License, or
17
+ (at your option) any later version.
18
+
19
+ This code is distributed in the hope that it will be useful, but WITHOUT
20
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
21
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
22
+ version 3 for more details.
23
+
24
+ You should have received a copy of the GNU Lesser General Public License
25
+ version 3 along with this work. If not, see <http://www.gnu.org/licenses/>.
26
+
27
+
28
+
data/README.md ADDED
@@ -0,0 +1,20 @@
1
+ walters [![Build Status](https://travis-ci.org/wmeissner/walters.png)](https://travis-ci.org/wmeissner/walters)
2
+ ======
3
+
4
+ [Walters](https://github.com/wmeissner/walters) is a JRuby wrapper for the [Houdini](https://github.com/vmg/houdini)
5
+ html escaping library
6
+
7
+ ##### Example usage
8
+
9
+ jruby-1.7.4.dev :001 > require 'walters'
10
+ => true
11
+ jruby-1.7.4.dev :002 > Walters.escape_html('<html>')
12
+ => "&lt;html&gt;"
13
+
14
+
15
+ The same extension can be used from the legacy CRuby VM as well (aka MRI)
16
+
17
+ 2.0.0p0 :001 > require 'walters'
18
+ => true
19
+ 2.0.0p0 :002 > Walters.escape_html('<html>')
20
+ => "&lt;html&gt;"
data/Rakefile ADDED
@@ -0,0 +1,6 @@
1
+ require 'rake/clean'
2
+ require 'rubygems/tasks'
3
+
4
+ Gem::Tasks.new do |t|
5
+ t.scm.tag.format = '%s'
6
+ end
data/ext/Rakefile ADDED
@@ -0,0 +1,5 @@
1
+ require 'xni/compile_task'
2
+
3
+ XNI::CompileTask.new('walters') do |t|
4
+ t.export File.expand_path('../lib/walters.rb')
5
+ end
data/ext/houdini/buffer.c ADDED
@@ -0,0 +1,249 @@
1
+ /*
2
+ * Copyright (C) the libgit2 contributors. All rights reserved.
3
+ *
4
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
5
+ * a Linking Exception. For full terms see the included COPYING file.
6
+ */
7
+ #include <stdarg.h>
8
+ #include <ctype.h>
9
+ #include <string.h>
10
+ #include <assert.h>
11
+ #include <string.h>
12
+ #include <stdio.h>
13
+ #include <stdlib.h>
14
+ #include <sys/param.h>
15
+
16
+ #include "buffer.h"
17
+
18
+ /* Used as default value for gh_buf->ptr so that people can always
19
+ * assume ptr is non-NULL and zero terminated even for new gh_bufs.
20
+ */
21
+ char gh_buf__initbuf[1];
22
+ char gh_buf__oom[1];
23
+
24
+ #define ENSURE_SIZE(b, d) \
25
+ if ((d) > buf->asize && gh_buf_grow(b, (d)) < 0)\
26
+ return -1;
27
+
28
+ void gh_buf_init(gh_buf *buf, size_t initial_size)
29
+ {
30
+ buf->asize = 0;
31
+ buf->size = 0;
32
+ buf->ptr = gh_buf__initbuf;
33
+
34
+ if (initial_size)
35
+ gh_buf_grow(buf, initial_size);
36
+ }
37
+
38
+ int gh_buf_try_grow(gh_buf *buf, size_t target_size, bool mark_oom)
39
+ {
40
+ char *new_ptr;
41
+ size_t new_size;
42
+
43
+ if (buf->ptr == gh_buf__oom)
44
+ return -1;
45
+
46
+ if (target_size <= buf->asize)
47
+ return 0;
48
+
49
+ if (buf->asize == 0) {
50
+ new_size = target_size;
51
+ new_ptr = NULL;
52
+ } else {
53
+ new_size = buf->asize;
54
+ new_ptr = buf->ptr;
55
+ }
56
+
57
+ /* grow the buffer size by 1.5, until it's big enough
58
+ * to fit our target size */
59
+ while (new_size < target_size)
60
+ new_size = (new_size << 1) - (new_size >> 1);
61
+
62
+ /* round allocation up to multiple of 8 */
63
+ new_size = (new_size + 7) & ~7;
64
+
65
+ new_ptr = realloc(new_ptr, new_size);
66
+
67
+ if (!new_ptr) {
68
+ if (mark_oom)
69
+ buf->ptr = gh_buf__oom;
70
+ return -1;
71
+ }
72
+
73
+ buf->asize = new_size;
74
+ buf->ptr = new_ptr;
75
+
76
+ /* truncate the existing buffer size if necessary */
77
+ if (buf->size >= buf->asize)
78
+ buf->size = buf->asize - 1;
79
+ buf->ptr[buf->size] = '\0';
80
+
81
+ return 0;
82
+ }
83
+
84
+ void gh_buf_free(gh_buf *buf)
85
+ {
86
+ if (!buf) return;
87
+
88
+ if (buf->ptr != gh_buf__initbuf && buf->ptr != gh_buf__oom)
89
+ free(buf->ptr);
90
+
91
+ gh_buf_init(buf, 0);
92
+ }
93
+
94
+ void gh_buf_clear(gh_buf *buf)
95
+ {
96
+ buf->size = 0;
97
+ if (buf->asize > 0)
98
+ buf->ptr[0] = '\0';
99
+ }
100
+
101
+ int gh_buf_set(gh_buf *buf, const char *data, size_t len)
102
+ {
103
+ if (len == 0 || data == NULL) {
104
+ gh_buf_clear(buf);
105
+ } else {
106
+ if (data != buf->ptr) {
107
+ ENSURE_SIZE(buf, len + 1);
108
+ memmove(buf->ptr, data, len);
109
+ }
110
+ buf->size = len;
111
+ buf->ptr[buf->size] = '\0';
112
+ }
113
+ return 0;
114
+ }
115
+
116
+ int gh_buf_sets(gh_buf *buf, const char *string)
117
+ {
118
+ return gh_buf_set(buf, string, string ? strlen(string) : 0);
119
+ }
120
+
121
+ int gh_buf_putc(gh_buf *buf, char c)
122
+ {
123
+ ENSURE_SIZE(buf, buf->size + 2);
124
+ buf->ptr[buf->size++] = c;
125
+ buf->ptr[buf->size] = '\0';
126
+ return 0;
127
+ }
128
+
129
+ int gh_buf_put(gh_buf *buf, const void *data, size_t len)
130
+ {
131
+ ENSURE_SIZE(buf, buf->size + len + 1);
132
+ memmove(buf->ptr + buf->size, data, len);
133
+ buf->size += len;
134
+ buf->ptr[buf->size] = '\0';
135
+ return 0;
136
+ }
137
+
138
+ int gh_buf_puts(gh_buf *buf, const char *string)
139
+ {
140
+ assert(string);
141
+ return gh_buf_put(buf, string, strlen(string));
142
+ }
143
+
144
+ int gh_buf_vprintf(gh_buf *buf, const char *format, va_list ap)
145
+ {
146
+ int len;
147
+ const size_t expected_size = buf->size + (strlen(format) * 2);
148
+
149
+ ENSURE_SIZE(buf, expected_size);
150
+
151
+ while (1) {
152
+ va_list args;
153
+ va_copy(args, ap);
154
+
155
+ len = vsnprintf(
156
+ buf->ptr + buf->size,
157
+ buf->asize - buf->size,
158
+ format, args
159
+ );
160
+
161
+ if (len < 0) {
162
+ free(buf->ptr);
163
+ buf->ptr = gh_buf__oom;
164
+ return -1;
165
+ }
166
+
167
+ if ((size_t)len + 1 <= buf->asize - buf->size) {
168
+ buf->size += len;
169
+ break;
170
+ }
171
+
172
+ ENSURE_SIZE(buf, buf->size + len + 1);
173
+ }
174
+
175
+ return 0;
176
+ }
177
+
178
+ int gh_buf_printf(gh_buf *buf, const char *format, ...)
179
+ {
180
+ int r;
181
+ va_list ap;
182
+
183
+ va_start(ap, format);
184
+ r = gh_buf_vprintf(buf, format, ap);
185
+ va_end(ap);
186
+
187
+ return r;
188
+ }
189
+
190
+ void gh_buf_copy_cstr(char *data, size_t datasize, const gh_buf *buf)
191
+ {
192
+ size_t copylen;
193
+
194
+ assert(data && datasize && buf);
195
+
196
+ data[0] = '\0';
197
+
198
+ if (buf->size == 0 || buf->asize <= 0)
199
+ return;
200
+
201
+ copylen = buf->size;
202
+ if (copylen > datasize - 1)
203
+ copylen = datasize - 1;
204
+ memmove(data, buf->ptr, copylen);
205
+ data[copylen] = '\0';
206
+ }
207
+
208
+ void gh_buf_swap(gh_buf *buf_a, gh_buf *buf_b)
209
+ {
210
+ gh_buf t = *buf_a;
211
+ *buf_a = *buf_b;
212
+ *buf_b = t;
213
+ }
214
+
215
+ char *gh_buf_detach(gh_buf *buf)
216
+ {
217
+ char *data = buf->ptr;
218
+
219
+ if (buf->asize == 0 || buf->ptr == gh_buf__oom)
220
+ return NULL;
221
+
222
+ gh_buf_init(buf, 0);
223
+
224
+ return data;
225
+ }
226
+
227
+ void gh_buf_attach(gh_buf *buf, char *ptr, size_t asize)
228
+ {
229
+ gh_buf_free(buf);
230
+
231
+ if (ptr) {
232
+ buf->ptr = ptr;
233
+ buf->size = strlen(ptr);
234
+ if (asize)
235
+ buf->asize = (asize < buf->size) ? buf->size + 1 : asize;
236
+ else /* pass 0 to fall back on strlen + 1 */
237
+ buf->asize = buf->size + 1;
238
+ } else {
239
+ gh_buf_grow(buf, asize);
240
+ }
241
+ }
242
+
243
+ int gh_buf_cmp(const gh_buf *a, const gh_buf *b)
244
+ {
245
+ int result = memcmp(a->ptr, b->ptr, MIN(a->size, b->size));
246
+ return (result != 0) ? result :
247
+ (a->size < b->size) ? -1 : (a->size > b->size) ? 1 : 0;
248
+ }
249
+
data/ext/houdini/buffer.h ADDED
@@ -0,0 +1,113 @@
1
+ /*
2
+ * Copyright (C) the libgit2 contributors. All rights reserved.
3
+ *
4
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
5
+ * a Linking Exception. For full terms see the included COPYING file.
6
+ */
7
+ #ifndef INCLUDE_buffer_h__
8
+ #define INCLUDE_buffer_h__
9
+
10
+ #include <stdbool.h>
11
+ #include <stddef.h>
12
+ #include <stdarg.h>
13
+ #include <sys/types.h>
14
+ #include <stdint.h>
15
+
16
+ typedef struct {
17
+ char *ptr;
18
+ size_t asize, size;
19
+ } gh_buf;
20
+
21
+ extern char gh_buf__initbuf[];
22
+ extern char gh_buf__oom[];
23
+
24
+ #define GH_BUF_INIT { gh_buf__initbuf, 0, 0 }
25
+
26
+ /**
27
+ * Initialize a gh_buf structure.
28
+ *
29
+ * For the cases where GH_BUF_INIT cannot be used to do static
30
+ * initialization.
31
+ */
32
+ extern void gh_buf_init(gh_buf *buf, size_t initial_size);
33
+
34
+ /**
35
+ * Attempt to grow the buffer to hold at least `target_size` bytes.
36
+ *
37
+ * If the allocation fails, this will return an error. If mark_oom is true,
38
+ * this will mark the buffer as invalid for future operations; if false,
39
+ * existing buffer content will be preserved, but calling code must handle
40
+ * that buffer was not expanded.
41
+ */
42
+ extern int gh_buf_try_grow(gh_buf *buf, size_t target_size, bool mark_oom);
43
+
44
+ /**
45
+ * Grow the buffer to hold at least `target_size` bytes.
46
+ *
47
+ * If the allocation fails, this will return an error and the buffer will be
48
+ * marked as invalid for future operations, invaliding contents.
49
+ *
50
+ * @return 0 on success or -1 on failure
51
+ */
52
+ static inline int gh_buf_grow(gh_buf *buf, size_t target_size)
53
+ {
54
+ return gh_buf_try_grow(buf, target_size, true);
55
+ }
56
+
57
+ extern void gh_buf_free(gh_buf *buf);
58
+ extern void gh_buf_swap(gh_buf *buf_a, gh_buf *buf_b);
59
+
60
+ /**
61
+ * Test if there have been any reallocation failures with this gh_buf.
62
+ *
63
+ * Any function that writes to a gh_buf can fail due to memory allocation
64
+ * issues. If one fails, the gh_buf will be marked with an OOM error and
65
+ * further calls to modify the buffer will fail. Check gh_buf_oom() at the
66
+ * end of your sequence and it will be true if you ran out of memory at any
67
+ * point with that buffer.
68
+ *
69
+ * @return false if no error, true if allocation error
70
+ */
71
+ static inline bool gh_buf_oom(const gh_buf *buf)
72
+ {
73
+ return (buf->ptr == gh_buf__oom);
74
+ }
75
+
76
+
77
+ static inline size_t gh_buf_len(const gh_buf *buf)
78
+ {
79
+ return buf->size;
80
+ }
81
+
82
+ extern int gh_buf_cmp(const gh_buf *a, const gh_buf *b);
83
+
84
+ extern void gh_buf_attach(gh_buf *buf, char *ptr, size_t asize);
85
+ extern char *gh_buf_detach(gh_buf *buf);
86
+ extern void gh_buf_copy_cstr(char *data, size_t datasize, const gh_buf *buf);
87
+
88
+ static inline const char *gh_buf_cstr(const gh_buf *buf)
89
+ {
90
+ return buf->ptr;
91
+ }
92
+
93
+ /*
94
+ * Functions below that return int value error codes will return 0 on
95
+ * success or -1 on failure (which generally means an allocation failed).
96
+ * Using a gh_buf where the allocation has failed with result in -1 from
97
+ * all further calls using that buffer. As a result, you can ignore the
98
+ * return code of these functions and call them in a series then just call
99
+ * gh_buf_oom at the end.
100
+ */
101
+ extern int gh_buf_set(gh_buf *buf, const char *data, size_t len);
102
+ extern int gh_buf_sets(gh_buf *buf, const char *string);
103
+ extern int gh_buf_putc(gh_buf *buf, char c);
104
+ extern int gh_buf_put(gh_buf *buf, const void *data, size_t len);
105
+ extern int gh_buf_puts(gh_buf *buf, const char *string);
106
+ extern int gh_buf_printf(gh_buf *buf, const char *format, ...)
107
+ __attribute__((format (printf, 2, 3)));
108
+ extern int gh_buf_vprintf(gh_buf *buf, const char *format, va_list ap);
109
+ extern void gh_buf_clear(gh_buf *buf);
110
+
111
+ #define gh_buf_PUTS(buf, str) gh_buf_put(buf, str, sizeof(str) - 1)
112
+
113
+ #endif
data/ext/houdini/houdini.h ADDED
@@ -0,0 +1,44 @@
1
+ #ifndef __HOUDINI_H__
2
+ #define __HOUDINI_H__
3
+
4
+ #ifdef __cplusplus
5
+ extern "C" {
6
+ #endif
7
+
8
+ #include <stdint.h>
9
+ #include "buffer.h"
10
+
11
+ #define likely(x) __builtin_expect((x),1)
12
+ #define unlikely(x) __builtin_expect((x),0)
13
+
14
+ #ifdef HOUDINI_USE_LOCALE
15
+ # define _isxdigit(c) isxdigit(c)
16
+ # define _isdigit(c) isdigit(c)
17
+ #else
18
+ /*
19
+ * Helper _isdigit methods -- do not trust the current locale
20
+ * */
21
+ # define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL)
22
+ # define _isdigit(c) ((c) >= '0' && (c) <= '9')
23
+ #endif
24
+
25
+ #define HOUDINI_ESCAPED_SIZE(x) (((x) * 12) / 10)
26
+ #define HOUDINI_UNESCAPED_SIZE(x) (x)
27
+
28
+ extern int houdini_escape_html(gh_buf *ob, const uint8_t *src, size_t size);
29
+ extern int houdini_escape_html0(gh_buf *ob, const uint8_t *src, size_t size, int secure);
30
+ extern int houdini_unescape_html(gh_buf *ob, const uint8_t *src, size_t size);
31
+ extern int houdini_escape_xml(gh_buf *ob, const uint8_t *src, size_t size);
32
+ extern int houdini_escape_uri(gh_buf *ob, const uint8_t *src, size_t size);
33
+ extern int houdini_escape_url(gh_buf *ob, const uint8_t *src, size_t size);
34
+ extern int houdini_escape_href(gh_buf *ob, const uint8_t *src, size_t size);
35
+ extern int houdini_unescape_uri(gh_buf *ob, const uint8_t *src, size_t size);
36
+ extern int houdini_unescape_url(gh_buf *ob, const uint8_t *src, size_t size);
37
+ extern int houdini_escape_js(gh_buf *ob, const uint8_t *src, size_t size);
38
+ extern int houdini_unescape_js(gh_buf *ob, const uint8_t *src, size_t size);
39
+
40
+ #ifdef __cplusplus
41
+ }
42
+ #endif
43
+
44
+ #endif