etude_for_ruby 0.1.0 → 0.1.4

data/vendor/bundle/ruby/2.2.0/gems/redcarpet-3.4.0/ext/redcarpet/redcarpet.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2015, Vicent Marti
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef REDCARPET_H__
+#define REDCARPET_H__
+
+#define RSTRING_NOT_MODIFIED
+#include "ruby.h"
+#include <stdio.h>
+
+#include <ruby/encoding.h>
+
+#include "markdown.h"
+#include "html.h"
+
+#define CSTR2SYM(s) (ID2SYM(rb_intern((s))))
+
+void Init_redcarpet_rndr();
+
+struct redcarpet_renderopt {
+	struct html_renderopt html;
+	VALUE link_attributes;
+	VALUE self;
+	VALUE base_class;
+	rb_encoding *active_enc;
+};
+
+struct rb_redcarpet_rndr {
+	struct sd_callbacks callbacks;
+	struct redcarpet_renderopt options;
+};
+
+#endif

data/vendor/bundle/ruby/2.2.0/gems/redcarpet-3.4.0/ext/redcarpet/stack.c

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2015, Vicent Marti
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "stack.h"
+#include <string.h>
+
+int
+redcarpet_stack_grow(struct stack *st, size_t new_size)
+{
+	void **new_st;
+
+	if (st->asize >= new_size)
+		return 0;
+
+	new_st = realloc(st->item, new_size * sizeof(void *));
+	if (new_st == NULL)
+		return -1;
+
+	memset(new_st + st->asize, 0x0,
+		(new_size - st->asize) * sizeof(void *));
+
+	st->item = new_st;
+	st->asize = new_size;
+
+	if (st->size > new_size)
+		st->size = new_size;
+
+	return 0;
+}
+
+void
+redcarpet_stack_free(struct stack *st)
+{
+	if (!st)
+		return;
+
+	free(st->item);
+
+	st->item = NULL;
+	st->size = 0;
+	st->asize = 0;
+}
+
+int
+redcarpet_stack_init(struct stack *st, size_t initial_size)
+{
+	st->item = NULL;
+	st->size = 0;
+	st->asize = 0;
+
+	if (!initial_size)
+		initial_size = 8;
+
+	return redcarpet_stack_grow(st, initial_size);
+}
+
+int
+redcarpet_stack_push(struct stack *st, void *item)
+{
+	if (redcarpet_stack_grow(st, st->size * 2) < 0)
+		return -1;
+
+	st->item[st->size++] = item;
+	return 0;
+}

