tidy-ext 0.1.7

data/ext/tidy/pprint.h

@@ -0,0 +1,93 @@
+#ifndef __PPRINT_H__
+#define __PPRINT_H__
+
+/* pprint.h -- pretty print parse tree  
+  
+   (c) 1998-2007 (W3C) MIT, ERCIM, Keio University
+   See tidy.h for the copyright notice.
+  
+   CVS Info:
+     $Author: arnaud02 $ 
+     $Date: 2007/02/11 09:45:08 $ 
+     $Revision: 1.9 $ 
+
+*/
+
+#include "forward.h"
+
+/*
+  Block-level and unknown elements are printed on
+  new lines and their contents indented 2 spaces
+
+  Inline elements are printed inline.
+
+  Inline content is wrapped on spaces (except in
+  attribute values or preformatted text, after
+  start tags and before end tags
+*/
+
+#define NORMAL        0u
+#define PREFORMATTED  1u
+#define COMMENT       2u
+#define ATTRIBVALUE   4u
+#define NOWRAP        8u
+#define CDATA         16u
+
+
+/* The pretty printer keeps at most two lines of text in the
+** buffer before flushing output.  We need to capture the
+** indent state (indent level) at the _beginning_ of _each_
+** line, not the end of just the second line.
+**
+** We must also keep track "In Attribute" and "In String"
+** states at the _end_ of each line, 
+*/
+
+typedef struct _TidyIndent
+{
+    int spaces;
+    int attrValStart;
+    int attrStringStart;
+} TidyIndent;
+
+typedef struct _TidyPrintImpl
+{
+    TidyAllocator *allocator; /* Allocator */
+
+    uint *linebuf;
+    uint lbufsize;
+    uint linelen;
+    uint wraphere;
+  
+    uint ixInd;
+    TidyIndent indent[2];  /* Two lines worth of indent state */
+} TidyPrintImpl;
+
+
+#if 0 && SUPPORT_ASIAN_ENCODINGS
+/* #431953 - start RJ Wraplen adjusted for smooth international ride */
+uint CWrapLen( TidyDocImpl* doc, uint ind );
+#endif
+
+void TY_(InitPrintBuf)( TidyDocImpl* doc );
+void TY_(FreePrintBuf)( TidyDocImpl* doc );
+
+void TY_(PFlushLine)( TidyDocImpl* doc, uint indent );
+
+
+/* print just the content of the body element.
+** useful when you want to reuse material from
+** other documents.
+** 
+** -- Sebastiano Vigna <vigna@dsi.unimi.it>
+*/
+
+void TY_(PrintBody)( TidyDocImpl* doc );       /* you can print an entire document */
+                                          /* node as body using PPrintTree() */
+
+void TY_(PPrintTree)( TidyDocImpl* doc, uint mode, uint indent, Node *node );
+
+void TY_(PPrintXMLTree)( TidyDocImpl* doc, uint mode, uint indent, Node *node );
+
+
+#endif /* __PPRINT_H__ */

data/ext/tidy/ruby-tidy.c

