texttube 5.0.2

data/lib/texttube/base.rb

@@ -0,0 +1,158 @@
+module TextTube
+
+  # Inherit from this and wrap it around a string and
+  # you can then run filters against it.
+  # @example
+  #   module AFilter
+  #     extend TextTube::Filterable
+  #   
+  #     filter_with :double do |text|
+  #       text * 2
+  #     end
+  #   
+  #     filter_with :triple do |text|
+  #       text * 3
+  #     end
+  #   end
+  #   
+  #   module BFil
+  #     extend TextTube::Filterable
+  #   
+  #     filter_with :spacial do |current,options|
+  #       current.split(//).join " " 
+  #     end
+  #   end
+  #   
+  #   class NeuS < TextTube::Base
+  #     register BFil
+  #     register AFilter
+  #     register do
+  #       filter_with :dashes do |text|
+  #         "---#{text}---"
+  #       end
+  #     end
+  #   end
+  #
+  #   n = NeuS.new "abc"
+  #   n.filter
+  #   # => "---a b ca b ca b ca b ca b ca b c---"
+  #   n
+  #   # => "abc"
+  class Base < ::String
+
+    # @!attribute [rw] options
+    #   This instance's options.
+    #   @return [Hash]
+    attr_accessor :options
+
+    # @param [#to_s] text The original text.
+    # @param [Hash] options Options that will be passed on to every instance.
+    # @example
+    #   n = NeuS.new "abc"
+    def initialize( text, options={} )
+      @options = options
+      @filters ||= []
+      super text
+    end
+
+
+    class << self
+
+      # Global options. Every descendant will get these.
+      def options
+        @options ||= {}
+      end
+
+      # remove all filters
+      # @todo remove methods too.
+      def reset!
+        @filters = []
+      end
+
+
+      # Filters added.
+      def filters
+        @filters ||= []
+      end
+
+
+      # Register a module of filters.
+      # @example
+      #   class MyFilter < TextTube::Base
+      #     register TextTube::LinkReffing
+      #     register TextTube::Coderay
+      #     register do
+      #       filter_with :dashes do |text|
+      #         "---#{text}---"
+      #       end
+      #     end
+      #   end
+      #
+      # I could've made it so there's no need to write the
+      # `filter_with` part, but this way your code will be 
+      # clearer to those reading it later, and you can add 
+      # in any other stuff you want done too, you don't just 
+      # have to set up a filter.
+      def register( filter=nil, &block )
+        @filters ||= []
+        if block
+          name = filter
+          
+          filter = Module.new do
+            extend Filterable
+          end
+          filter.instance_eval &block
+        end
+        @filters += filter.filters
+        include filter
+      end
+
+
+      # A clean slate
+      # @private
+      def inherited(subclass)
+        subclass.reset!
+      end
+    end
+
+
+    # Run the filters. If the names of filters are provided as arguments then only those filters will be run, in that order (left first, to right).
+    # @overload filter()
+    #   Run all the filters in the order they were registered.
+    #     n = NeuS.new "abc"
+    #     n.filter
+    #     # => "---a b ca b ca b ca b ca b ca b c---"
+    # @overload filter( filters )
+    #   Run the given filters in the order given.
+    #   @param [Array<#to_sym>] filters
+    #   @example
+    #     n = NeuS.new "abc"
+    #     n.filter :spacial
+    #     # => "a b c"
+    #     n.filter :spacial, :dashes
+    #     # => "---a b c---"
+    # @overload filter( filters_and_options )
+    #   Run the given filters in the order given with the given options. Pass any options for a filter at the end, by giving the options as a hash with the name of the filter. I'd prefer to give the filter name and the options at the same time, but the Ruby argument parser can't handle it, which is fair enough :)
+    #   @example
+    #     n = NeuS.new "abc"
+    #     n.filter :dashes, :spacial, :dashes => {some_option_for_dashes: true}
+    def filter( *order_and_options )
+      if order_and_options.last.respond_to?(:keys)
+        *order,options = *order_and_options
+      else
+        order,options = order_and_options, {}
+      end
+      order = order.flatten
+      order = @options.fetch :order, self.class.filters if order.empty?
+      order.inject(self){|current,filter|
+        send filter, current, options
+      }
+    end
+
+    # See all added filters.
+    def filters
+      self.class.filters
+    end
+
+  end
+end