data/vendor/bundle/ruby/2.2.0/gems/redcarpet-3.4.0/ext/redcarpet/stack.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2015, Vicent Marti
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef STACK_H__
+#define STACK_H__
+
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct stack {
+	void **item;
+	size_t size;
+	size_t asize;
+};
+
+void redcarpet_stack_free(struct stack *);
+int redcarpet_stack_grow(struct stack *, size_t);
+int redcarpet_stack_init(struct stack *, size_t);
+
+int redcarpet_stack_push(struct stack *, void *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/vendor/bundle/ruby/2.2.0/gems/redcarpet-3.4.0/lib/redcarpet.rb

@@ -0,0 +1,92 @@
+require 'redcarpet.so'
+require 'redcarpet/compat'
+
+module Redcarpet
+  VERSION = '3.4.0'
+
+  class Markdown
+    attr_reader :renderer
+  end
+
+  module Render
+
+    # XHTML Renderer
+    class XHTML < HTML
+      def initialize(extensions = {})
+        super(extensions.merge(xhtml: true))
+      end
+    end
+
+    # HTML + SmartyPants renderer
+    class SmartyHTML < HTML
+      include SmartyPants
+    end
+
+    # A renderer object you can use to deal with users' input. It
+    # enables +escape_html+ and +safe_links_only+ by default.
+    #
+    # The +block_code+ callback is also overriden not to include
+    # the lang's class as the user can basically specify anything
+    # with the vanilla one.
+    class Safe < HTML
+      def initialize(extensions = {})
+        super({
+          escape_html: true,
+          safe_links_only: true
+        }.merge(extensions))
+      end
+
+      def block_code(code, lang)
+        "<pre>" \
+          "<code>#{html_escape(code)}</code>" \
+        "</pre>"
+      end
+
+      private
+
+      # TODO: This is far from ideal to have such method as we
+      # are duplicating existing code from Houdini. This method
+      # should be defined at the C level.
+      def html_escape(string)
+        string.gsub(/['&\"<>\/]/, {
+          '&' => '&amp;',
+          '<' => '&lt;',
+          '>' => '&gt;',
+          '"' => '&quot;',
+          "'" => '&#x27;',
+          "/" => '&#x2F;',
+        })
+      end
+    end
+
+    # SmartyPants Mixin module
+    #
+    # Implements SmartyPants.postprocess, which
+    # performs smartypants replacements on the HTML file,
+    # once it has been fully rendered.
+    #
+    # To add SmartyPants postprocessing to your custom
+    # renderers, just mixin the module `include SmartyPants`
+    #
+    # You can also use this as a standalone SmartyPants
+    # implementation.
+    #
+    # Example:
+    #
+    #   # Mixin
+    #   class CoolRenderer < HTML
+    #     include SmartyPants
+    #     # more code here
+    #   end
+    #
+    #   # Standalone
+    #   Redcarpet::Render::SmartyPants.render("you're")
+    #
+    module SmartyPants
+      extend self
+      def self.render(text)
+        postprocess text
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/redcarpet-3.4.0/lib/redcarpet/cli.rb

@@ -0,0 +1,86 @@
+require 'redcarpet'
+require 'optparse'
+
+module Redcarpet
+  # This class aims at easing the creation of custom
+  # binary for your needs. For example, you can add new
+  # options or change the existing ones. The parsing
+  # is handled by Ruby's OptionParser. For instance:
+  #
+  #   class Custom::CLI < Redcarpet::CLI
+  #     def self.options_parser
+  #       super.tap do |opts|
+  #         opts.on("--rainbow") do
+  #           @@options[:rainbow] = true
+  #         end
+  #       end
+  #     end
+  #
+  #     def self.render_object
+  #       @@options[:rainbow] ? RainbowRender : super
+  #     end
+  #   end
+  class CLI
+    def self.options_parser
+      @@options = {
+        render_extensions: {},
+        parse_extensions: {},
+        smarty_pants: false
+      }
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: redcarpet [--parse <extension>...] " \
+                      "[--render <extension>...] [--smarty] <file>..."
+
+        opts.on("--parse EXTENSION", "Enable a parsing extension") do |ext|
+          ext = ext.gsub('-', '_').to_sym
+          @@options[:parse_extensions][ext] = true
+        end
+
+        opts.on("--render EXTENSION", "Enable a rendering extension") do |ext|
+          ext = ext.gsub('-', '_').to_sym
+          @@options[:render_extensions][ext] = true
+        end
+
+        opts.on("--smarty", "Enable Smarty Pants") do
+          @@options[:smarty_pants] = true
+        end
+
+        opts.on_tail("-v", "--version", "Display the current version") do
+          STDOUT.puts "Redcarpet #{Redcarpet::VERSION}"
+          exit
+        end
+
+        opts.on_tail("-h", "--help", "Display this help message") do
+          puts opts
+          exit
+        end
+      end
+    end
+
+    def self.process(args)
+      self.legacy_parse!(args)
+      self.options_parser.parse!(args)
+      STDOUT.write parser_object.render(ARGF.read)
+    end
+
+    def self.render_object
+      @@options[:smarty_pants] ? Render::SmartyHTML : Render::HTML
+    end
+
+    def self.parser_object
+      renderer = render_object.new(@@options[:render_extensions])
+      Redcarpet::Markdown.new(renderer, @@options[:parse_extensions])
+    end
+
+    def self.legacy_parse!(args) # :nodoc:
+      # Workaround for backward compatibility as OptionParser
+      # doesn't support the --flag-OPTION syntax.
+      args.select {|a| a =~ /--(parse|render)-/ }.each do |arg|
+        args.delete(arg)
+        arg = arg.partition(/\b-/)
+        args.push(arg.first, arg.last)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/redcarpet-3.4.0/lib/redcarpet/compat.rb

@@ -0,0 +1,73 @@
+require 'redcarpet'
+
+# Creates an instance of Redcarpet with the RedCloth API.
+class RedcarpetCompat
+  attr_accessor :text
+
+  def initialize(text, *exts)
+    exts_hash, render_hash = *parse_extensions_and_renderer_options(exts)
+    @text = text
+    renderer = Redcarpet::Render::HTML.new(render_hash)
+    @markdown = Redcarpet::Markdown.new(renderer, exts_hash)
+  end
+
+  def to_html(*_dummy)
+    @markdown.render(text)
+  end
+
+  private
+
+  EXTENSION_MAP = {
+    # old name => new name
+    :autolink         => :autolink,
+    :fenced_code      => :fenced_code_blocks,
+    :filter_html      => :filter_html,
+    :hard_wrap        => :hard_wrap,
+    :prettify         => :prettify,
+    :lax_htmlblock    => :lax_spacing,
+    :no_image         => :no_images,
+    :no_intraemphasis => :no_intra_emphasis,
+    :no_links         => :no_links,
+    :filter_styles    => :no_styles,
+    :safelink         => :safe_links_only,
+    :space_header     => :space_after_headers,
+    :strikethrough    => :strikethrough,
+    :tables           => :tables,
+    :generate_toc     => :with_toc_data,
+    :xhtml            => :xhtml,
+
+    # old names with no new mapping
+    :gh_blockcode => nil,
+    :no_tables    => nil,
+    :smart        => nil,
+    :strict       => nil
+  }
+
+  RENDERER_OPTIONS = [:filter_html, :no_images, :no_links, :no_styles,
+    :safe_links_only, :with_toc_data, :hard_wrap, :prettify, :xhtml]
+
+  def rename_extensions(exts)
+    exts.map do |old_name|
+      if new_name = EXTENSION_MAP[old_name]
+        new_name
+      else
+        old_name
+      end
+    end.compact
+  end
+
+  # Returns two hashes, the extensions and renderer options
+  # given the extension list
+  def parse_extensions_and_renderer_options(exts)
+    exts = rename_extensions(exts)
+    exts.partition {|ext| !RENDERER_OPTIONS.include?(ext) }.
+      map {|list| list_to_truthy_hash(list) }
+  end
+
+  # Turns a list of symbols into a hash of <tt>symbol => true</tt>.
+  def list_to_truthy_hash(list)
+    list.inject({}) {|h, k| h[k] = true; h }
+  end
+end
+
+Markdown = RedcarpetCompat unless defined? Markdown