apex-ruby 1.0.6

data/ext/apex_ext/apex_src/vendor/cmark-gfm/why-cmark-and-not-x.md

@@ -0,0 +1,104 @@
+Why use `cmark` and not X?
+==========================
+
+`hoedown`
+---------
+
+`hoedown` (which derives from `sundown`) is slightly faster
+than `cmark` in our benchmarks (0.21s vs. 0.29s).  But both
+are much faster than any other available implementations.
+
+`hoedown` boasts of including "protection against all possible
+DOS attacks," but there are some chinks in the armor:
+
+    % time python -c 'print(("[" * 50000) + "a" + ("]" * 50000))' | cmark
+    ...
+    user 0m0.073s
+    % time python -c 'print(("[" * 50000) + "a" + ("]" * 50000))' | hoedown
+    ...
+    0m17.84s
+
+`hoedown` has many parsing bugs.  Here is a selection (as of
+v3.0.3):
+
+    % hoedown
+    - one
+      - two
+        1. three
+    ^D
+    <ul>
+    <li>one
+
+    <ul>
+    <li>two</li>
+    <li>three</li>
+    </ul></li>
+    </ul>
+
+
+    % hoedown
+    ## hi\###
+    ^D
+    <h2>hi\</h2>
+
+
+    % hoedown
+    [ΑΓΩ]: /φου
+
+    [αγω]
+    ^D
+    <p>[αγω]</p>
+
+
+    % hoedown
+    ```
+    [foo]: /url
+    ```
+
+    [foo]
+    ^D
+    <p>```</p>
+
+    <p>```</p>
+
+    <p><a href="/url">foo</a></p>
+
+
+    % hoedown
+    [foo](url "ti\*tle")
+    ^D
+    <p><a href="url" title="ti\*tle">foo</a></p>
+
+
+    % ./hoedown
+    - one
+     - two
+      - three
+       - four
+    ^D
+    <ul>
+    <li>one
+
+    <ul>
+    <li>two</li>
+    <li>three</li>
+    <li>four</li>
+    </ul></li>
+    </ul>
+
+
+`discount`
+----------
+
+`cmark` is about six times faster.
+
+`kramdown`
+----------
+
+`cmark` is about a hundred times faster.
+
+`kramdown` also gets tied in knots by pathological input like
+
+    python -c 'print(("[" * 50000) + "a" + ("]" * 50000))'
+
+

data/ext/apex_ext/apex_src/vendor/cmark-gfm/wrappers/wrapper.js

@@ -0,0 +1,6 @@
+
+const cmark = require('node-cmark');
+
+const markdown = '# h1 title';
+
+cmark.markdown2html(markdown);

data/ext/apex_ext/apex_src/vendor/cmark-gfm/wrappers/wrapper.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+
+# Example for using the shared library from python
+# Will work with either python 2 or python 3
+# Requires cmark library to be installed
+
+from ctypes import CDLL, c_char_p, c_long
+import sys
+import platform
+
+sysname = platform.system()
+
+if sysname == 'Darwin':
+    libname = "libcmark.dylib"
+elif sysname == 'Windows':
+    libname = "cmark.dll"
+else:
+    libname = "libcmark.so"
+cmark = CDLL(libname)
+
+markdown = cmark.cmark_markdown_to_html
+markdown.restype = c_char_p
+markdown.argtypes = [c_char_p, c_long, c_long]
+
+opts = 0 # defaults
+
+def md2html(text):
+    if sys.version_info >= (3,0):
+        textbytes = text.encode('utf-8')
+        textlen = len(textbytes)
+        return markdown(textbytes, textlen, opts).decode('utf-8')
+    else:
+        textbytes = text
+        textlen = len(text)
+        return markdown(textbytes, textlen, opts)
+
+sys.stdout.write(md2html(sys.stdin.read()))

data/ext/apex_ext/apex_src/vendor/cmark-gfm/wrappers/wrapper.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+require 'ffi'
+
+module CMark
+  extend FFI::Library
+  ffi_lib ['libcmark', 'cmark']
+  attach_function :cmark_markdown_to_html, [:string, :int, :int], :string
+end
+
+def markdown_to_html(s)
+  len = s.bytesize
+  CMark::cmark_markdown_to_html(s, len, 0)
+end
+
+STDOUT.write(markdown_to_html(ARGF.read()))

