papercraft 0.21 → 0.24
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/CHANGELOG.md +14 -0
- data/README.md +216 -102
- data/lib/papercraft/extension_proxy.rb +13 -2
- data/lib/papercraft/extensions/soap.rb +46 -0
- data/lib/papercraft/renderer.rb +9 -9
- data/lib/papercraft/tags.rb +35 -10
- data/lib/papercraft/version.rb +1 -1
- data/lib/papercraft.rb +0 -1
- metadata +3 -3
- data/lib/papercraft/encoding.rb +0 -26
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA256:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: f90c4ea6ac9d3090ae45d79f7f4a58668ccf7f8ae5d4dfa2a727b44a82699eb9
|
|
4
|
+
data.tar.gz: 10ff5bc3df10c10b0a968921517d2e0c18a61973dd97b88e95eef38670b9e451
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: '02461962ba174678a5b4a6ec550a8faa2f643fe87234e41513f7b49d798e3f3b2ade02adcfb0fa4961124a74484ddddea9437cb02eec98e9e897721729c0ef63'
|
|
7
|
+
data.tar.gz: f99728bb218382a040f67cbf2fd9652c33b3e0648efefbc695ceee708006758b6ec249748f3e3d41b065bf3b2fb28014b1ae61e02f7d3b01231e928f028e6ebd
|
data/CHANGELOG.md
CHANGED
|
@@ -1,3 +1,17 @@
|
|
|
1
|
+
## 0.24 2022-03-19
|
|
2
|
+
|
|
3
|
+
- Fix usage of const components (#13)
|
|
4
|
+
- Fix formatting of HTML/XML attributes for non-string values
|
|
5
|
+
|
|
6
|
+
## 0.23 2022-02-15
|
|
7
|
+
|
|
8
|
+
- Remove unused `Encoding` module
|
|
9
|
+
- Add SOAP extension (#11, thanks [@aemadrid](https://github.com/aemadrid))
|
|
10
|
+
|
|
11
|
+
## 0.22 2022-02-14
|
|
12
|
+
|
|
13
|
+
- Fix behaviour of call to `#p` in an extension (#10)
|
|
14
|
+
|
|
1
15
|
## 0.21 2022-02-13
|
|
2
16
|
|
|
3
17
|
- Refactor and improve documentation
|
data/README.md
CHANGED
|
@@ -42,6 +42,10 @@ Papercraft includes built-in support for rendering Markdown (using
|
|
|
42
42
|
creating template extensions in order to allow the creation of component
|
|
43
43
|
libraries.
|
|
44
44
|
|
|
45
|
+
Papercraft automatically escapes all text emitted in templates according to the
|
|
46
|
+
template type. For more information see the section on [escaping
|
|
47
|
+
content](#escaping-content).
|
|
48
|
+
|
|
45
49
|
```ruby
|
|
46
50
|
require 'papercraft'
|
|
47
51
|
|
|
@@ -59,27 +63,30 @@ hello.render('world')
|
|
|
59
63
|
#=> "<html><head><title>Title</title></head><body><h1>Hello, world!</h1></body></html>"
|
|
60
64
|
```
|
|
61
65
|
|
|
62
|
-
## Table of
|
|
63
|
-
|
|
64
|
-
- [Installing
|
|
65
|
-
- [Basic
|
|
66
|
-
- [Adding
|
|
67
|
-
- [
|
|
68
|
-
- [
|
|
69
|
-
- [Template
|
|
70
|
-
- [
|
|
71
|
-
- [Template
|
|
72
|
-
- [
|
|
73
|
-
- [
|
|
74
|
-
- [
|
|
75
|
-
- [
|
|
76
|
-
- [
|
|
66
|
+
## Table of Content
|
|
67
|
+
|
|
68
|
+
- [Installing Papercraft](#installing-papercraft)
|
|
69
|
+
- [Basic Usage](#basic-usage)
|
|
70
|
+
- [Adding Tags](#adding-tags)
|
|
71
|
+
- [Tag and Attribute Formatting](#tag-and-attribute-formatting)
|
|
72
|
+
- [Escaping Content](#escaping-content)
|
|
73
|
+
- [Template Parameters](#template-parameters)
|
|
74
|
+
- [Template Logic](#template-logic)
|
|
75
|
+
- [Template Blocks](#template-blocks)
|
|
76
|
+
- [Plain Procs as Templates](#plain-procs-as-templates)
|
|
77
|
+
- [Template Composition](#template-composition)
|
|
78
|
+
- [Parameter and Block Application](#parameter-and-block-application)
|
|
79
|
+
- [Higher-Order Templates](#higher-order-templates)
|
|
80
|
+
- [Layout Template Composition](#layout-template-composition)
|
|
81
|
+
- [Emitting Raw HTML](#emitting-raw-html)
|
|
82
|
+
- [Emitting a String with HTML Encoding](#emitting-a-string-with-html-encoding)
|
|
77
83
|
- [Emitting Markdown](#emitting-markdown)
|
|
78
|
-
- [Working with MIME
|
|
79
|
-
- [Deferred
|
|
80
|
-
- [
|
|
81
|
-
- [
|
|
82
|
-
- [
|
|
84
|
+
- [Working with MIME Types](#working-with-mime-types)
|
|
85
|
+
- [Deferred Evaluation](#deferred-evaluation)
|
|
86
|
+
- [XML Templates](#xml-templates)
|
|
87
|
+
- [JSON Templates](#json-templates)
|
|
88
|
+
- [Papercraft Extensions](#papercraft-extensions)
|
|
89
|
+
- [Bundled Extensions](#bundled-extensions)
|
|
83
90
|
- [API Reference](#api-reference)
|
|
84
91
|
|
|
85
92
|
## Installing Papercraft
|
|
@@ -96,7 +103,7 @@ Or manually:
|
|
|
96
103
|
$ gem install papercraft
|
|
97
104
|
```
|
|
98
105
|
|
|
99
|
-
## Basic
|
|
106
|
+
## Basic Usage
|
|
100
107
|
|
|
101
108
|
To create an HTML template use `Papercraft.html`:
|
|
102
109
|
|
|
@@ -117,7 +124,7 @@ Rendering a template is done using `#render`:
|
|
|
117
124
|
html.render #=> "<div id="greeter"><p>Hello!</p></div>"
|
|
118
125
|
```
|
|
119
126
|
|
|
120
|
-
## Adding
|
|
127
|
+
## Adding Tags
|
|
121
128
|
|
|
122
129
|
Tags are added using unqualified method calls, and can be nested using blocks:
|
|
123
130
|
|
|
@@ -154,7 +161,60 @@ Papercraft.html { img src: '/my.gif' }.render #=> "<img src="/my.gif"/>
|
|
|
154
161
|
Papercraft.html { p "foobar", class: 'important' }.render #=> "<p class=\"important\">foobar</p>"
|
|
155
162
|
```
|
|
156
163
|
|
|
157
|
-
##
|
|
164
|
+
## Tag and Attribute Formatting
|
|
165
|
+
|
|
166
|
+
Papercraft does not make any presumption about what tags and attributes you can
|
|
167
|
+
use. You can mix upper and lower case letters, and you can include arbitrary
|
|
168
|
+
characters in tag and attribute names. However, in order to best adhere to the
|
|
169
|
+
HTML and XML specs and common practices, tag names and attributes will be
|
|
170
|
+
formatted according to the following rules, depending on the template type:
|
|
171
|
+
|
|
172
|
+
- HTML: underscores are converted to dashes:
|
|
173
|
+
|
|
174
|
+
```ruby
|
|
175
|
+
Papercraft.html {
|
|
176
|
+
foo_bar { p 'Hello', data_name: 'world' }
|
|
177
|
+
}.render #=> '<foo-bar><p data-name="world">Hello</p></foo-bar>'
|
|
178
|
+
```
|
|
179
|
+
|
|
180
|
+
- XML: underscores are converted to dashes, double underscores are converted to
|
|
181
|
+
colons:
|
|
182
|
+
|
|
183
|
+
```ruby
|
|
184
|
+
Papercraft.xml {
|
|
185
|
+
soap__Envelope(
|
|
186
|
+
xmlns__soap: 'http://schemas.xmlsoap.org/soap/envelope/',
|
|
187
|
+
) { }
|
|
188
|
+
}.render #=> '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Envelope>'
|
|
189
|
+
```
|
|
190
|
+
|
|
191
|
+
If you need more precise control over tag names, you can use the `#tag` method,
|
|
192
|
+
which takes the tag name as its first parameter, then the rest of the parameters
|
|
193
|
+
normally used for tags:
|
|
194
|
+
|
|
195
|
+
```ruby
|
|
196
|
+
Papercraft.html {
|
|
197
|
+
tag 'cra_zy__:!tag', 'foo'
|
|
198
|
+
}.render #=> '<cra_zy__:!tag>foo</cra_zy__:!tag>'
|
|
199
|
+
```
|
|
200
|
+
|
|
201
|
+
## Escaping Content
|
|
202
|
+
|
|
203
|
+
Papercraft automatically escapes all text content emitted in a template. The
|
|
204
|
+
specific escaping algorithm depends on the template type. For both HTML and XML
|
|
205
|
+
templates, Papercraft uses
|
|
206
|
+
[escape_utils](https://github.com/brianmario/escape_utils), specifically:
|
|
207
|
+
|
|
208
|
+
- HTML: `escape_utils.escape_html`
|
|
209
|
+
- XML: `escape_utils.escape_xml`
|
|
210
|
+
|
|
211
|
+
In order to emit raw HTML/XML, you can use the `#emit` method as [described
|
|
212
|
+
below](#emitting-raw-html).
|
|
213
|
+
|
|
214
|
+
JSON templates are rendered using the `json` gem bundled with Ruby, which takes
|
|
215
|
+
care of escaping text values.
|
|
216
|
+
|
|
217
|
+
## Template Parameters
|
|
158
218
|
|
|
159
219
|
In Papercraft, parameters are always passed explicitly. This means that template
|
|
160
220
|
parameters are specified as block parameters, and are passed to the template on
|
|
@@ -172,7 +232,7 @@ greeting = Papercraft.html { |name:| h1 "Hello, #{name}!" }
|
|
|
172
232
|
greeting.render(name: 'world') #=> "<h1>Hello, world!</h1>"
|
|
173
233
|
```
|
|
174
234
|
|
|
175
|
-
## Template
|
|
235
|
+
## Template Logic
|
|
176
236
|
|
|
177
237
|
Since Papercraft templates are just a bunch of Ruby, you can easily write your
|
|
178
238
|
view logic right in the template:
|
|
@@ -187,7 +247,7 @@ Papercraft.html { |user = nil|
|
|
|
187
247
|
}
|
|
188
248
|
```
|
|
189
249
|
|
|
190
|
-
## Template
|
|
250
|
+
## Template Blocks
|
|
191
251
|
|
|
192
252
|
Templates can also accept and render blocks by using `emit_yield`:
|
|
193
253
|
|
|
@@ -202,7 +262,7 @@ page = Papercraft.html {
|
|
|
202
262
|
page.render { h1 'hi' }
|
|
203
263
|
```
|
|
204
264
|
|
|
205
|
-
## Plain
|
|
265
|
+
## Plain Procs as Templates
|
|
206
266
|
|
|
207
267
|
With Papercraft you can write a template as a plain Ruby proc, and later render
|
|
208
268
|
it by passing it as a block to `Papercraft.html`:
|
|
@@ -219,7 +279,7 @@ greeting = ->(name) { h1 "Hello, #{name}!" }
|
|
|
219
279
|
Papercraft.html(&greeting).render('world')
|
|
220
280
|
```
|
|
221
281
|
|
|
222
|
-
## Template
|
|
282
|
+
## Template Composition
|
|
223
283
|
|
|
224
284
|
Papercraft makes it easy to compose multiple templates into a whole HTML
|
|
225
285
|
document. A Papercraft template can contain other templates, as the following
|
|
@@ -269,7 +329,7 @@ Papercraft.html {
|
|
|
269
329
|
}
|
|
270
330
|
```
|
|
271
331
|
|
|
272
|
-
## Parameter and
|
|
332
|
+
## Parameter and Block Application
|
|
273
333
|
|
|
274
334
|
Parameters and blocks can be applied to a template without it being rendered, by
|
|
275
335
|
using `#apply`. This mechanism is what allows template composition and the
|
|
@@ -294,7 +354,7 @@ wrapped_hello_world = div_wrap.apply(&hello_world)
|
|
|
294
354
|
wrapped_hello_world.render #=> "<div><h1>Hello, world!</h1></div>"
|
|
295
355
|
```
|
|
296
356
|
|
|
297
|
-
## Higher-
|
|
357
|
+
## Higher-Order Templates
|
|
298
358
|
|
|
299
359
|
Papercraft also lets you create higher-order templates, that is,
|
|
300
360
|
templates that take other templates as parameters, or as blocks. Higher-order
|
|
@@ -318,7 +378,7 @@ wrapped_greeter = div_wrap.apply { h1 'hi' }
|
|
|
318
378
|
wrapped_greeter.render #=> "<div><h1>hi</h1></div>"
|
|
319
379
|
```
|
|
320
380
|
|
|
321
|
-
## Layout
|
|
381
|
+
## Layout Template Composition
|
|
322
382
|
|
|
323
383
|
One of the principal uses of higher-order templates is the creation of nested
|
|
324
384
|
layouts. Suppose we have a website with a number of different layouts, and we'd
|
|
@@ -351,7 +411,7 @@ article_layout.render(
|
|
|
351
411
|
)
|
|
352
412
|
```
|
|
353
413
|
|
|
354
|
-
## Emitting
|
|
414
|
+
## Emitting Raw HTML
|
|
355
415
|
|
|
356
416
|
Raw HTML can be emitted using `#emit`:
|
|
357
417
|
|
|
@@ -360,13 +420,13 @@ wrapped = Papercraft.html { |html| div { emit html } }
|
|
|
360
420
|
wrapped.render("<h1>hi</h1>") #=> "<div><h1>hi</h1></div>"
|
|
361
421
|
```
|
|
362
422
|
|
|
363
|
-
## Emitting a
|
|
423
|
+
## Emitting a String with HTML Encoding
|
|
364
424
|
|
|
365
425
|
To emit a string with proper HTML encoding, without wrapping it in an HTML
|
|
366
426
|
element, use `#text`:
|
|
367
427
|
|
|
368
428
|
```ruby
|
|
369
|
-
Papercraft.html {
|
|
429
|
+
Papercraft.html { text 'hi&lo' }.render #=> "hi&lo"
|
|
370
430
|
```
|
|
371
431
|
|
|
372
432
|
## Emitting Markdown
|
|
@@ -415,7 +475,7 @@ The deafult options can be configured by accessing
|
|
|
415
475
|
Papercraft.default_kramdown_options[:auto_ids] = false
|
|
416
476
|
```
|
|
417
477
|
|
|
418
|
-
## Working with MIME
|
|
478
|
+
## Working with MIME Types
|
|
419
479
|
|
|
420
480
|
Papercraft lets you set and interrogate a template's MIME type, in order to be
|
|
421
481
|
able to dynamically set the `Content-Type` HTTP response header. A template's
|
|
@@ -431,7 +491,7 @@ def serve_template(req, template)
|
|
|
431
491
|
end
|
|
432
492
|
```
|
|
433
493
|
|
|
434
|
-
## Deferred
|
|
494
|
+
## Deferred Evaluation
|
|
435
495
|
|
|
436
496
|
Deferred evaluation allows deferring the rendering of parts of a template until
|
|
437
497
|
the last moment, thus allowing an inner template to manipulate the state of the
|
|
@@ -483,7 +543,73 @@ page = default_layout.apply {
|
|
|
483
543
|
}
|
|
484
544
|
```
|
|
485
545
|
|
|
486
|
-
##
|
|
546
|
+
## XML Templates
|
|
547
|
+
|
|
548
|
+
XML templates behave largely the same as HTML templates, with a few minor
|
|
549
|
+
differences. XML templates employ a different encoding algorithm, and lack some
|
|
550
|
+
specific HTML functionality, such as emitting Markdown.
|
|
551
|
+
|
|
552
|
+
Here's an example showing how to create an RSS feed:
|
|
553
|
+
|
|
554
|
+
```ruby
|
|
555
|
+
rss = Papercraft.xml(mime_type: 'text/xml; charset=utf-8') { |resource:, **props|
|
|
556
|
+
rss(version: '2.0', 'xmlns:atom' => 'http://www.w3.org/2005/Atom') {
|
|
557
|
+
channel {
|
|
558
|
+
title 'Noteflakes'
|
|
559
|
+
link 'https://noteflakes.com/'
|
|
560
|
+
description 'A website by Sharon Rosner'
|
|
561
|
+
language 'en-us'
|
|
562
|
+
pubDate Time.now.httpdate
|
|
563
|
+
emit '<atom:link href="https://noteflakes.com/feeds/rss" rel="self" type="application/rss+xml" />'
|
|
564
|
+
|
|
565
|
+
article_entries = resource.page_list('/articles').reverse
|
|
566
|
+
|
|
567
|
+
article_entries.each { |e|
|
|
568
|
+
item {
|
|
569
|
+
title e[:title]
|
|
570
|
+
link "https://noteflakes.com#{e[:url]}"
|
|
571
|
+
guid "https://noteflakes.com#{e[:url]}"
|
|
572
|
+
pubDate e[:date].to_time.httpdate
|
|
573
|
+
description e[:html_content]
|
|
574
|
+
}
|
|
575
|
+
}
|
|
576
|
+
}
|
|
577
|
+
}
|
|
578
|
+
}
|
|
579
|
+
```
|
|
580
|
+
|
|
581
|
+
## JSON Templates
|
|
582
|
+
|
|
583
|
+
JSON templates behave largely the same as HTML and XML templates. The only major
|
|
584
|
+
difference is that for adding array items you'll need to use the `#item` method:
|
|
585
|
+
|
|
586
|
+
```ruby
|
|
587
|
+
Papercraft.json {
|
|
588
|
+
item 1
|
|
589
|
+
item 2
|
|
590
|
+
item 3
|
|
591
|
+
}.render #=> "[1,2,3]"
|
|
592
|
+
```
|
|
593
|
+
|
|
594
|
+
Otherwise, you can create arbitrarily complex JSON structures by mixing hashes
|
|
595
|
+
and arrays:
|
|
596
|
+
|
|
597
|
+
```Ruby
|
|
598
|
+
Papercraft.json {
|
|
599
|
+
foo {
|
|
600
|
+
bar {
|
|
601
|
+
item nil
|
|
602
|
+
item true
|
|
603
|
+
item 123.456
|
|
604
|
+
}
|
|
605
|
+
}
|
|
606
|
+
}.render #=> "{\"foo\":{\"bar\":[null,true,123.456]}}"
|
|
607
|
+
```
|
|
608
|
+
|
|
609
|
+
Papercraft uses the [JSON gem](https://rubyapi.org/3.1/o/json) under the hood in
|
|
610
|
+
order to generate actual JSON.
|
|
611
|
+
|
|
612
|
+
## Papercraft Extensions
|
|
487
613
|
|
|
488
614
|
Papercraft extensions are modules that contain one or more methods that can be
|
|
489
615
|
used to render complex HTML components. Extension modules can be used by
|
|
@@ -513,21 +639,27 @@ and other associated methods:
|
|
|
513
639
|
|
|
514
640
|
```ruby
|
|
515
641
|
module BootstrapComponents
|
|
516
|
-
|
|
517
|
-
|
|
518
|
-
def card(**props)
|
|
642
|
+
def card(**props, &block)
|
|
519
643
|
div(class: 'card', **props) {
|
|
520
|
-
div(class: 'card-body')
|
|
521
|
-
emit_yield
|
|
522
|
-
}
|
|
644
|
+
div(class: 'card-body', &block)
|
|
523
645
|
}
|
|
524
646
|
end
|
|
525
|
-
|
|
647
|
+
|
|
526
648
|
def card_title(title)
|
|
527
|
-
|
|
649
|
+
h4(title, class: 'card-title')
|
|
650
|
+
end
|
|
651
|
+
|
|
652
|
+
def card_subtitle(subtitle)
|
|
653
|
+
h5(subtitle, class: 'card-subtitle')
|
|
528
654
|
end
|
|
529
655
|
|
|
530
|
-
|
|
656
|
+
def card_text(text)
|
|
657
|
+
p(text, class: 'card-text')
|
|
658
|
+
end
|
|
659
|
+
|
|
660
|
+
def card_link(text, **opts)
|
|
661
|
+
a(text, class: 'card-link', **opts)
|
|
662
|
+
end
|
|
531
663
|
end
|
|
532
664
|
|
|
533
665
|
Papercraft.extension(bootstrap: BootstrapComponents)
|
|
@@ -543,81 +675,63 @@ Papercraft.html {
|
|
|
543
675
|
bootstrap.card_title 'Card title'
|
|
544
676
|
bootstrap.card_subtitle 'Card subtitle'
|
|
545
677
|
bootstrap.card_text 'Some quick example text to build on the card title and make up the bulk of the card''s content.'
|
|
546
|
-
bootstrap.card_link '
|
|
547
|
-
bootstrap.card_link '
|
|
678
|
+
bootstrap.card_link 'Card link', href: '#foo'
|
|
679
|
+
bootstrap.card_link 'Another link', href: '#bar'
|
|
548
680
|
}
|
|
549
681
|
}
|
|
550
682
|
```
|
|
551
683
|
|
|
684
|
+
## Bundled Extensions
|
|
552
685
|
|
|
686
|
+
Papercraft comes bundled with a few extensions that address common use cases.
|
|
687
|
+
All bundled extensions are namespaced under `Papercraft::Extensions`, and must
|
|
688
|
+
be specifically required in order to be available to templates.
|
|
553
689
|
|
|
554
|
-
|
|
690
|
+
For all bundled Papercraft extensions, there's no need to call
|
|
691
|
+
`Papercraft.extension`, requiring the extension is sufficient.
|
|
555
692
|
|
|
556
|
-
|
|
557
|
-
differences. XML templates employ a different encoding algorithm, and lack some
|
|
558
|
-
specific HTML functionality, such as emitting Markdown.
|
|
693
|
+
### SOAP Extension
|
|
559
694
|
|
|
560
|
-
|
|
695
|
+
> The SOAP extension was contributed by [@aemadrid](https://github.com/aemadrid).
|
|
561
696
|
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
channel {
|
|
566
|
-
title 'Noteflakes'
|
|
567
|
-
link 'https://noteflakes.com/'
|
|
568
|
-
description 'A website by Sharon Rosner'
|
|
569
|
-
language 'en-us'
|
|
570
|
-
pubDate Time.now.httpdate
|
|
571
|
-
emit '<atom:link href="https://noteflakes.com/feeds/rss" rel="self" type="application/rss+xml" />'
|
|
572
|
-
|
|
573
|
-
article_entries = resource.page_list('/articles').reverse
|
|
697
|
+
The SOAP extension provides common tags for building SOAP payloads. To load the
|
|
698
|
+
SOAP extensions, require `polyphony/extensions/soap`. The extension provides the
|
|
699
|
+
following methods:
|
|
574
700
|
|
|
575
|
-
|
|
576
|
-
|
|
577
|
-
|
|
578
|
-
|
|
579
|
-
guid "https://noteflakes.com#{e[:url]}"
|
|
580
|
-
pubDate e[:date].to_time.httpdate
|
|
581
|
-
description e[:html_content]
|
|
582
|
-
}
|
|
583
|
-
}
|
|
584
|
-
}
|
|
585
|
-
}
|
|
586
|
-
}
|
|
587
|
-
```
|
|
701
|
+
- `soap.Body(...)` - emits a `soap:Body` tag.
|
|
702
|
+
- `soap.Envelope(...)` - emits a `soap:Envelope` tag.
|
|
703
|
+
- `soap.Fault(...)` - emits a `soap:Fault` tag.
|
|
704
|
+
- `soap.Header(...)` - emits a `soap:Header` tag.
|
|
588
705
|
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
difference is that for adding array items you'll need to use the `#item` method:
|
|
706
|
+
As mentioned above, namespaced tags and attributes may be specified by using
|
|
707
|
+
double underscores for colons. Other tags that contain special characters may be
|
|
708
|
+
emitted using the `#tag` method:
|
|
593
709
|
|
|
594
710
|
```ruby
|
|
595
|
-
|
|
596
|
-
item 1
|
|
597
|
-
item 2
|
|
598
|
-
item 3
|
|
599
|
-
}.render #=> "[1,2,3]"
|
|
600
|
-
```
|
|
711
|
+
require 'polyphony/extensions/soap'
|
|
601
712
|
|
|
602
|
-
|
|
603
|
-
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
|
|
607
|
-
|
|
608
|
-
|
|
609
|
-
|
|
610
|
-
|
|
611
|
-
|
|
713
|
+
xml = Papercraft.xml {
|
|
714
|
+
soap.Envelope(
|
|
715
|
+
xmlns__xsd: 'http://www.w3.org/2001/XMLSchema',
|
|
716
|
+
xmlns__xsi: 'http://www.w3.org/2001/XMLSchema-instance'
|
|
717
|
+
) {
|
|
718
|
+
soap.Body {
|
|
719
|
+
PosRequest(xmlns: 'http://Some.Site') {
|
|
720
|
+
tag('Ver1.0') {
|
|
721
|
+
Header {
|
|
722
|
+
SecretAPIKey 'some_secret_key'
|
|
723
|
+
}
|
|
724
|
+
Transaction {
|
|
725
|
+
SomeData {}
|
|
726
|
+
}
|
|
727
|
+
}
|
|
728
|
+
}
|
|
612
729
|
}
|
|
613
730
|
}
|
|
614
|
-
}
|
|
731
|
+
}
|
|
615
732
|
```
|
|
616
733
|
|
|
617
|
-
Papercraft uses the [JSON gem](https://rubyapi.org/3.1/o/json) under the hood in
|
|
618
|
-
order to generate actual JSON.
|
|
619
|
-
|
|
620
734
|
## API Reference
|
|
621
735
|
|
|
622
736
|
The API reference for this library can be found
|
|
623
|
-
[here](https://www.rubydoc.info/gems/papercraft).
|
|
737
|
+
[here](https://www.rubydoc.info/gems/papercraft).
|
|
@@ -23,10 +23,21 @@ module Papercraft
|
|
|
23
23
|
#
|
|
24
24
|
# @param sym [Symbol] method name
|
|
25
25
|
# @param *args [Array] arguments
|
|
26
|
+
# @param *props [Array] named arguments
|
|
26
27
|
# @param &block [Proc] block
|
|
27
28
|
# @return void
|
|
28
|
-
def method_missing(sym, *args, &block)
|
|
29
|
-
@renderer.send(sym, *args, &block)
|
|
29
|
+
def method_missing(sym, *args, **props, &block)
|
|
30
|
+
@renderer.send(sym, *args, **props, &block)
|
|
31
|
+
end
|
|
32
|
+
|
|
33
|
+
# Overrides the `Kernel#p` method to emit a p tag.
|
|
34
|
+
#
|
|
35
|
+
# @param *args [Array] arguments
|
|
36
|
+
# @param *props [Array] named arguments
|
|
37
|
+
# @param &block [Proc] block
|
|
38
|
+
# @return void
|
|
39
|
+
def p(text = nil, **props, &block)
|
|
40
|
+
@renderer.p(text, **props, &block)
|
|
30
41
|
end
|
|
31
42
|
end
|
|
32
43
|
end
|
|
@@ -0,0 +1,46 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
module Papercraft
|
|
4
|
+
module Extensions
|
|
5
|
+
module Soap
|
|
6
|
+
# Emits a SOAP XML tag that identifies the XML document as a SOAP message.
|
|
7
|
+
#
|
|
8
|
+
# @param **props [Hash] tag attributes
|
|
9
|
+
# @param &block [Proc] optional inner XML
|
|
10
|
+
# @return [void]
|
|
11
|
+
def Envelope(**props, &block)
|
|
12
|
+
props[:xmlns__soap] ||= 'http://schemas.xmlsoap.org/soap/envelope/'
|
|
13
|
+
tag('soap:Envelope', **props, &block)
|
|
14
|
+
end
|
|
15
|
+
|
|
16
|
+
# Emits a SOAP XML tag that contains header information.
|
|
17
|
+
#
|
|
18
|
+
# @param **props [Hash] tag attributes
|
|
19
|
+
# @param &block [Proc] optional inner XML
|
|
20
|
+
# @return [void]
|
|
21
|
+
def Header(**props, &blk)
|
|
22
|
+
tag('soap:Header', **props, &blk)
|
|
23
|
+
end
|
|
24
|
+
|
|
25
|
+
# Emits a SOAP XML tag that contains header information.
|
|
26
|
+
#
|
|
27
|
+
# @param **props [Hash] tag attributes
|
|
28
|
+
# @param &block [Proc] optional inner XML
|
|
29
|
+
# @return [void]
|
|
30
|
+
def Body(**props, &blk)
|
|
31
|
+
tag('soap:Body', **props, &blk)
|
|
32
|
+
end
|
|
33
|
+
|
|
34
|
+
# Emits a SOAP XML tag that contains errors and status information.
|
|
35
|
+
#
|
|
36
|
+
# @param **props [Hash] tag attributes
|
|
37
|
+
# @param &block [Proc] optional inner XML
|
|
38
|
+
# @return [void]
|
|
39
|
+
def Fault(**props, &blk)
|
|
40
|
+
tag('soap:Fault', **props, &blk)
|
|
41
|
+
end
|
|
42
|
+
end
|
|
43
|
+
end
|
|
44
|
+
end
|
|
45
|
+
|
|
46
|
+
Papercraft.extension(soap: Papercraft::Extensions::Soap)
|
data/lib/papercraft/renderer.rb
CHANGED
|
@@ -47,17 +47,17 @@ module Papercraft
|
|
|
47
47
|
# components. In cases where method names in the module clash with XML
|
|
48
48
|
# tag names, you can use the `#tag` method to emit the relevant tag.
|
|
49
49
|
#
|
|
50
|
-
#
|
|
51
|
-
#
|
|
52
|
-
#
|
|
53
|
-
#
|
|
54
|
-
#
|
|
55
|
-
#
|
|
50
|
+
# module ComponentLibrary
|
|
51
|
+
# def card(title, content)
|
|
52
|
+
# div(class: 'card') {
|
|
53
|
+
# h3 title
|
|
54
|
+
# div(class: 'card-content') { emit_markdown content }
|
|
55
|
+
# }
|
|
56
|
+
# end
|
|
56
57
|
# end
|
|
57
|
-
# end
|
|
58
58
|
#
|
|
59
|
-
#
|
|
60
|
-
#
|
|
59
|
+
# Papercraft.extension(components: ComponentLibrary)
|
|
60
|
+
# Papercraft.html { components.card('Foo', '**Bar**') }
|
|
61
61
|
#
|
|
62
62
|
# @param map [Hash] hash mapping methods to extension modules
|
|
63
63
|
# @return [void]
|
data/lib/papercraft/tags.rb
CHANGED
|
@@ -160,16 +160,14 @@ module Papercraft
|
|
|
160
160
|
# @param &block [Proc] block passed to method
|
|
161
161
|
# @return [void]
|
|
162
162
|
def method_missing(sym, *args, **opts, &block)
|
|
163
|
-
# p method_missing: sym, self: self
|
|
164
163
|
tag = sym.to_s
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
self.class.class_eval(code, __FILE__, S_TAG_METHOD_LINE)
|
|
164
|
+
if tag =~ /^[A-Z]/ && (Object.const_defined?(tag))
|
|
165
|
+
define_const_tag_method(tag)
|
|
166
|
+
# return send(tag, *args, **opts)
|
|
167
|
+
else
|
|
168
|
+
define_tag_method(tag)
|
|
169
|
+
end
|
|
170
|
+
|
|
173
171
|
send(sym, *args, **opts, &block)
|
|
174
172
|
end
|
|
175
173
|
|
|
@@ -184,6 +182,33 @@ module Papercraft
|
|
|
184
182
|
|
|
185
183
|
private
|
|
186
184
|
|
|
185
|
+
# Defines a method that emits the given tag based on a constant. The
|
|
186
|
+
# constant must be defined on the main (Object) binding.
|
|
187
|
+
#
|
|
188
|
+
# @param tag [Symbol, String] tag/method name
|
|
189
|
+
# @return [void]
|
|
190
|
+
def define_const_tag_method(tag)
|
|
191
|
+
const = Object.const_get(tag)
|
|
192
|
+
self.class.define_method(tag) { |*a, **b, &blk|
|
|
193
|
+
emit const, *a, **b, &blk
|
|
194
|
+
}
|
|
195
|
+
end
|
|
196
|
+
|
|
197
|
+
# Defines a normal tag method.
|
|
198
|
+
#
|
|
199
|
+
# @param tag [Symbol, String] tag/method name
|
|
200
|
+
# @return [void]
|
|
201
|
+
def define_tag_method(tag)
|
|
202
|
+
repr = tag_repr(tag)
|
|
203
|
+
code = S_TAG_METHOD % {
|
|
204
|
+
tag: tag,
|
|
205
|
+
TAG: tag.upcase,
|
|
206
|
+
tag_pre: "<#{repr}".inspect,
|
|
207
|
+
tag_close: "</#{repr}>".inspect
|
|
208
|
+
}
|
|
209
|
+
self.class.class_eval(code, __FILE__, S_TAG_METHOD_LINE)
|
|
210
|
+
end
|
|
211
|
+
|
|
187
212
|
# Emits an arbitrary object by converting it to string, then adding it to
|
|
188
213
|
# the internal buffer. This method is called internally by `Renderer#emit`.
|
|
189
214
|
#
|
|
@@ -252,7 +277,7 @@ module Papercraft
|
|
|
252
277
|
# emit nothing
|
|
253
278
|
else
|
|
254
279
|
@buffer << S_SPACE << att_repr(k) <<
|
|
255
|
-
S_EQUAL_QUOTE << v << S_QUOTE
|
|
280
|
+
S_EQUAL_QUOTE << escape_text(v) << S_QUOTE
|
|
256
281
|
end
|
|
257
282
|
end
|
|
258
283
|
}
|
data/lib/papercraft/version.rb
CHANGED
data/lib/papercraft.rb
CHANGED
metadata
CHANGED
|
@@ -1,14 +1,14 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: papercraft
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: '0.
|
|
4
|
+
version: '0.24'
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Sharon Rosner
|
|
8
8
|
autorequire:
|
|
9
9
|
bindir: bin
|
|
10
10
|
cert_chain: []
|
|
11
|
-
date: 2022-
|
|
11
|
+
date: 2022-03-19 00:00:00.000000000 Z
|
|
12
12
|
dependencies:
|
|
13
13
|
- !ruby/object:Gem::Dependency
|
|
14
14
|
name: escape_utils
|
|
@@ -134,8 +134,8 @@ files:
|
|
|
134
134
|
- README.md
|
|
135
135
|
- lib/papercraft.rb
|
|
136
136
|
- lib/papercraft/compiler.rb
|
|
137
|
-
- lib/papercraft/encoding.rb
|
|
138
137
|
- lib/papercraft/extension_proxy.rb
|
|
138
|
+
- lib/papercraft/extensions/soap.rb
|
|
139
139
|
- lib/papercraft/html.rb
|
|
140
140
|
- lib/papercraft/json.rb
|
|
141
141
|
- lib/papercraft/renderer.rb
|
data/lib/papercraft/encoding.rb
DELETED
|
@@ -1,26 +0,0 @@
|
|
|
1
|
-
# frozen_string_literal: true
|
|
2
|
-
|
|
3
|
-
module Papercraft
|
|
4
|
-
# Papercraft::Encoding includes common encoding methods
|
|
5
|
-
module Encoding
|
|
6
|
-
# Encodes the given string to safe HTML text, converting special characters
|
|
7
|
-
# into the respective HTML entities. If a non-string value is given, it is
|
|
8
|
-
# converted to `String` using `#to_s`.
|
|
9
|
-
#
|
|
10
|
-
# @param text [String] string to be encoded
|
|
11
|
-
# @return [String] HTML-encoded string
|
|
12
|
-
def __html_encode__(text)
|
|
13
|
-
EscapeUtils.escape_html(text.to_s)
|
|
14
|
-
end
|
|
15
|
-
|
|
16
|
-
# Encodes the given string to safe URI component, converting special
|
|
17
|
-
# characters to URI entities. If a non-string value is given, it is
|
|
18
|
-
# converted to `String` using `#to_s`.
|
|
19
|
-
#
|
|
20
|
-
# @param text [String] string to be encoded
|
|
21
|
-
# @return [String] URI-encoded string
|
|
22
|
-
def __uri_encode__(text)
|
|
23
|
-
EscapeUtils.escape_uri(text.to_s)
|
|
24
|
-
end
|
|
25
|
-
end
|
|
26
|
-
end
|