jeremy-RedCloth 4.1.1

data/ext/redcloth_scan/redcloth_attributes.java.rl

@@ -0,0 +1,96 @@
+/*
+ * redcloth_attributes.rl
+ *
+ * Copyright (C) 2008 Jason Garber
+ */
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyHash;
+import org.jruby.RubyModule;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.CallbackFactory;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import org.jruby.util.ByteList;
+
+public class RedclothAttributes extends RedclothScanService.Base {
+
+%%{
+
+  machine redcloth_attributes;
+  include redcloth_common "redcloth_common.java.rl";
+  include redcloth_attributes "redcloth_attributes.rl";
+
+}%%
+
+%% write data nofinal;
+
+  public void SET_ATTRIBUTES() {
+    SET_ATTRIBUTE("class_buf", "class");
+    SET_ATTRIBUTE("id_buf", "id");
+    SET_ATTRIBUTE("lang_buf", "lang");
+    SET_ATTRIBUTE("style_buf", "style");
+  }
+
+  public void SET_ATTRIBUTE(String B, String A) {
+    buf = ((RubyHash)regs).aref(runtime.newSymbol(B));
+    if(!buf.isNil()) {
+      ((RubyHash)regs).aset(runtime.newSymbol(A), buf);
+    }
+  }
+ 
+  private int machine;
+  private IRubyObject buf;
+   
+  public RedclothAttributes(int machine, IRubyObject self, byte[] data, int p, int pe) {
+    this.runtime = self.getRuntime();
+    this.self = self;
+
+    // This is GROSS but necessary for EOF matching
+    this.data = new byte[pe+1];
+    System.arraycopy(data, p, this.data, 0, pe);
+    this.data[pe] = 0;
+
+    this.p = 0;
+    this.pe = pe+1;
+    this.eof = this.pe;
+    this.orig_p = 0;
+    this.orig_pe = this.pe;
+
+    this.regs = RubyHash.newHash(runtime);
+    this.buf = runtime.getNil();
+    this.machine = machine;
+  }
+
+  public IRubyObject parse() {
+    %% write init;
+  
+    cs = machine;
+
+    %% write exec;
+
+    return regs;
+  }
+
+  public static IRubyObject attributes(IRubyObject self, IRubyObject str) {
+    ByteList bl = str.convertToString().getByteList();
+    int cs = redcloth_attributes_en_inline;
+    return new RedclothAttributes(cs, self, bl.bytes, bl.begin, bl.realSize).parse();
+  }
+
+  public static IRubyObject link_attributes(IRubyObject self, IRubyObject str) {
+    ByteList bl = str.convertToString().getByteList();
+    int cs = redcloth_attributes_en_link_says;
+    return new RedclothAttributes(cs, self, bl.bytes, bl.begin, bl.realSize).parse();
+  }
+}

data/ext/redcloth_scan/redcloth_attributes.rl