data/lib/texttube/filterable.rb

@@ -0,0 +1,53 @@
+module TextTube
+
+  # Add this to your filter module.
+  # @example
+  #   module AFilter
+  #     extend TextTube::Filterable
+  #   
+  #     filter_with :double do |text|
+  #       text * 2
+  #     end
+  #   
+  #     filter_with :triple do |text|
+  #       text * 3
+  #     end
+  #   end
+  module Filterable
+
+    # See all current filters.
+    # @return [Array<Symbol>]
+    def filters
+      @filters ||= []
+    end
+  
+    # Add a filter.
+    # @example
+    #   filter_with :triple do |text|
+    #     text * 3
+    #   end
+    #   filter_with :number do |text,options|
+    #     text * options[:times].to_i
+    #   end
+    # @param [#to_sym] name
+    # @yield [String, Hash] Pass the string to be filtered, and optionally, any options.
+    def filter_with name, &block
+      name = name.to_sym
+      filters << name unless filters.include? name
+      define_method name do |current=self, options=nil|
+        if current.respond_to? :keys
+          options=current
+          current=self
+        end
+        options = [options, @options, self.class.options].find{|opts|
+          !opts.nil? && 
+          opts.respond_to?(:keys) && 
+          !opts.empty?
+        } || {}
+
+        block.call current, options[name]
+      end
+    end
+
+  end # Filterable
+end # TextTube

data/lib/texttube/filters/coderay.rb

@@ -0,0 +1,68 @@
+# encoding: UTF-8
+module TextTube
+
+  require 'nokogiri'
+  require_relative "../../ext/blank.rb"
+  require 'coderay'
+  require_relative "../filterable.rb"
+
+  # a filter for Coderay
+  module Coderay
+    extend Filterable
+
+    filter_with :coderay do |text|
+      TextTube::Coderay.run text
+    end
+
+
+    # @param [String] content
+    # @param [Hash] options
+    # @return [String]
+    def self.run(content, options={})
+      options = {lang: :ruby } if options.blank? 
+      doc = Nokogiri::HTML::fragment(content) 
+
+      code_blocks = doc.xpath("pre/code").map do |code_block| 
+        #un-escape as Coderay will escape it again
+        inner_html = code_block.inner_html
+        
+        # following the convention of Rack::Codehighlighter
+        if inner_html.start_with?("::::")
+          lines = inner_html.split("\n")
+          options[:lang] = lines.shift.match(%r{::::(\w+)})[1].to_sym
+          inner_html = lines.join("\n")
+        end
+
+        if (options[:lang] == :skip) || (! options.has_key? :lang )
+          code_block.inner_html = inner_html
+        else
+          code = Coderay.codify(Coderay.html_unescape(inner_html), options[:lang]) 
+          code_block.inner_html = code 
+          code_block["class"] = "CodeRay"    
+        end      
+      end#block
+
+      doc.to_s
+    end#def
+
+    # @private
+    # Unescape the HTML as the Coderay scanner won't work otherwise.
+    def self.html_unescape(a_string) 
+      a_string.gsub('&amp;', '&').gsub('&lt;', '<').gsub('&gt;', 
+      '>').gsub('&quot;', '"') 
+    end#def
+
+    # Run the Coderay scanner.
+    # @private
+    # @param [String] str
+    # @param [String] lang
+    # @example
+    #   self.class.codify "x = 2", "ruby"
+    def self.codify(str, lang) 
+      CodeRay.scan(str, lang).html
+    end#def
+
+  end#class 
+
+
+end#module