data/ext/apex_ext/apex_src/vendor/cmark-gfm/wrappers/wrapper.rkt

@@ -0,0 +1,208 @@
+#lang racket/base
+
+;; requires racket >= 5.3 because of submodules
+
+;; Lowlevel interface
+
+(module low-level racket/base
+
+  (require ffi/unsafe ffi/unsafe/define)
+
+  (provide (all-defined-out))
+
+  (define-ffi-definer defcmark (ffi-lib "libcmark"))
+
+  (define _cmark_node_type
+    (_enum '(;; Error status
+             none
+             ;; Block
+             document block-quote list item code-block
+             html-block custom-block
+             paragraph heading thematic-break
+             ;; ?? first-block = document
+             ;; ?? last-block = thematic-break
+             ;; Inline
+             text softbreak linebreak code html-inline custom-inline
+             emph strong link image
+             ;; ?? first-inline = text
+             ;; ?? last-inline = image
+             )))
+  (define _cmark_list_type
+    (_enum '(no_list bullet_list ordered_list)))
+  (define _cmark_delim_type
+    (_enum '(no_delim period_delim paren_delim)))
+  (define _cmark_opts
+    (_bitmask
+     '(sourcepos  = 2 ; include sourcepos attribute on block elements
+       hardbreaks = 4 ; render `softbreak` elements as hard line breaks
+       safe       = 8 ; suppress raw HTML and unsafe links
+       nobreaks   = 16 ; render `softbreak` elements as spaces
+       normalize  = 256 ; legacy (no effect)
+       validate-utf8 = 512 ; validate UTF-8 in the input
+       smart      = 1024 ; straight quotes to curly, ---/-- to em/en dashes
+       )))
+
+  (define-cpointer-type _node)
+
+  (defcmark cmark_markdown_to_html
+    (_fun [bs : _bytes] [_int = (bytes-length bs)] _cmark_opts
+          -> [r : _bytes] -> (begin0 (bytes->string/utf-8 r) (free r))))
+
+  (defcmark cmark_parse_document
+    (_fun [bs : _bytes] [_int = (bytes-length bs)] _cmark_opts
+          -> _node))
+
+  (defcmark cmark_render_html
+    (_fun _node _cmark_opts
+          -> [r : _bytes] -> (begin0 (bytes->string/utf-8 r) (free r))))
+
+  (defcmark cmark_node_new              (_fun _cmark_node_type -> _node))
+  (defcmark cmark_node_free             (_fun _node -> _void))
+
+  (defcmark cmark_node_next             (_fun _node -> _node/null))
+  (defcmark cmark_node_previous         (_fun _node -> _node/null))
+  (defcmark cmark_node_parent           (_fun _node -> _node/null))
+  (defcmark cmark_node_first_child      (_fun _node -> _node/null))
+  (defcmark cmark_node_last_child       (_fun _node -> _node/null))
+
+  (defcmark cmark_node_get_user_data    (_fun _node -> _racket))
+  (defcmark cmark_node_set_user_data    (_fun _node _racket -> _bool))
+  (defcmark cmark_node_get_type         (_fun _node -> _cmark_node_type))
+  (defcmark cmark_node_get_type_string  (_fun _node -> _bytes))
+  (defcmark cmark_node_get_literal      (_fun _node -> _string))
+  (defcmark cmark_node_set_literal      (_fun _node _string -> _bool))
+  (defcmark cmark_node_get_heading_level (_fun _node -> _int))
+  (defcmark cmark_node_set_heading_level (_fun _node _int -> _bool))
+  (defcmark cmark_node_get_list_type    (_fun _node -> _cmark_list_type))
+  (defcmark cmark_node_set_list_type    (_fun _node _cmark_list_type -> _bool))
+  (defcmark cmark_node_get_list_delim   (_fun _node -> _cmark_delim_type))
+  (defcmark cmark_node_set_list_delim   (_fun _node _cmark_delim_type -> _bool))
+  (defcmark cmark_node_get_list_start   (_fun _node -> _int))
+  (defcmark cmark_node_set_list_start   (_fun _node _int -> _bool))
+  (defcmark cmark_node_get_list_tight   (_fun _node -> _bool))
+  (defcmark cmark_node_set_list_tight   (_fun _node _bool -> _bool))
+  (defcmark cmark_node_get_fence_info   (_fun _node -> _string))
+  (defcmark cmark_node_set_fence_info   (_fun _node _string -> _bool))
+  (defcmark cmark_node_get_url          (_fun _node -> _string))
+  (defcmark cmark_node_set_url          (_fun _node _string -> _bool))
+  (defcmark cmark_node_get_title        (_fun _node -> _string))
+  (defcmark cmark_node_set_title        (_fun _node _string -> _bool))
+  (defcmark cmark_node_get_start_line   (_fun _node -> _int))
+  (defcmark cmark_node_get_start_column (_fun _node -> _int))
+  (defcmark cmark_node_get_end_line     (_fun _node -> _int))
+  (defcmark cmark_node_get_end_column   (_fun _node -> _int))
+
+  (defcmark cmark_node_unlink           (_fun _node -> _void))
+  (defcmark cmark_node_insert_before    (_fun _node _node -> _bool))
+  (defcmark cmark_node_insert_after     (_fun _node _node -> _bool))
+  (defcmark cmark_node_prepend_child    (_fun _node _node -> _bool))
+  (defcmark cmark_node_append_child     (_fun _node _node -> _bool))
+  (defcmark cmark_consolidate_text_nodes (_fun _node -> _void))
+
+  (defcmark cmark_version               (_fun -> _int))
+  (defcmark cmark_version_string        (_fun -> _string))
+
+  )
+
+;; Rackety interface
+
+(module high-level racket/base
+
+  (require (submod ".." low-level) ffi/unsafe)
+
+  (provide cmark-markdown-to-html)
+  (define (cmark-markdown-to-html str [options '(normalize smart)])
+    (cmark_markdown_to_html (if (bytes? str) str (string->bytes/utf-8 str))
+                            options))
+
+  (require (for-syntax racket/base racket/syntax))
+  (define-syntax (make-getter+setter stx)
+    (syntax-case stx ()
+      [(_ name) (with-syntax ([(getter setter)
+                               (map (λ(op) (format-id #'name "cmark_node_~a_~a"
+                                                      op #'name))
+                                    '(get set))])
+                  #'(cons getter setter))]))
+  (define-syntax-rule (define-getters+setters name [type field ...] ...)
+    (define name (list (list 'type (make-getter+setter field) ...) ...)))
+  (define-getters+setters getters+setters
+    [heading heading_level] [code-block fence_info]
+    [link url title] [image url title]
+    [list list_type list_delim list_start list_tight])
+
+  (provide cmark->sexpr)
+  (define (cmark->sexpr node)
+    (define text (cmark_node_get_literal node))
+    (define type (cmark_node_get_type node))
+    (define children
+      (let loop ([node (cmark_node_first_child node)])
+        (if (not node) '()
+            (cons (cmark->sexpr node) (loop (cmark_node_next node))))))
+    (define info
+      (cond [(assq type getters+setters)
+             => (λ(gss) (map (λ(gs) ((car gs) node)) (cdr gss)))]
+            [else '()]))
+    (define (assert-no what-not b)
+      (when b (error 'cmark->sexpr "unexpected ~a in ~s" what-not type)))
+    (cond [(memq type '(document paragraph heading block-quote list item
+                        emph strong link image))
+           (assert-no 'text text)
+           (list type info children)]
+          [(memq type '(text code code-block html-block html-inline
+                        softbreak linebreak thematic-break))
+           (assert-no 'children (pair? children))
+           (list type info text)]
+          [else (error 'cmark->sexpr "unknown type: ~s" type)]))
+
+  (provide sexpr->cmark)
+  (define (sexpr->cmark sexpr) ; assumes valid input, as generated by the above
+    (define (loop sexpr)
+      (define type (car sexpr))
+      (define info (cadr sexpr))
+      (define data (caddr sexpr))
+      (define node (cmark_node_new type))
+      (let ([gss (assq type getters+setters)])
+        (when gss
+          (unless (= (length (cdr gss)) (length info))
+            (error 'sexpr->cmark "bad number of info values in ~s" sexpr))
+          (for-each (λ(gs x) ((cdr gs) node x)) (cdr gss) info)))
+      (cond [(string? data) (cmark_node_set_literal node data)]
+            [(not data) (void)]
+            [(list? data)
+             (for ([child (in-list data)])
+               (cmark_node_append_child node (sexpr->cmark child)))]
+            [else (error 'sexpr->cmark "bad data in ~s" sexpr)])
+      node)
+    (define root (loop sexpr))
+    (register-finalizer root cmark_node_free)
+    root)
+
+  ;; Registers a `cmark_node_free` finalizer
+  (provide cmark-parse-document)
+  (define (cmark-parse-document str [options '(normalize smart)])
+    (define root (cmark_parse_document
+                  (if (bytes? str) str (string->bytes/utf-8 str))
+                  options))
+    (register-finalizer root cmark_node_free)
+    root)
+
+  (provide cmark-render-html)
+  (define (cmark-render-html root [options '(normalize smart)])
+    (cmark_render_html root options)))
+
+#; ;; sample use
+(begin
+  (require 'high-level racket/string)
+  (cmark-render-html
+   (cmark-parse-document
+    (string-join '("foo"
+                   "==="
+                   ""
+                   "> blah"
+                   ">"
+                   "> blah *blah* `bar()` blah:"
+                   ">"
+                   ">     function foo() {"
+                   ">       bar();"
+                   ">     }")
+                 "\n"))))

data/ext/apex_ext/apex_src/vendor/cmark-gfm/wrappers/wrapper_ext.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+
+#
+# Example for using the shared library from python.
+# Will work with either python 2 or python 3.
+# Requires cmark-gfm and cmark-gfm-extensions libraries to be installed.
+#
+# This particular example uses the GitHub extensions from the gfm-extensions
+# library. EXTENSIONS specifies which to use, and the sample shows how to
+# connect them into a parser.
+#
+
+import sys
+import ctypes
+
+if sys.platform == 'darwin':
+    libname = 'libcmark-gfm.dylib'
+    extname = 'libcmark-gfm-extensions.dylib'
+elif sys.platform == 'win32':
+    libname = 'cmark-gfm.dll'
+    extname = 'cmark-gfm-extensions.dll'
+else:
+    libname = 'libcmark-gfm.so'
+    extname = 'libcmark-gfm-extensions.so'
+cmark = ctypes.CDLL(libname)
+cmark_ext = ctypes.CDLL(extname)
+
+# Options for the GFM rendering call
+OPTS = 0  # defaults
+
+# The GFM extensions that we want to use
+EXTENSIONS = (
+  'autolink',
+  'table',
+  'strikethrough',
+  'tagfilter',
+  )
+
+# Use ctypes to access the functions in libcmark-gfm
+
+F_cmark_parser_new = cmark.cmark_parser_new
+F_cmark_parser_new.restype = ctypes.c_void_p
+F_cmark_parser_new.argtypes = (ctypes.c_int,)
+
+F_cmark_parser_feed = cmark.cmark_parser_feed
+F_cmark_parser_feed.restype = None
+F_cmark_parser_feed.argtypes = (ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t)
+
+F_cmark_parser_finish = cmark.cmark_parser_finish
+F_cmark_parser_finish.restype = ctypes.c_void_p
+F_cmark_parser_finish.argtypes = (ctypes.c_void_p,)
+
+F_cmark_parser_attach_syntax_extension = cmark.cmark_parser_attach_syntax_extension
+F_cmark_parser_attach_syntax_extension.restype = ctypes.c_int
+F_cmark_parser_attach_syntax_extension.argtypes = (ctypes.c_void_p, ctypes.c_void_p)
+
+F_cmark_parser_get_syntax_extensions = cmark.cmark_parser_get_syntax_extensions
+F_cmark_parser_get_syntax_extensions.restype = ctypes.c_void_p
+F_cmark_parser_get_syntax_extensions.argtypes = (ctypes.c_void_p,)
+
+F_cmark_parser_free = cmark.cmark_parser_free
+F_cmark_parser_free.restype = None
+F_cmark_parser_free.argtypes = (ctypes.c_void_p,)
+
+F_cmark_node_free = cmark.cmark_node_free
+F_cmark_node_free.restype = None
+F_cmark_node_free.argtypes = (ctypes.c_void_p,)
+
+F_cmark_find_syntax_extension = cmark.cmark_find_syntax_extension
+F_cmark_find_syntax_extension.restype = ctypes.c_void_p
+F_cmark_find_syntax_extension.argtypes = (ctypes.c_char_p,)
+
+F_cmark_render_html = cmark.cmark_render_html
+F_cmark_render_html.restype = ctypes.c_char_p
+F_cmark_render_html.argtypes = (ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p)
+
+
+# Set up the libcmark-gfm library and its extensions
+F_register = cmark_ext.cmark_gfm_core_extensions_ensure_registered
+F_register.restype = None
+F_register.argtypes = ( )
+F_register()
+
+
+def md2html(text):
+  "Use cmark-gfm to render the Markdown into an HTML fragment."
+
+  parser = F_cmark_parser_new(OPTS)
+  assert parser
+  for name in EXTENSIONS:
+    ext = F_cmark_find_syntax_extension(name)
+    assert ext
+    rv = F_cmark_parser_attach_syntax_extension(parser, ext)
+    assert rv
+  exts = F_cmark_parser_get_syntax_extensions(parser)
+
+  F_cmark_parser_feed(parser, text, len(text))
+  doc = F_cmark_parser_finish(parser)
+  assert doc
+
+  output = F_cmark_render_html(doc, OPTS, exts)
+
+  F_cmark_parser_free(parser)
+  F_cmark_node_free(doc)
+
+  return output
+
+
+sys.stdout.write(md2html(sys.stdin.read()))

data/ext/apex_ext/apex_src/vendor/libyaml/CMakeLists.txt

@@ -0,0 +1,160 @@
+
+cmake_minimum_required(VERSION 3.0)
+project (yaml C)
+
+set (YAML_VERSION_MAJOR 0)
+set (YAML_VERSION_MINOR 2)
+set (YAML_VERSION_PATCH 5)
+set (YAML_VERSION_STRING "${YAML_VERSION_MAJOR}.${YAML_VERSION_MINOR}.${YAML_VERSION_PATCH}")
+
+option(BUILD_SHARED_LIBS "Build libyaml as a shared library" OFF)
+set(YAML_STATIC_LIB_NAME "yaml" CACHE STRING "Base name of static library output")
+
+#
+# Output directories for a build tree
+#
+if(NOT DEFINED CMAKE_RUNTIME_OUTPUT_DIRECTORY)
+  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+endif()
+
+#
+# Install relative directories
+#
+if(NOT DEFINED INSTALL_LIB_DIR)
+  set(INSTALL_LIB_DIR lib)
+endif()
+if(NOT DEFINED INSTALL_BIN_DIR)
+  set(INSTALL_BIN_DIR bin)
+endif()
+if(NOT DEFINED INSTALL_INCLUDE_DIR)
+  set(INSTALL_INCLUDE_DIR include)
+endif()
+if(NOT DEFINED INSTALL_CMAKE_DIR)
+  set(INSTALL_CMAKE_DIR cmake)
+endif()
+
+#
+# Build library
+#
+set(SRCS
+  src/api.c
+  src/dumper.c
+  src/emitter.c
+  src/loader.c
+  src/parser.c
+  src/reader.c
+  src/scanner.c
+  src/writer.c
+  )
+
+set(config_h ${CMAKE_CURRENT_BINARY_DIR}/include/config.h)
+configure_file(
+  cmake/config.h.in
+  ${config_h}
+  )
+
+add_library(yaml ${SRCS})
+
+if(NOT BUILD_SHARED_LIBS)
+  set_target_properties(yaml
+    PROPERTIES OUTPUT_NAME ${YAML_STATIC_LIB_NAME}
+  )
+endif()
+
+set_target_properties(yaml
+  PROPERTIES DEFINE_SYMBOL YAML_DECLARE_EXPORT
+  )
+
+target_compile_definitions(yaml
+  PRIVATE HAVE_CONFIG_H
+  PUBLIC
+    $<$<NOT:$<BOOL:${BUILD_SHARED_LIBS}>>:YAML_DECLARE_STATIC>
+    $<$<BOOL:${MSVC}>:_CRT_SECURE_NO_WARNINGS>
+  )
+
+target_include_directories(yaml PUBLIC
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+  $<INSTALL_INTERFACE:${INSTALL_INCLUDE_DIR}>
+  )
+
+#
+# Install rules
+#
+install(
+  FILES
+    include/yaml.h
+  DESTINATION include COMPONENT Development
+  )
+
+install(
+  TARGETS yaml
+  EXPORT yamlTargets
+  RUNTIME DESTINATION "${INSTALL_BIN_DIR}" COMPONENT Runtime
+  LIBRARY DESTINATION "${INSTALL_LIB_DIR}" COMPONENT Development
+  ARCHIVE DESTINATION "${INSTALL_LIB_DIR}" COMPONENT Development
+  )
+
+#
+# Add tests
+#
+include(CTest) # This module defines BUILD_TESTING option
+if(BUILD_TESTING)
+  add_subdirectory(tests)
+endif()
+
+#
+# Generate 'yamlConfig.cmake', 'yamlConfigVersion.cmake' and 'yamlTargets.cmake'
+#
+include(CMakePackageConfigHelpers)
+
+# Configure 'yamlConfig.cmake' for a build tree
+set(CONFIG_DIR_CONFIG ${PROJECT_BINARY_DIR})
+set(config_file ${PROJECT_BINARY_DIR}/yamlConfig.cmake)
+configure_package_config_file(
+  yamlConfig.cmake.in
+  ${config_file}
+  INSTALL_DESTINATION ${PROJECT_BINARY_DIR}
+  PATH_VARS CONFIG_DIR_CONFIG
+  NO_CHECK_REQUIRED_COMPONENTS_MACRO
+  )
+
+# Configure 'yamlTargets.cmake' for a build tree
+export(TARGETS yaml
+  FILE ${PROJECT_BINARY_DIR}/yamlTargets.cmake
+  )
+
+# Configure and install 'yamlConfig.cmake' for an install tree
+set(CONFIG_DIR_CONFIG ${INSTALL_CMAKE_DIR})
+set(install_config_file ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/yamlConfig.cmake )
+configure_package_config_file(
+  yamlConfig.cmake.in
+  ${install_config_file}
+  INSTALL_DESTINATION ${CMAKE_INSTALL_PREFIX}/${INSTALL_CMAKE_DIR}
+  PATH_VARS CONFIG_DIR_CONFIG
+  NO_CHECK_REQUIRED_COMPONENTS_MACRO
+  )
+install(
+  FILES ${install_config_file}
+  DESTINATION ${INSTALL_CMAKE_DIR} COMPONENT Development
+  )
+
+# Configure and install 'yamlTargets.cmake' for an install tree
+install(EXPORT yamlTargets
+  FILE yamlTargets.cmake
+  DESTINATION ${INSTALL_CMAKE_DIR}
+  COMPONENT Development
+  )
+
+# Configure 'yamlConfigVersion.cmake' for a build tree
+set(config_version_file ${PROJECT_BINARY_DIR}/yamlConfigVersion.cmake)
+write_basic_package_version_file(
+    ${config_version_file}
+    VERSION ${YAML_VERSION_STRING}
+    COMPATIBILITY AnyNewerVersion
+)
+# ... and install for an install tree
+install(
+  FILES ${config_version_file}
+  DESTINATION ${INSTALL_CMAKE_DIR} COMPONENT Development
+  )