basis/xml/data/data.factor

   1 ! Copyright (C) 2005, 2009 Daniel Ehrenberg
   2 ! See http://factorcode.org/license.txt for BSD license.
   3 USING: kernel sequences sequences.private assocs arrays
   4 delegate.protocols delegate vectors accessors multiline
   5 macros words quotations combinators slots fry strings ;
   6 IN: xml.data
   7
   8 TUPLE: interpolated var ;
   9 C: <interpolated> interpolated
  10
  11 UNION: nullable-string string POSTPONE: f ;
  12
  13 TUPLE: name
  14     { space nullable-string }
  15     { main string }
  16     { url nullable-string } ;
  17 C: <name> name
  18
  19 : ?= ( object/f object/f -- ? )
  20     2dup and [ = ] [ 2drop t ] if ;
  21
  22 : names-match? ( name1 name2 -- ? )
  23     [ [ space>> ] bi@ ?= ]
  24     [ [ url>> ] bi@ ?= ]
  25     [ [ main>> ] bi@ ?= ] 2tri and and ;
  26
  27 : <simple-name> ( string -- name )
  28     "" swap f <name> ;
  29
  30 : <null-name> ( string -- name )
  31     f swap f <name> ;
  32
  33 : assure-name ( string/name -- name )
  34     dup name? [ <null-name> ] unless ;
  35
  36 TUPLE: attrs { alist sequence } ;
  37 C: <attrs> attrs
  38
  39 : attr@ ( key alist -- index {key,value} )
  40     [ assure-name ] dip alist>>
  41     [ first names-match? ] with find ;
  42
  43 M: attrs at*
  44     attr@ nip [ second t ] [ f f ] if* ;
  45 M: attrs set-at
  46     2dup attr@ nip [
  47         2nip set-second
  48     ] [
  49         [ assure-name swap 2array ] dip
  50         [ alist>> ?push ] keep alist<<
  51     ] if* ;
  52
  53 M: attrs assoc-size alist>> length ;
  54 M: attrs new-assoc drop V{ } new-sequence <attrs> ;
  55 M: attrs >alist alist>> ;
  56
  57 : >attrs ( assoc -- attrs )
  58     dup [
  59         V{ } assoc-clone-like
  60         [ [ assure-name ] dip ] assoc-map
  61     ] when <attrs> ;
  62 M: attrs assoc-like
  63     drop dup attrs? [ >attrs ] unless ;
  64
  65 M: attrs clear-assoc
  66     f >>alist drop ;
  67 M: attrs delete-at
  68     [ nip ] [ attr@ drop ] 2bi
  69     [ swap alist>> remove-nth! drop ] [ drop ] if* ;
  70
  71 M: attrs clone
  72     alist>> clone <attrs> ;
  73
  74 INSTANCE: attrs assoc
  75
  76 TUPLE: opener { name name } { attrs attrs } ;
  77 C: <opener> opener
  78
  79 TUPLE: closer { name name } ;
  80 C: <closer> closer
  81
  82 TUPLE: contained { name name } { attrs attrs } ;
  83 C: <contained> contained
  84
  85 TUPLE: comment { text string } ;
  86 C: <comment> comment
  87
  88 TUPLE: directive ;
  89
  90 TUPLE: element-decl < directive
  91     { name string }
  92     { content-spec string } ;
  93 C: <element-decl> element-decl
  94
  95 TUPLE: attlist-decl < directive
  96     { name string }
  97     { att-defs string } ;
  98 C: <attlist-decl> attlist-decl
  99
 100 UNION: boolean t POSTPONE: f ;
 101
 102 TUPLE: entity-decl < directive
 103     { name string }
 104     { def string }
 105     { pe? boolean } ;
 106 C: <entity-decl> entity-decl
 107
 108 TUPLE: system-id { system-literal string } ;
 109 C: <system-id> system-id
 110
 111 TUPLE: public-id { pubid-literal string } { system-literal string } ;
 112 C: <public-id> public-id
 113
 114 UNION: id system-id public-id POSTPONE: f ;
 115
 116 TUPLE: dtd
 117     { directives sequence }
 118     { entities assoc }
 119     { parameter-entities assoc } ;
 120 C: <dtd> dtd
 121
 122 UNION: dtd/f dtd POSTPONE: f ;
 123
 124 TUPLE: doctype-decl < directive
 125     { name string }
 126     { external-id id }
 127     { internal-subset dtd/f } ;
 128 C: <doctype-decl> doctype-decl
 129
 130 TUPLE: notation-decl < directive
 131     { name string }
 132     { id string } ;
 133 C: <notation-decl> notation-decl
 134
 135 TUPLE: instruction { text string } ;
 136 C: <instruction> instruction
 137
 138 TUPLE: prolog
 139     { version string }
 140     { encoding string }
 141     { standalone boolean } ;
 142 C: <prolog> prolog
 143
 144 TUPLE: tag
 145     { name name }
 146     { attrs attrs }
 147     { children sequence } ;
 148
 149 : <tag> ( name attrs children -- tag )
 150     [ assure-name ] [ T{ attrs } assoc-like ] [ ] tri*
 151     tag boa ;
 152
 153 : attr ( tag/xml name -- string )
 154     swap attrs>> at ;
 155
 156 : set-attr ( tag/xml value name -- )
 157     rot attrs>> set-at ;
 158
 159 ! They also follow the sequence protocol (for children)
 160 CONSULT: sequence-protocol tag children>> ;
 161 INSTANCE: tag sequence
 162
 163 CONSULT: name tag name>> ;
 164
 165 M: tag like
 166     over tag? [ drop ] [
 167         [ name>> ] keep attrs>>
 168         rot dup [ V{ } like ] when <tag>
 169     ] if ;
 170
 171 MACRO: clone-slots ( class -- tuple )
 172     [
 173         "slots" word-prop
 174         [ name>> reader-word '[ _ execute clone ] ] map
 175         '[ _ cleave ]
 176     ] [ '[ _ boa ] ] bi compose ;
 177
 178 M: tag clone
 179     tag clone-slots ;
 180
 181 TUPLE: xml
 182     { prolog prolog }
 183     { before sequence }
 184     { body tag }
 185     { after sequence } ;
 186 C: <xml> xml
 187
 188 CONSULT: sequence-protocol xml body>> ;
 189 INSTANCE: xml sequence
 190
 191 CONSULT: tag xml body>> ;
 192
 193 CONSULT: name xml body>> ;
 194
 195 <PRIVATE
 196 : tag>xml ( xml tag -- newxml )
 197     [ [ prolog>> ] [ before>> ] [ after>> ] tri ] dip
 198     swap <xml> ;
 199
 200 : seq>xml ( xml seq -- newxml )
 201     over body>> like tag>xml ;
 202 PRIVATE>
 203
 204 M: xml clone
 205    xml clone-slots ;
 206
 207 M: xml like
 208     swap dup xml? [ nip ] [
 209         dup tag? [ tag>xml ] [ seq>xml ] if
 210     ] if ;
 211
 212 ! tag with children=f is contained
 213 : <contained-tag> ( name attrs -- tag )
 214     f <tag> ;
 215
 216 PREDICATE: contained-tag < tag children>> not ;
 217 PREDICATE: open-tag < tag children>> ;
 218
 219 TUPLE: unescaped string ;
 220 C: <unescaped> unescaped
 221
 222 UNION: xml-data
 223     tag comment string directive instruction unescaped ;
 224
 225 TUPLE: xml-chunk seq ;
 226 C: <xml-chunk> xml-chunk
 227
 228 CONSULT: sequence-protocol xml-chunk seq>> ;
 229 INSTANCE: xml-chunk sequence