@@ -0,0 +1,33 @@
+/*
+ * redcloth_attributes.rl
+ *
+ * Copyright (C) 2008 Jason Garber
+ */
+%%{
+
+  machine redcloth_attributes;
+  
+  C2_CLAS = ( "(" ( [^)#]+ >A %{ STORE("class_buf"); } )? ("#" [^)]+ >A %{STORE("id_buf");} )? ")" ) ;
+  C2_LNGE = ( "[" [^\[\]]+ >A %{ STORE("lang_buf"); } "]" ) ;
+  C2_STYL = ( "{" [^}]+ >A %{ STORE("style_buf"); } "}" ) ;
+  C2 = ( C2_CLAS | C2_STYL | C2_LNGE )+ ;
+
+  mtext_with_attributes = ( C2 mtext >A %T ) >X ;
+
+  inline := |*
+
+    mtext_with_attributes { SET_ATTRIBUTES(); } ;
+
+  *|;
+
+  link_text_with_attributes = C2 "."* " "* ( mtext+ ) >A %{ STORE("name"); } ;
+  link_text_without_attributes = ( mtext+ ) >B %{ STORE_B("name_without_attributes"); } ;
+
+  link_says := |*
+
+    link_text_with_attributes { SET_ATTRIBUTES(); } ;
+    link_text_without_attributes { SET_ATTRIBUTE("name_without_attributes", "name"); } ;
+
+  *|;
+
+}%%;

data/ext/redcloth_scan/redcloth_common.c.rl

@@ -0,0 +1,18 @@
+%%{
+  
+  machine redcloth_common;
+  include redcloth_common "redcloth_common.rl";
+  
+  action esc { rb_str_cat_escaped(self, block, ts, te); }
+  action esc_pre { rb_str_cat_escaped_for_preformatted(self, block, ts, te); }
+  action ignore { rb_str_append(block, rb_funcall(self, rb_intern("ignore"), 1, regs)); }
+  
+  # conditionals
+  action starts_line {
+    p == orig_p || *(p-1) == '\r' || *(p-1) == '\n' || *(p-1) == '\f'
+  }
+  action starts_phrase {
+    p == orig_p || *(p-1) == '\r' || *(p-1) == '\n' || *(p-1) == '\f' || *(p-1) == ' '
+  }
+  
+}%%;

data/ext/redcloth_scan/redcloth_common.java.rl

@@ -0,0 +1,18 @@
+%%{
+
+  machine redcloth_common;
+  include redcloth_common "redcloth_common.rl";
+
+  action esc { strCatEscaped(self, block, data, ts, te); }
+  action esc_pre { strCatEscapedForPreformatted(self, block, data, ts, te); }
+  action ignore { ((RubyString)block).append(self.callMethod(runtime.getCurrentContext(), "ignore", regs)); }
+  
+  # conditionals
+  action starts_line {
+    p == orig_p || data[(p-1)] == '\r' || data[(p-1)] == '\n' || data[(p-1)] == '\f'
+  }
+  action starts_phrase {
+    p == orig_p || data[(p-1)] == '\r' || data[(p-1)] == '\n' || data[(p-1)] == '\f' || data[(p-1)] == ' '
+  }
+
+}%%;

data/ext/redcloth_scan/redcloth_common.rl

@@ -0,0 +1,111 @@
+%%{
+
+  machine redcloth_common;
+
+  action A { reg = p; }
+  action B { bck = p; }
+  action T { STORE("text"); }
+  action X { CLEAR_REGS(); RESET_REG(); }
+  action cat { CAT(block); }
+
+  # simple
+  LF = ( '\n' ) ;
+  default = ^0 ;
+  EOF = 0 ;
+
+  # textile modifiers
+  A_LEFT = "<" %{ ASET("align", "left"); } ;
+  A_RIGHT = ">" %{ ASET("align", "right"); } ;
+  A_JUSTIFIED = "<>" %{ ASET("align", "justify"); } ;
+  A_CENTER = "=" %{ ASET("align", "center"); } ;
+  A_PADLEFT = "(" >A %{ AINC("padding-left"); } ;
+  A_PADRIGHT = ")" >A %{ AINC("padding-right"); } ;
+  A_HLGN = ( A_LEFT | A_RIGHT | A_JUSTIFIED | A_CENTER | A_PADLEFT | A_PADRIGHT ) ;
+  A_LIMIT = ( A_LEFT | A_CENTER | A_RIGHT ) ;
+  A_VLGN = ( "-" %{ ASET("vertical-align", "middle"); } | "^" %{ ASET("vertical-align", "top"); } | "~" %{ ASET("vertical-align", "bottom"); } ) ;
+  C_CLAS = ( "(" ( [^)#]+ >A %{ STORE("class"); } )? ("#" [^)]+ >A %{STORE("id");} )? ")" ) ;
+  C_LNGE = ( "[" [^\]]+ >A %{ STORE("lang"); } "]" ) ;
+  C_STYL = ( "{" [^}]+ >A %{ STORE("style"); } "}" ) ;
+  S_CSPN = ( "\\" [0-9]+ >A %{ STORE("colspan"); } ) ;
+  S_RSPN = ( "/" [0-9]+ >A %{ STORE("rowspan"); } ) ;
+  D_HEADER = "_" %{ ASET("th", "true"); } ;
+  A = ( ( A_HLGN | A_VLGN )* ) ;
+  A2 = ( A_LIMIT? ) ;
+  S = ( S_CSPN | S_RSPN )* ;
+  C = ( C_CLAS | C_STYL | C_LNGE )* ;
+  D = ( D_HEADER ) ;
+  N_CONT = "_" %{ list_continue = 1; };
+  N_NUM = digit+ >A %{ STORE("start"); };
+  N = ( N_CONT | N_NUM )? ;
+  PUNCT = ( "!" | '"' | "#" | "$" | "%" | "&" | "'" | "," | "-" | "." | "/" | ":" | ";" | "=" | "?" | "\\" | "^" | "`" | "|" | "~" | "[" | "]" | "(" | ")" | "<" ) ;
+  dotspace = ("." " "*) ;
+  indent =  [ \t]* ;
+  
+  # very un-DRY; Adrian says an action-stripping macro will come in a future Ragel version
+  A_LEFT_noactions = "<" ;
+  A_RIGHT_noactions = ">" ;
+  A_JUSTIFIED_noactions = "<>" ;
+  A_CENTER_noactions = "=" ;
+  A_PADLEFT_noactions = "(" ;
+  A_PADRIGHT_noactions = ")"  ;
+  A_HLGN_noactions = ( A_LEFT_noactions | A_RIGHT_noactions | A_JUSTIFIED_noactions | A_CENTER_noactions | A_PADLEFT_noactions | A_PADRIGHT_noactions ) ;
+  A_VLGN_noactions = ( "-" | "^" | "~" ) ;
+  C_CLAS_noactions = ( "(" ( [^)#]+ )? ("#" [^)]+ )? ")" ) ;
+  C_LNGE_noactions = ( "[" [^\]]+ "]" ) ;
+  C_STYL_noactions = ( "{" [^}]+ "}" ) ;
+  A_noactions = ( ( A_HLGN_noactions | A_VLGN_noactions )* ) ;
+  C_noactions = ( C_CLAS_noactions | C_STYL_noactions | C_LNGE_noactions )* ;
+  C_noquotes_noactions = C_noactions -- '"' ;
+
+  # text blocks
+  trailing = PUNCT - ("'" | '"') ;
+  chars = (default - space)+ ;
+  phrase = chars -- trailing ;
+
+  # html tags (from Hpricot)
+  NameChar = [\-A-Za-z0-9._:?] ;
+  Name = [A-Za-z_:] NameChar* ;
+  NameAttr = NameChar+ ;
+  Q1Attr = [^']* ;
+  Q2Attr = [^"]* ;
+  UnqAttr = ( space | [^ \t\r\n<>"'] [^ \t\r\n<>]* ) ;
+  Nmtoken = NameChar+ ;
+  Attr =  NameAttr space* "=" space* ('"' Q2Attr '"' | "'" Q1Attr "'" | UnqAttr space+ ) space* ;
+  AttrEnd = ( NameAttr space* "=" space* UnqAttr? | Nmtoken ) ;
+  AttrSet = ( Attr | Nmtoken space+ ) ;
+  
+  script_tag_start = ( "<script" [^>]* ">" ) >X >A %T ;
+  script_tag_end = ( "</script>" >A %T LF? ) >X ;
+  
+
+  # URI tokens (lifted from Mongrel)
+  CTL = (cntrl | 127);
+  safe = ("$" | "-" | "_" | ".");
+  extra = ("!" | "*" | "'" | "(" | ")" | "," | "#");
+  reserved = (";" | "/" | "?" | ":" | "@" | "&" | "=" | "+");
+  unsafe = (CTL | " " | "\"" | "%" | "<" | ">");
+  national = any -- (alpha | digit | reserved | extra | safe | unsafe);
+  unreserved = (alpha | digit | safe | extra | national);
+  escape = ("%" xdigit xdigit);
+  uchar = (unreserved | escape);
+  pchar = (uchar | ":" | "@" | "&" | "=" | "+");
+  scheme = ( alpha | digit | "+" | "-" | "." )+ ;
+  absolute_uri = (scheme ":" (uchar | reserved )*);
+  safepath = (pchar* (alpha | digit | safe) pchar*) ;
+  path = (safepath ( "/" pchar* )*) ;
+  query = ( uchar | reserved )* ;
+  param = ( pchar | "/" )* ;
+  params = (param ( ";" param )*) ;
+  rel_path = (path (";" params)?) ("?" query)?;
+  absolute_path = ("/"+ rel_path?);
+  target = ("#" pchar*) ;
+  uri = (target | absolute_uri | absolute_path | rel_path) ;
+
+  # common
+  title = ( '(' default+ >A %{ STORE("title"); } :> ')' ) ;
+  word = ( alnum | safe | " " ) ;
+  mspace = ( ( " " | "\t" | LF )+ ) -- LF{2} ;
+  mtext = ( chars (mspace chars)* ) ;
+  
+
+}%%;

data/ext/redcloth_scan/redcloth_inline.c.rl

@@ -0,0 +1,159 @@
+/*
+ * redcloth_inline.c.rl
+ *
+ * Copyright (C) 2008 Jason Garber
+ */
+#include <ruby.h>
+#include "redcloth.h"
+
+%%{
+
+  machine redcloth_inline;
+  include redcloth_common "redcloth_common.c.rl";
+  include redcloth_inline "redcloth_inline.rl";
+
+}%%
+
+%% write data nofinal;
+
+VALUE
+red_pass(VALUE self, VALUE regs, VALUE ref, ID meth, VALUE refs)
+{
+  VALUE txt = rb_hash_aref(regs, ref);
+  if (!NIL_P(txt)) rb_hash_aset(regs, ref, redcloth_inline2(self, txt, refs));
+  return rb_funcall(self, meth, 1, regs);
+}
+
+VALUE
+red_parse_attr(VALUE self, VALUE regs, VALUE ref)
+{
+  VALUE txt = rb_hash_aref(regs, ref);
+  VALUE new_regs = redcloth_attributes(self, txt);
+  return rb_funcall(regs, rb_intern("update"), 1, new_regs);
+}
+
+VALUE
+red_parse_link_attr(VALUE self, VALUE regs, VALUE ref)
+{
+  VALUE txt = rb_hash_aref(regs, ref);
+  VALUE new_regs = redcloth_link_attributes(self, txt);
+  return rb_funcall(regs, rb_intern("update"), 1, new_regs);
+}
+
+VALUE
+red_pass_code(VALUE self, VALUE regs, VALUE ref, ID meth)
+{
+  VALUE txt = rb_hash_aref(regs, ref);
+  if (!NIL_P(txt)) {
+    VALUE txt2 = rb_str_new2("");
+    rb_str_cat_escaped_for_preformatted(self, txt2, RSTRING_PTR(txt), RSTRING_PTR(txt) + RSTRING_LEN(txt));
+    rb_hash_aset(regs, ref, txt2);
+  }
+  return rb_funcall(self, meth, 1, regs);
+}
+
+VALUE
+red_block(VALUE self, VALUE regs, VALUE block, VALUE refs)
+{
+  ID method;
+  VALUE fallback;
+  VALUE sym_text = ID2SYM(rb_intern("text"));
+  VALUE btype = rb_hash_aref(regs, ID2SYM(rb_intern("type")));
+  block = rb_funcall(block, rb_intern("strip"), 0);
+  if ((!NIL_P(block)) && !NIL_P(btype))
+  {
+    method = rb_intern(RSTRING_PTR(btype));
+    if (method == rb_intern("notextile")) {
+      rb_hash_aset(regs, sym_text, block);
+    } else {
+      rb_hash_aset(regs, sym_text, redcloth_inline2(self, block, refs));
+    }
+    if (rb_ary_includes(rb_iv_get(self, "@custom_tags"), btype)) {
+      block = rb_funcall(self, method, 1, regs);
+    } else {
+      fallback = rb_hash_aref(regs, ID2SYM(rb_intern("fallback")));
+      if (!NIL_P(fallback)) {
+        rb_str_append(fallback, rb_hash_aref(regs, sym_text));
+        CLEAR_REGS();
+        rb_hash_aset(regs, sym_text, fallback);
+      }
+      block = rb_funcall(self, rb_intern("p"), 1, regs);
+    }
+  }
+  return block;
+}
+
+VALUE
+red_blockcode(VALUE self, VALUE regs, VALUE block)
+{
+  VALUE btype = rb_hash_aref(regs, ID2SYM(rb_intern("type")));
+  if (RSTRING_LEN(block) > 0)
+  {
+    rb_hash_aset(regs, ID2SYM(rb_intern("text")), block);
+    block = rb_funcall(self, rb_intern(RSTRING_PTR(btype)), 1, regs);
+  }
+  return block;
+}
+
+void
+red_inc(VALUE regs, VALUE ref)
+{
+  int aint = 0;
+  VALUE aval = rb_hash_aref(regs, ref);
+  if (aval != Qnil) aint = NUM2INT(aval);
+  rb_hash_aset(regs, ref, INT2NUM(aint + 1));
+}
+
+VALUE
+redcloth_inline(self, p, pe, refs)
+  VALUE self;
+  char *p, *pe;
+  VALUE refs;
+{
+  int cs, act;
+  char *ts, *te, *reg, *eof;
+  char *orig_p = p, *orig_pe = pe;
+  VALUE block = rb_str_new2("");
+  VALUE regs = Qnil;
+  unsigned int opts = 0;
+  VALUE buf = Qnil;
+  
+  %% write init;
+
+  %% write exec;
+
+  return block;
+}
+
+/** Append characters to a string, escaping (&, <, >, ", ') using the formatter's escape method.
+  * @param str ruby string
+  * @param ts  start of character buffer to append
+  * @param te  end of character buffer
+  */
+void
+rb_str_cat_escaped(self, str, ts, te)
+  VALUE self, str;
+  char *ts, *te;
+{
+  VALUE source_str = rb_str_new(ts, te-ts);
+  VALUE escaped_str = rb_funcall(self, rb_intern("escape"), 1, source_str);
+  rb_str_concat(str, escaped_str);
+}
+
+void
+rb_str_cat_escaped_for_preformatted(self, str, ts, te)
+  VALUE self, str;
+  char *ts, *te;
+{
+  VALUE source_str = rb_str_new(ts, te-ts);
+  VALUE escaped_str = rb_funcall(self, rb_intern("escape_pre"), 1, source_str);
+  rb_str_concat(str, escaped_str);
+}
+
+VALUE
+redcloth_inline2(self, str, refs)
+  VALUE self, str, refs;
+{
+  StringValue(str);
+  return redcloth_inline(self, RSTRING_PTR(str), RSTRING_PTR(str) + RSTRING_LEN(str) + 1, refs);
+}

data/ext/redcloth_scan/redcloth_inline.java.rl

@@ -0,0 +1,108 @@
+/*
+ * redcloth_inline.rl
+ *
+ * Copyright (C) 2008 Jason Garber
+ */
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyHash;
+import org.jruby.RubyModule;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.CallbackFactory;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import org.jruby.util.ByteList;
+
+public class RedclothInline extends RedclothScanService.Base {
+
+%%{
+
+  machine redcloth_inline;
+  include redcloth_common "redcloth_common.java.rl";
+  include redcloth_inline "redcloth_inline.rl";
+
+}%%
+
+%% write data nofinal;
+
+  public IRubyObject red_pass_code(IRubyObject self, IRubyObject regs, IRubyObject ref, String meth) {
+    IRubyObject txt = ((RubyHash)regs).aref(ref);
+    if(!txt.isNil()) {
+      IRubyObject txt2 = RubyString.newEmptyString(runtime);
+      strCatEscapedForPreformatted(self, txt2, ((RubyString)txt).getByteList().bytes, ((RubyString)txt).getByteList().begin, ((RubyString)txt).getByteList().begin + ((RubyString)txt).getByteList().realSize);
+      ((RubyHash)regs).aset(ref, txt2);
+    }
+    return self.callMethod(runtime.getCurrentContext(), meth, regs);
+  }
+
+  public IRubyObject red_parse_attr(IRubyObject self, IRubyObject regs, IRubyObject ref) {
+    IRubyObject txt = ((RubyHash)regs).aref(ref);
+    IRubyObject new_regs = RedclothAttributes.attributes(self, txt);
+    return regs.callMethod(runtime.getCurrentContext(), "update", new_regs);
+  }
+
+  public IRubyObject red_parse_link_attr(IRubyObject self, IRubyObject regs, IRubyObject ref) {
+    IRubyObject txt = ((RubyHash)regs).aref(ref);
+    IRubyObject new_regs = RedclothAttributes.link_attributes(self, txt);
+    return regs.callMethod(runtime.getCurrentContext(), "update", new_regs);
+  }
+
+  public void PASS_CODE(IRubyObject H, String A, String T, int O) {
+    ((RubyString)H).append(red_pass_code(self, regs, runtime.newSymbol(A), T));
+  }
+
+  public void PARSE_ATTR(String A) {
+    red_parse_attr(self, regs, runtime.newSymbol(A));
+  }
+
+  public void PARSE_LINK_ATTR(String A) {
+    red_parse_link_attr(self, regs, runtime.newSymbol(A));
+  }
+
+  private int opts;
+  private IRubyObject buf;
+
+  public RedclothInline(IRubyObject self, byte[] data, int p, int pe, IRubyObject refs) {
+    this.runtime = self.getRuntime();
+    this.self = self;
+    
+    // This is GROSS but necessary for EOF matching
+    this.data = new byte[pe+1];
+    System.arraycopy(data, p, this.data, 0, pe);
+    this.data[pe] = 0;
+
+    this.p = 0;
+    this.pe = pe+1;
+    this.eof = this.pe;
+    this.orig_p = 0;
+    this.orig_pe = this.pe;
+    this.refs = refs;
+    this.block = RubyString.newEmptyString(runtime);
+    this.regs = runtime.getNil();
+    this.opts = 0;
+    this.buf = runtime.getNil();
+  }
+
+
+  public IRubyObject inline() {
+    %% write init;
+    %% write exec;
+
+    return block;
+  }
+
+  public static IRubyObject inline2(IRubyObject self, IRubyObject str, IRubyObject refs) {
+    ByteList bl = str.convertToString().getByteList();
+    return new RedclothInline(self, bl.bytes, bl.begin, bl.realSize, refs).inline();
+  }
+}