@@ -0,0 +1,195 @@
+/*
+  ruby-tidy.c - Ruby driver for HTML TidyLib
+*/
+#include <ruby.h>
+#include "tidy.h"
+#include "buffio.h"
+
+int TIDY_CALL rb_tidyGetByte( TidyInputSource* source )
+{
+  VALUE data = (VALUE)source->sourceData;
+  VALUE value = rb_funcall(data, rb_intern("getc"), 0, NULL);
+  return NUM2INT(value);
+}
+
+void TIDY_CALL rb_tidyUngetByte( TidyInputSource* source, byte byteValue )
+{
+  VALUE data = (VALUE)source->sourceData;
+  VALUE value = rb_funcall(data, rb_intern("ungetc"), 1, INT2NUM(byteValue));
+}
+
+Bool TIDY_CALL rb_tidyIsEOF( TidyInputSource* source )
+{
+  VALUE data = (VALUE)source->sourceData;
+  VALUE value = rb_funcall(data, rb_intern("eof"), 0, NULL);
+  return value == Qfalse ? no : yes;
+}
+
+static VALUE cTidy;
+
+/* release tidy doc memory */
+static void rb_tidy_free(void *ptr)
+{
+  tidyRelease(ptr);
+}
+
+/* create a new tidy doc */
+/* TODO, observe :show_warnings=>true in hash */
+static VALUE rb_tidy_new(VALUE class, VALUE hash)
+{
+  VALUE argv[1];
+  TidyDoc tdoc = tidyCreate();
+  VALUE tdata = Data_Wrap_Struct(class, 0, rb_tidy_free, (struct _TidyDoc *)tdoc);
+  argv[0] = hash;
+
+  rb_obj_call_init(tdata, 0, NULL);
+  return tdata;
+}
+
+/* parse the given input and return the tidy errors and output */
+static VALUE rb_tidy_parse(VALUE self, VALUE input)
+{
+  VALUE array;
+  VALUE access;
+  VALUE errors;
+
+  TidyDoc tdoc;
+  TidyBuffer output;
+  TidyBuffer errbuf;
+  int status          = 0;
+
+  int contentErrors   = 0;
+  int contentWarnings = 0;
+  int accessWarnings  = 0;
+
+  /* See platform.h, opaque_type for typedef convention */
+  Data_Get_Struct(self, struct _TidyDoc, tdoc);
+
+  tidyBufInit( &output );
+  tidyBufInit( &errbuf );
+
+  array = rb_ary_new();
+
+  status = tidySetErrorBuffer( tdoc, &errbuf );
+
+  access = rb_iv_get(self, "@access");
+  tidyOptSetInt( tdoc, TidyAccessibilityCheckLevel, NUM2UINT(access));
+
+  if (status >= 0) {
+
+    int is_input_source = 0;
+
+    is_input_source =
+      rb_respond_to(input, rb_intern("eof")) == Qtrue &&
+      rb_respond_to(input, rb_intern("getc")) == Qtrue &&
+      rb_respond_to(input, rb_intern("ungetc")) == Qtrue;
+
+    if (is_input_source != 0) {
+      TidyInputSource source;
+
+      tidyInitSource(&source, (void *)&input,
+        (TidyGetByteFunc)rb_tidyGetByte,
+        (TidyUngetByteFunc)rb_tidyUngetByte,
+        (TidyEOFFunc)rb_tidyIsEOF);
+
+      status = tidyParseSource(tdoc, &source);
+    } else {
+      status = tidyParseString(tdoc, StringValuePtr(input));
+    }
+  }
+
+  if (status >= 0)
+    status = tidyCleanAndRepair( tdoc );
+  if (status >= 0)
+    status = tidyRunDiagnostics( tdoc );
+  if (status >= 0)
+    tidyErrorSummary( tdoc );
+  if (status >= 0)
+    tidyGeneralInfo( tdoc );
+
+  if (status >= 0)
+    status = tidySaveBuffer( tdoc, &output );
+
+  contentErrors   += tidyErrorCount( tdoc );
+  contentWarnings += tidyWarningCount( tdoc );
+  accessWarnings  += tidyAccessWarningCount( tdoc );
+
+  if (contentErrors > 0 || contentWarnings > 0) {
+    errors = rb_str_new2(errbuf.bp);
+  } else {
+    errors = rb_ary_new2("");
+  }
+
+  rb_iv_set(self, "@errors", errors);
+
+  rb_ary_store(array, 0, errors);
+  rb_ary_store(array, 1, rb_str_new2(output.bp));
+
+  tidyBufFree( &output );
+  tidyBufFree( &errbuf );
+
+  return array;
+}
+
+static VALUE rb_tidy_init(VALUE self)
+{
+  VALUE access = INT2NUM(4);
+  VALUE errors = rb_ary_new();
+
+  rb_iv_set(self, "@access", access);
+  rb_iv_set(self, "@errors", errors);
+
+  return self;
+}
+
+static VALUE rb_tidy_open(VALUE class, VALUE hash)
+{
+  VALUE tidy = rb_tidy_new(class, hash);
+
+  if (rb_block_given_p()) {
+    rb_yield(tidy);
+  }
+
+  return tidy;
+}
+
+static VALUE rb_tidy_clean(VALUE self, VALUE input)
+{
+  VALUE array;
+
+  array = rb_tidy_parse(self, input);
+
+  return rb_ary_entry(array, 1);
+}
+
+static VALUE rb_tidy_path_get(VALUE self)
+{
+  VALUE path;
+  path = rb_cv_get(self, "@@path");
+  return path;
+}
+
+static VALUE rb_tidy_path_set(VALUE self, VALUE path)
+{
+  rb_cv_set(self, "@@path", path);
+  return Qnil;
+}
+
+void Init_tidy()
+{
+  cTidy = rb_define_class("Tidy", rb_cObject);
+
+  rb_define_class_variable(cTidy, "@@path", rb_str_new2("tidy-is-built-in"));
+
+  rb_define_singleton_method(cTidy, "new", rb_tidy_new, 0);
+  rb_define_singleton_method(cTidy, "open", rb_tidy_open, 1);
+  rb_define_singleton_method(cTidy, "path", rb_tidy_path_get, 0);
+  rb_define_singleton_method(cTidy, "path=", rb_tidy_path_set, 1);
+
+  rb_define_method(cTidy, "parse", rb_tidy_parse, 1);
+  rb_define_method(cTidy, "initialize", rb_tidy_init, 0);
+  rb_define_method(cTidy, "clean", rb_tidy_clean, 1);
+
+  rb_define_attr(cTidy, "access", 1, 1);
+  rb_define_attr(cTidy, "errors", 1, 0);
+}