data/lib/texttube/filters/embedding_audio.rb

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+require_relative "../filterable.rb"
+
+module TextTube
+
+  # Embed some audio via [audio[link|name]]
+  module EmbeddingAudio
+    extend TextTube::Filterable
+  
+    filter_with :embeddingaudio do |text|
+      TextTube::EmbeddingAudio.run text
+    end
+  
+    # default attributes
+    DEFAULTS = {
+      src_base:  "/streams/",
+      preload:   "metadata",
+      fallback_text: "Your browser does not support HTML5, update your browser you fool!",
+      controls: "controls",
+    }
+    
+    # [audio[link|name]]
+    R_link = /             # [audio[url|description]]
+      \[audio\[        # opening square brackets
+        ([^\|]+)     # link
+          \|      # separator
+        ([^\[]+)  # description
+      \]\]        # closing square brackets
+    /x
+
+
+    # @param [String] content
+    # @param [Hash] options
+    # @return [String]
+    def self.run(content, options={})
+      options ||= {}
+      attributes = DEFAULTS.merge options
+           
+      content.gsub( R_link ) { |m|
+        url,desc = $1,$2
+        EmbeddingAudio::render_tag(url,desc,attributes)
+      }
+    end
+
+
+    # Does the grunt work of rendering the tag.
+    # @private
+    # @param [String] link
+    # @param [String] desc
+    # @param [Hash] attributes
+    def self.render_tag(link,desc,attributes)
+      fallback_text = attributes.delete(:fallback_text)
+      src_base = attributes.delete(:src_base)
+      make_inner = ->(lnk){%Q!<source src='#{src_base}#{lnk}' type='audio/#{File.extname(lnk)[1..-1]}' />!}
+      inner = make_inner.( link )
+      inner += make_inner.( link.sub(/m4a$/, "ogg") ) if File.extname(link) == ".m4a"
+      %Q!<div class='audio'><h3>#{desc}</h3><audio #{attributes.map{|(k,v)| "#{k}='#{v}'" }.join(" ")}>#{inner}#{fallback_text}</audio></div>!.strip.gsub /\s+/, " "
+    end
+
+  end # class
+end # module

data/lib/texttube/filters/embedding_video.rb

@@ -0,0 +1,111 @@
+# encoding: UTF-8
+require_relative "../filterable.rb"
+
+module TextTube
+
+  # Embed video via [embed_SIZE[url|description]]
+  module EmbeddingVideo
+    extend TextTube::Filterable
+  
+    filter_with :embeddingvideo do |text|
+      TextTube::EmbeddingVideo.run text
+    end
+
+    # List of available sites.
+    SITES = {
+      #     "video.google".to_sym => ['http://www.video.google.com/',->(w,h,url){ %Q!! }],
+      #     :brightcove => ['http://www.brightcove.com/',->(w,h,url){ %Q!! }],
+      #     :photobucket => ['http://www.photobucket.com/',->(w,h,url){ %Q!! }],
+      :youtube => {
+        name: 'http://www.youtube.com/',
+        html: ->(w,h,url){ %Q!<iframe title="YouTube video player" class="youtube-player" type="text/html" width="#{w}" height="#{h}" src="#{url}" frameborder="0"></iframe>!.strip},
+        url_morph: ->(orig){ orig.sub( %r{watch\?v=}, 'embed/') }
+      },
+      #     :dailymotion => ['http://dailymotion.com/',->(w,h,url){ %Q!! }],
+      #     :ifilm => ['http://ifilm.com/',->(w,h,url){ %Q!! }],
+      #     :break => ['http://break.com/',->(w,h,url){ %Q!! }],
+      #     :blip => ['http://blip.tv/',->(w,h,url){ %Q!! }],
+      #     :grindtv => ['http://www.grindtv.com/',->(w,h,url){ %Q!! }],
+      #     :metacafe => ['http://metacafe.com/',->(w,h,url){ %Q!! }],
+      #     :myspace => ['http://vids.myspace.com/',->(w,h,url){ %Q!! }],
+      #     :vimeo => ['http://vimeo.com/',->(w,h,url){ %Q!! }],
+      #     :buzznet => ['http://buzznet.com/',->(w,h,url){ %Q!! }],
+      #     :liveleak => ['http://www.liveleak.com/',->(w,h,url){ %Q!! }],
+      #     :stupidvideos => ['http://stupidvideos.com/',->(w,h,url){ %Q!! }],
+      #     :flixya => ['http://www.flixya.com/',->(w,h,url){ %Q!! }],
+      #     :gofish => ['http://gofish.com/',->(w,h,url){ %Q!! }],
+      #     :kewego => ['http://kewego.com/',->(w,h,url){ %Q!! }],
+      #     :lulu => ['http://lulu.tv/',->(w,h,url){ %Q!! }],
+      #     :pandora => ['http://pandora.tv/',->(w,h,url){ %Q!! }],
+      #     :viddler => ['http://www.viddler.com/',->(w,h,url){ %Q!! }],
+      #     :myheavy => ['http://myheavy.com/',->(w,h,url){ %Q!! }],
+      #     :putfile => ['http://putfile.com/',->(w,h,url){ %Q!! }],
+      #     :stupidvideos => ['http://stupidvideos.com/',->(w,h,url){ %Q!! }],
+      #     :vmix => ['http://vmix.com/',->(w,h,url){ %Q!! }],
+      #     :zippyvideos => ['http://zippyvideos.com/',->(w,h,url){ %Q!! }],
+      #     :castpost => ['http://castpost.com/',->(w,h,url){ %Q!! }],
+      #     :dotv => ['http://dotv.com/',->(w,h,url){ %Q!! }],
+      #     :famster => ['http://famster.com/',->(w,h,url){ %Q!! }],
+      #     :gawkk => ['http://gawkk.com/',->(w,h,url){ %Q!! }],
+      #     :tubetorial => ['http://tubetorial.com/',->(w,h,url){ %Q!! }],
+      #     :MeraVideo => ['http://MeraVideo.com/',->(w,h,url){ %Q!! }],
+      #     :Porkolt => ['http://Porkolt.com/',->(w,h,url){ %Q!! }],
+      #     :VideoWebTown => ['http://VideoWebTown.com/',->(w,h,url){ %Q!! }],
+      #     :Vidmax => ['http://Vidmax.com/',->(w,h,url){ %Q!! }],
+      #     :clipmoon => ['http://www.clipmoon.com/',->(w,h,url){ %Q!! }],
+      #     :motorsportmad => ['http://motorsportmad.com/',->(w,h,url){ %Q!! }],
+      #     :thatshow => ['http://www.thatshow.com/',->(w,h,url){ %Q!! }],
+      #     :clipchef => ['http://clipchef.com/',->(w,h,url){ %Q!! }],
+    }
+
+    # Some standard player sizes.
+    SIZES = {
+      small:    [560,345],
+      medium:   [640,390],
+      large:    [853,510],
+      largest:  [1280,750] }
+
+
+
+    #     r_url = %r{
+    #               http(?:s)?\://          #http https ://
+    #               (?:(?:www|vids)\.)?     # www. vids.
+    #               (.+?)                   # domain name (hopefully)
+    #               \.(?:com|tv)            # .com .tv
+    #               /?                      # optional trailing slash
+    #               }x
+
+    # Pattern for deconstructing [embed_SIZE[url|description]]
+    R_link = /             # [embed_SIZE[url|description]]
+    \[embed\_?([a-z]+)?\[        # opening square brackets
+      (\S+)     # link
+      \|      # separator
+      ([^\[]+)  # description
+      \]\]        # closing square brackets
+      /x
+
+
+    # @param [String] content
+    # @param [Hash] options
+    # @return [String]
+    def self.run(content, options={})
+      options ||= {}
+      content.gsub( R_link ) { |m|
+        size,url,desc = $1,$2,$3
+
+        unless size.nil?
+          res = SIZES[size.to_sym] || SIZES[:medium] #resolution
+        else
+          res = SIZES[:medium]
+        end
+
+        #"res: #{res.inspect} size: #{size}, url:#{url}, desc:#{desc}"
+
+        emb_url = SITES[:youtube][:url_morph].(url)
+        SITES[:youtube][:html].(res.first, res.last, emb_url )
+      }
+
+    end
+
+  end # class
+end # module

data/lib/texttube/filters/inside_block.rb

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+require 'nokogiri'
+require_relative "../filterable.rb"
+
+module TextTube
+  
+  # This finds html tags with "markdown='1'" as an attribute, runs markdown over the contents, then removes the markdown attribute, allowing markdown within html blocks
+  module InsideBlock
+    extend TextTube::Filterable
+  
+    filter_with :insideblock do |text|
+      TextTube::InsideBlock.run text
+    end
+    
+    # @param [String] content
+    # @param [Hash] options
+    # @option options [Constant] The markdown parser to use. I'm not sure this bit really works for other parsers than RDiscount.    
+    def self.run( content, options={})   
+      options ||= {} 
+      if options[:markdown_parser].nil?
+        require 'rdiscount' 
+        markdown_parser=RDiscount
+      end
+      doc = Nokogiri::HTML::fragment(content) 
+      
+      (doc/"*[@markdown='1']").each do |ele|  
+        ele.inner_html = markdown_parser.new(ele.inner_html).to_html
+        ele.remove_attribute("markdown")
+      end
+      
+      doc.to_s
+    end # run
+    
+  end # class
+end # module

data/lib/texttube/filters/link_reffing.rb

@@ -0,0 +1,144 @@
+# encoding: UTF-8
+require_relative "../filterable.rb"
+
+module TextTube
+  
+  # @author Iain Barnett
+  # A class to take links in the format `[[link|description]]` and give them a number reference, then output them in markdown format. Note: this is not the same as reference links in markdown, this is more akin to the way books will refer to references or footnotes with a number.
+  #P.S. I don't like to make functions private, we're all adults, so to use this call Link_reffing#run, #format_links is for internal use.
+  module LinkReffing
+    extend Filterable
+    
+    filter_with :linkreffing do |text, options|
+      TextTube::LinkReffing.run text, options
+    end
+    
+    # These are the html codes for superscript 0 - 9
+    UNITS = ['⁰', '¹', '²', '³', '⁴', '⁵', '⁶', '⁷', '⁸', '⁹'] #unicode superscript numbers
+
+    # Matches [[link|description]]
+    Pattern = /              
+          \[\[                      # opening square brackets
+            (?<link>\S+)
+              \s*\|\s*              # separator
+            (?<description>[^\[]+)
+          \]\]                      # closing square brackets
+        /x
+    
+    # a lambda function to transform a link and a number into a markdown reference link.
+    # @param [String] lnk The url.
+    # @param [String] num The reference number.
+    Reffer = ->(lnk, num){ %Q![#{lnk}](##{num} "Jump to reference")!}
+
+    # A lambda to transform a link and a number to a HTML reference link.
+    RefHTMLer = ->(lnk, num){ %Q!<a href="##{num}" title="Jump to reference">#{lnk}</a>!  }
+
+    # A lambda to transform a href and a description into an HTML link.
+    HTMLer = ->(lnk, desc){ %Q! <a href="#{lnk}">#{desc}</a>!  }
+
+    # A lambda to transform a link and a description into an inline Markdown link.
+    Markdowner = ->(lnk, desc){ %Q! [#{desc}](#{lnk})! }
+
+#     Noner = ->(_,_) { "" } # this isn't needed but will sit here as a reminder.
+
+
+    # Takes markdown content with ref links and turns it into 100% markdown.
+    # @param [String] content The markdown content with links to ref.
+    # @option options [#to_s] :format The format of the link you want added. The options are :html, :markdown. The default is :markdown
+    # @option options [#to_s] :kind The kind of link you want added. The options are :reference, :inline, :none. The default is :reference
+    # @option options [String,nil] :div_id ID of the div to wrap reference links in. Defaults to "reflinks". Set to nil or false for no div.
+    # @return [String] The string formatted as markdown e.g. `[http://cheat.errtheblog.com/s/yard/more/and/m...](http://cheat.errtheblog.com/s/yard/more/and/more/and/more/ "http://cheat.errtheblog.com/s/yard/more/and/more/and/more/")`
+    def self.run(content, options={})
+      return content if content.blank?
+      text = content.dup
+      options ||= {}
+      kind = options.fetch :kind, :reference
+      format = options.fetch( :format, :markdown )
+      formatter = if kind == :inline
+                    if format == :html
+                      HTMLer
+                    else
+                      Markdowner
+                    end
+                  elsif kind == :none
+                    nil # none is needed
+                  else # kind == :reference
+                    if format == :html
+                      RefHTMLer
+                    else
+                      Reffer
+                    end
+                  end
+      
+      div_id =  options.has_key?(:div_id) ? 
+                  options[:div_id] :
+                  :reflinks
+
+      cur = 0 #current number
+
+      # if there are no reflinks found
+      # this will remain false
+      # and `divit` won't be run.
+      has_reflinks = false
+
+      links = [] #to store the matches
+      
+      text.gsub! Pattern do |md|  #block to pass to gsub
+        has_reflinks = true
+        if kind == :inline
+          formatter.($1,$2)
+        elsif kind == :none
+          ""
+        else # kind == :reference
+          mags = cur.divmod(10) #get magnitude of number
+          ref_tag = mags.first >= 1 ? 
+                      UNITS[mags.first] :
+                      '' #sort out tens
+  
+          ref_tag += UNITS[mags.last] #units
+          retval = formatter.(ref_tag,cur)
+                     
+          links << [$1, $2, cur] # add to the words list
+          cur += 1 #increase current number
+          retval
+        end
+      end
+
+      if !links.empty?
+        if has_reflinks && div_id
+          "#{text}\n#{LinkReffing.divit( div_id ) { format_links(links) }}"
+        else
+          "#{text}\n#{format_links(links)}"
+        end
+      else
+        text
+      end
+    end
+
+
+    # This func outputs the link as valid markdown.
+    # @param [Array<String,String,Integer>] links A list of 2-length arrays containing the url and the description and the reference number.
+    def self.format_links( links )
+      links.map{ |(link, description, cur)|
+        display_link = link.length >= 45 ? 
+                          link[0,45] + "..." : 
+                          link
+        %Q!\n<a name="#{cur}"></a>#{LeftSq}#{cur}#{RightSq} [#{display_link}](#{link} "#{link}") #{description}\n\n!
+      }.join
+    end
+
+
+    # Wraps things in a div. If no id given, no div.
+    # @param [#to_s] id The ID attribute for the div.
+    def self.divit( id )
+      "<div markdown='1' id='#{id}'>#{ yield }</div>"
+    end
+
+    # HTML code for [
+    LeftSq = "&#91;"
+    # HTML code for ]
+    RightSq = "&#93;"
+    
+  end#class
+ 
+end#module

data/lib/texttube/version.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+
+module TextTube
+  # This library's version.
+  VERSION = "5.0.2"
+end

data/lib/texttube.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+require_relative "./ext/blank.rb"
+require_relative "./ext/to_constant.rb"
+
+# The original. Maybe. I haven't checked.
+module TextTube
+
+  # Require all the filters.
+  # The `map` is there to show the result of this and
+  # show which libs were required (if so desired).
+  # @return [Array<String,TrueClass>]
+  def self.load_all_filters
+    Dir.glob( File.join File.dirname(__FILE__), "/texttube/filters/*.rb" )
+       .reject{|name| name.end_with? "version.rb" }
+       .map{|filter| 
+         tf = require filter
+         [File.basename(filter, ".rb").gsub("_",""), tf]
+       }
+  end
+
+
+end