mdurl-rb 1.0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bfcbf24da2273d2580682fa690c821fc69b23c53
+  data.tar.gz: 87074f454da478a788227b689d89a6d6be676a60
+SHA512:
+  metadata.gz: 347a0b6b36a1802ba392b3a8d01047b94517162fc418162f62b6040126d681e18b12797a6ef8d3a309ba23a38aec5498429174017c0c4aa222000d1efa4d6d1a
+  data.tar.gz: ce81db1bde29553a0776ae967523657e94c38fafec405f76fe8f6d3b0b66a9f6cedfd2f5dcdb91c54671892f6d2f3c2c98acf862853274ef65602ba33919897e

data/README.md

@@ -0,0 +1,104 @@
+# mdurl
+
+[![Gem Version](https://badge.fury.io/rb/mdurl-rb.svg)](http://badge.fury.io/rb/mdurl-rb)
+
+URL utilities for [motion-markdown-it](https://github.com/digitalmoksha/motion-markdown-it) parser, for both Ruby and RubyMotion
+
+This gem is a port of the [mdurl javascript package](https://github.com/markdown-it/mdurl) by Vitaly Puzrin and Alex Kocharin, that is used for the [markdown-it](https://github.com/markdown-it/markdown-it) package
+
+## API
+
+_As this gem was ported from the Javascript version, there may still be some mixture of Javascript terminology below'_
+
+### MDUrl::Encode.encode(str [, exclude, keepEncoded]) -> String
+
+Percent-encode a string, avoiding double encoding. Don't touch `/a-zA-Z0-9/` +
+excluded chars + `/%[a-fA-F0-9]{2}/` (if not disabled). Broken surrorates are
+replaced with `U+FFFD`.
+
+Params:
+
+- __str__ - input string.
+- __exclude__ - optional, `;/?:@&=+$,-_.!~*'()#`. Additional chars to keep intact
+  (except `/a-zA-Z0-9/`).
+- __keepEncoded__ - optional, `true`. By default it skips already encoded sequences
+  (`/%[a-fA-F0-9]{2}/`). If set to `false`, `%` will be encoded.
+
+
+### MDUrl::Encode::DEFAULT_CHARACTERS, MDUrl::Encode::COMPONENT_CHARACTERS
+
+You can use these constants as second argument to `encode` function.
+
+ - `DEFAULT_CHARACTERS` is the same exclude set as in the standard `encodeURI()` function
+ - `COMPONENT_CHARACTERS` is the same exclude set as in the `encodeURIComponent()` function
+
+For example, `MDUrl::Encode.encode('something', MDUrl::Encode::COMPONENT_CHARACTERS, true)` is roughly the equivalent of
+the `encodeURIComponent()` function in Javascript (except `encode()` doesn't throw).
+
+
+### MDUrl::Decode.decode(str [, exclude]) -> String
+
+Decode percent-encoded string. Invalid percent-encoded sequences (e.g. `%2G`)
+are left as is. Invalid UTF-8 characters are replaced with `U+FFFD`.
+
+
+Params:
+
+- __str__ - input string.
+- __exclude__ - set of characters to leave encoded, optional, `;/?:@&=+$,#`.
+
+
+### MDUrl::Decode::DEFTAULT_CHARS, MDUrl::Decode::COMPONENT_CHARS
+
+You can use these constants as second argument to `decode` function.
+
+ - `DEFTAULT_CHARS` is the same exclude set as in the standard `decodeURI()` function
+ - `COMPONENT_CHARS` is the same exclude set as in the `decodeURIComponent()` function
+
+For example, `MDUrl::Decode.decode('something', MDUrl::Decode::DEFTAULT_CHARS)` has the same behavior as
+`decodeURI('something')` in javascript on a correctly encoded input.
+
+
+### MDUrl::Url.parse(url, slashesDenoteHost) -> urlObs
+
+Parse url string. Similar to node's [url.parse](http://nodejs.org/api/url.html#url_url_parse_urlstr_parsequerystring_slashesdenotehost), but without any
+normalizations and query string parse.
+
+ - __url__ - input url (string)
+ - __slashesDenoteHost__ - if url starts with `//`, expect a hostname after it. Optional, `false`.
+
+Result (hash):
+
+- protocol
+- slashes
+- auth
+- port
+- hostname
+- hash
+- search
+- pathname
+
+Difference with node's `url`:
+
+1. No leading slash in paths, e.g. in `url.parse('http://foo?bar')` pathname is
+   ``, not `/`
+2. Backslashes are not replaced with slashes, so `http:\\example.org\` is
+   treated like a relative path
+3. Trailing colon is treated like a part of the path, i.e. in
+   `http://example.org:foo` pathname is `:foo`
+4. Nothing is URL-encoded in the resulting object, (in joyent/node some chars
+   in auth and paths are encoded)
+5. `url.parse()` does not have `parseQueryString` argument
+6. Removed extraneous result properties: `host`, `path`, `query`, etc.,
+   which can be constructed using other parts of the url.
+
+
+### MDUrl::Format.format(urlObject)
+
+Format an object previously obtained with `.parse()` function. Similar to node's
+[url.format](http://nodejs.org/api/url.html#url_url_format_urlobj).
+
+
+## License
+
+[MIT](https://github.com/markdown-it/mdurl/blob/master/LICENSE)

data/lib/mdurl-rb/decode.rb

@@ -0,0 +1,145 @@
+module MDUrl
+  module Decode
+
+    @@decodeCache = {};
+
+    DEFTAULT_CHARS   = ';/?:@&=+$,#'
+    COMPONENT_CHARS  = ''
+
+
+    #------------------------------------------------------------------------------
+    def self.getDecodeCache(exclude)
+      cache = @@decodeCache[exclude]
+      return cache if (cache)
+
+      cache = @@decodeCache[exclude] = []
+
+      (0...128).each do |i|
+        ch = i.chr
+        cache.push(ch)
+      end
+
+      (0...exclude.length).each do |i|
+        ch = exclude[i].ord
+        cache[ch] = '%' + ('0' + ch.to_s(16).upcase).slice(-2, 2)
+      end
+
+      return cache
+    end
+
+
+    # Decode percent-encoded string.
+    #------------------------------------------------------------------------------
+    def self.decode(string, exclude = nil)
+      if !exclude.is_a? String
+        exclude = DEFTAULT_CHARS
+      end
+
+      cache = getDecodeCache(exclude)
+
+      return string.gsub(/(%[a-f0-9]{2})+/i) do |seq|
+        result = ''
+
+        i = 0
+        l = seq.length
+        while i < l
+          b1 = seq.slice((i + 1)...(i + 3)).to_i(16)
+
+          if (b1 < 0x80)
+            result += cache[b1]
+            i += 3
+            next
+          end
+
+          if ((b1 & 0xE0) == 0xC0 && (i + 3 < l))
+            # 110xxxxx 10xxxxxx
+            b2 = seq.slice((i + 4)...(i + 6)).to_i(16)
+
+            if ((b2 & 0xC0) == 0x80)
+              char = ((b1 << 6) & 0x7C0) | (b2 & 0x3F)
+
+              if (char < 0x80)
+                result += "\ufffd\ufffd"
+              else
+                result += char.chr(Encoding::UTF_8)
+              end
+
+              i += 6
+              next
+            end
+          end
+
+          if ((b1 & 0xF0) == 0xE0 && (i + 6 < l))
+            # 1110xxxx 10xxxxxx 10xxxxxx
+            b2 = seq.slice((i + 4)...(i + 6)).to_i(16)
+            b3 = seq.slice((i + 7)...(i + 9)).to_i(16)
+
+            if ((b2 & 0xC0) == 0x80 && (b3 & 0xC0) == 0x80)
+              char = ((b1 << 12) & 0xF000) | ((b2 << 6) & 0xFC0) | (b3 & 0x3F)
+
+              if (char < 0x800 || (char >= 0xD800 && char <= 0xDFFF))
+                result += "\ufffd\ufffd\ufffd"
+              else
+                result += char.chr(Encoding::UTF_8)
+              end
+
+              i += 9
+              next
+            end
+          end
+
+          if ((b1 & 0xF8) == 0xF0 && (i + 9 < l))
+            # 111110xx 10xxxxxx 10xxxxxx 10xxxxxx
+            b2 = seq.slice((i + 4)...(i + 6)).to_i(16)
+            b3 = seq.slice((i + 7)...(i + 9)).to_i(16)
+            b4 = seq.slice((i + 10)...(i + 12)).to_i(16)
+
+            if ((b2 & 0xC0) == 0x80 && (b3 & 0xC0) == 0x80 && (b4 & 0xC0) == 0x80)
+              char = ((b1 << 18) & 0x1C0000) | ((b2 << 12) & 0x3F000) | ((b3 << 6) & 0xFC0) | (b4 & 0x3F)
+
+              if (char < 0x10000 || char > 0x10FFFF)
+                result += "\ufffd\ufffd\ufffd\ufffd"
+              else
+                # TODO don't know how to handle surrogate pairs properly.
+                char   -= 0x10000
+                result += [0xD800 + (char >> 10), 0xDC00 + (char & 0x3FF)].map{|c| c.chr(Encoding::UTF_8)}.join
+
+                # high = ((char - 0x10000) / 0x400).floor + 0xD800
+                # low  = ((char - 0x10000) % 0x400) + 0xDC00
+                # result += '\u' + [high, low].map { |x| x.to_s(16) }.join('\u').downcase
+              end
+
+              i += 12
+              next
+            end
+          end
+
+          result += "\ufffd"
+          i += 3
+        end
+
+        result
+      end
+    end
+
+  end
+end
+
+# https://gist.github.com/kreeger/4480326
+# class Fixnum
+#   def to_surrogate_pair
+#     if self >= 0x10000 && self <= 0x10FFFF
+#       high = ((self - 0x10000) / 0x400).floor + 0xD800
+#       low = ((self - 0x10000) % 0x400) + 0xDC00
+#     end
+#     '\U' + [high, low].map { |x| x.to_s(16) }.join('\U').upcase
+#   end
+#
+# end
+#
+# class String
+#   def to_hex
+#     self.gsub('\U000', '0x').to_i(16)
+#   end
+# end
+#

data/lib/mdurl-rb/encode.rb

@@ -0,0 +1,100 @@
+module MDUrl
+  module Encode
+
+    DEFAULT_CHARACTERS   = ";/?:@&=+$,-_.!~*'()#"
+    COMPONENT_CHARACTERS = "-_.!~*'()"
+
+    @@encodeCache = {}
+
+
+    # Create a lookup array where anything but characters in `chars` string
+    # and alphanumeric chars is percent-encoded.
+    #------------------------------------------------------------------------------
+    def self.getEncodeCache(exclude)
+      cache = @@encodeCache[exclude]
+      return cache if (cache)
+
+      cache = @@encodeCache[exclude] = []
+
+      (0...128).each do |i|
+        ch = i.chr
+
+        if (/^[0-9a-z]$/i =~ ch)
+          # always allow unencoded alphanumeric characters
+          cache.push(ch)
+        else
+          cache.push('%' + ('0' + i.to_s(16).upcase).slice(-2, 2))
+        end
+      end
+
+      (0...exclude.length).each do |i|
+        cache[exclude[i].ord] = exclude[i]
+      end
+
+      return cache
+    end
+
+
+    # Encode unsafe characters with percent-encoding, skipping already
+    # encoded sequences.
+    #
+    #  - string       - string to encode
+    #  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)
+    #  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)
+    #------------------------------------------------------------------------------
+    def self.encode(string, exclude = nil, keepEscaped = nil)
+      result = ''
+
+      if !exclude.is_a? String
+        # encode(string, keepEscaped)
+        keepEscaped = exclude
+        exclude = DEFAULT_CHARACTERS
+      end
+
+      if keepEscaped == nil
+        keepEscaped = true
+      end
+
+      cache = getEncodeCache(exclude)
+
+      i = 0
+      l = string.length
+      while i < l
+        code = string[i].ord
+
+        if (keepEscaped && code == 0x25 && i + 2 < l) #  %
+          if (/^[0-9a-f]{2}$/i =~ (string.slice((i + 1)...(i + 3))))
+            result += string.slice(i...(i + 3))
+            i += 3
+            next
+          end
+        end
+
+        if (code < 128)
+          result += cache[code]
+          i += 1
+          next
+        end
+
+        if (code >= 0xD800 && code <= 0xDFFF)
+          if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l)
+            nextCode = string[i + 1].ord
+            if (nextCode >= 0xDC00 && nextCode <= 0xDFFF)
+              result += CGI::escape(string[i] + string[i + 1])
+              i += 2
+              next
+            end
+          end
+          result += '%EF%BF%BD'
+          i += 1
+          next
+        end
+
+        result += CGI::escape(string[i])
+        i += 1
+      end
+
+      return result
+    end
+  end
+end

data/lib/mdurl-rb/format.rb

@@ -0,0 +1,28 @@
+module MDUrl
+  module Format
+
+    #------------------------------------------------------------------------------
+    def self.format(url)
+      result = ''
+
+      result += url.protocol || ''
+      result += url.slashes ? '//' : ''
+      result += url.auth ? url.auth + '@' : ''
+
+      if (url.hostname && url.hostname.index(':') != nil)
+        # ipv6 address
+        result += '[' + url.hostname + ']'
+      else
+        result += url.hostname || ''
+      end
+
+      result += url.port ? ':' + url.port : ''
+      result += url.pathname || ''
+      result += url.search || ''
+      result += url.hash || ''
+
+      return result
+    end
+    
+  end
+end

data/lib/mdurl-rb/parse.rb

@@ -0,0 +1,304 @@
+# Copyright Joyent, Inc. and other Node contributors.
+#
+# 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.
+
+#
+# Changes from joyent/node:
+#
+# 1. No leading slash in paths,
+#    e.g. in `url.parse('http://foo?bar')` pathname is ``, not `/`
+#
+# 2. Backslashes are not replaced with slashes,
+#    so `http:\\example.org\` is treated like a relative path
+#
+# 3. Trailing colon is treated like a part of the path,
+#    i.e. in `http://example.org:foo` pathname is `:foo`
+#
+# 4. Nothing is URL-encoded in the resulting object,
+#    (in joyent/node some chars in auth and paths are encoded)
+#
+# 5. `url.parse()` does not have `parseQueryString` argument
+#
+# 6. Removed extraneous result properties: `host`, `path`, `query`, etc.,
+#    which can be constructed using other parts of the url.
+#
+
+module MDUrl
+  class Url
+
+    attr_accessor   :protocol, :slashes, :hostname, :pathname, :auth, :port, :search, :hash
+    
+    # Reference: RFC 3986, RFC 1808, RFC 2396
+
+    # define these here so at least they only have to be
+    # compiled once on the first module load.
+    PROTOCOL_PATTERN  = /^([a-z0-9.+-]+:)/i
+    PORT_PATTERN      = /:[0-9]*$/
+
+    # Special case for a simple path URL
+    SIMPLE_PATH_PATTERN = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/
+
+    # RFC 2396: characters reserved for delimiting URLs.
+    # We actually just auto-escape these.
+    DELIMS = [ '<', '>', '"', '`', ' ', '\r', '\n', '\t' ]
+
+    # RFC 2396: characters not allowed for various reasons.
+    UNWISE = [ '{', '}', '|', '\\', '^', '`' ].concat(DELIMS)
+
+    # Allowed by RFCs, but cause of XSS attacks.  Always escape these.
+    AUTO_ESCAPE = [ '\'' ].concat(UNWISE)
+    # Characters that are never ever allowed in a hostname.
+    # Note that any invalid chars are also handled, but these
+    # are the ones that are *expected* to be seen, so we fast-path
+    # them.
+    NON_HOST_CHARS = [ '%', '/', '?', ';', '#' ].concat(AUTO_ESCAPE)
+    HOST_ENDING_CHARS = [ '/', '?', '#' ]
+    HOSTNAME_MAX_LEN = 255
+    HOSTNAME_PART_PATTERN = /^[+a-z0-9A-Z_-]{0,63}$/
+    HOSTNAME_PART_START = /^([+a-z0-9A-Z_-]{0,63})(.*)$/
+    # protocols that can allow "unsafe" and "unwise" chars.
+    # protocols that never have a hostname.
+    HOSTLESS_PROTOCOL = {
+      'javascript' => true,
+      'javascript:' => true
+    }
+    # protocols that always contain a # bit.
+    SLASHED_PROTOCOL = {
+      'http' => true,
+      'https' => true,
+      'ftp' => true,
+      'gopher' => true,
+      'file' => true,
+      'http:' => true,
+      'https:' => true,
+      'ftp:' => true,
+      'gopher:' => true,
+      'file:' => true
+    }
+
+    #------------------------------------------------------------------------------
+    def self.urlParse(url, slashesDenoteHost = false)
+      return url if (url && url.is_a?(Url))
+
+      u = Url.new
+      u.parse(url, slashesDenoteHost)
+      return u
+    end
+
+    #------------------------------------------------------------------------------
+    def parse(url, slashesDenoteHost = false)
+      rest = url
+
+      # trim before proceeding.
+      # This is to support parse stuff like "  http://foo.com  \n"
+      rest = rest.strip
+
+      if (!slashesDenoteHost && url.split('#').length == 1)
+        # Try fast path regexp
+        simplePath = SIMPLE_PATH_PATTERN.match(rest)
+        if (simplePath)
+          @pathname = simplePath[1]
+          if (simplePath[2])
+            @search = simplePath[2]
+          end
+          return self
+        end
+      end
+
+      proto = PROTOCOL_PATTERN.match(rest)
+      if (proto)
+        proto      = proto[0]
+        lowerProto = proto.downcase
+        @protocol  = proto
+        rest       = rest[proto.length..-1]
+      end
+
+      # figure out if it's got a host
+      # user@server is *always* interpreted as a hostname, and url
+      # resolution will treat //foo/bar as host=foo,path=bar because that's
+      # how the browser resolves relative URLs.
+      if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/))
+        slashes = rest[0...2] == '//'
+        if (slashes && !(proto && HOSTLESS_PROTOCOL[proto]))
+          rest = rest[2..-1]
+          @slashes = true
+        end
+      end
+
+      if (!HOSTLESS_PROTOCOL[proto] &&
+          (slashes || (proto && !SLASHED_PROTOCOL[proto])))
+
+        # there's a hostname.
+        # the first instance of /, ?, ;, or # ends the host.
+        #
+        # If there is an @ in the hostname, then non-host chars *are* allowed
+        # to the left of the last @ sign, unless some host-ending character
+        # comes *before* the @-sign.
+        # URLs are obnoxious.
+        #
+        # ex:
+        # http://a@b@c/ => user:a@b host:c
+        # http://a@b?@c => user:a host:c path:/?@c
+
+        # v0.12 TODO(isaacs): This is not quite how Chrome does things.
+        # Review our test case against browsers more comprehensively.
+
+        # find the first instance of any HOST_ENDING_CHARS
+        hostEnd = -1
+        (0...HOST_ENDING_CHARS.length).each do |i|
+          hec = rest.index(HOST_ENDING_CHARS[i])
+          if (hec != nil && (hostEnd == -1 || hec < hostEnd))
+            hostEnd = hec
+          end
+        end
+
+        # at this point, either we have an explicit point where the
+        # auth portion cannot go past, or the last @ char is the decider.
+        if (hostEnd == -1)
+          # atSign can be anywhere.
+          atSign = rest.rindex('@')
+        else
+          # atSign must be in auth portion.
+          # http://a@b/c@d => host:b auth:a path:/c@d
+          # atSign = rest.lastIndexOf('@', hostEnd);
+          atSign = rest[0..hostEnd].rindex('@')
+        end
+
+        # Now we have a portion which is definitely the auth.
+        # Pull that off.
+        if (atSign != nil)
+          auth = rest.slice(0...atSign)
+          rest = rest.slice((atSign + 1)..-1)
+          @auth = auth
+        end
+
+        # the host is the remaining to the left of the first non-host char
+        hostEnd = -1
+        (0...NON_HOST_CHARS.length).each do |i|
+          hec = rest.index(NON_HOST_CHARS[i])
+          if (hec != nil && (hostEnd == -1 || hec < hostEnd))
+            hostEnd = hec
+          end
+        end
+        # if we still have not hit it, then the entire thing is a host.
+        if (hostEnd === -1)
+          hostEnd = rest.length
+        end
+
+        hostEnd -= 1 if (rest[hostEnd - 1] == ':')
+        host = rest.slice(0...hostEnd)
+        rest = rest.slice(hostEnd..-1)
+
+        # pull out port.
+        self.parseHost(host)
+
+        # we've indicated that there is a hostname,
+        # so even if it's empty, it has to be present.
+        @hostname = @hostname || ''
+
+        # if hostname begins with [ and ends with ]
+        # assume that it's an IPv6 address.
+        ipv6Hostname = @hostname[0] == '[' &&
+            @hostname[@hostname.length - 1] == ']'
+
+        # validate a little.
+        if (!ipv6Hostname)
+          hostparts = @hostname.split(/\./)
+          (0...hostparts.length).each do |i|
+            part = hostparts[i]
+            next if (!part)
+            if (!part.match(HOSTNAME_PART_PATTERN))
+              newpart = ''
+              (0...part.length).each do |j|
+                if (part[j].ord > 127)
+                  # we replace non-ASCII char with a temporary placeholder
+                  # we need this to make sure size of hostname is not
+                  # broken by replacing non-ASCII by nothing
+                  newpart += 'x'
+                else
+                  newpart += part[j]
+                end
+              end
+              # we test again with ASCII char only
+              if (!newpart.match(HOSTNAME_PART_PATTERN))
+                validParts = hostparts.slice(0...i)
+                notHost = hostparts.slice((i + 1)..-1)
+                bit = part.match(HOSTNAME_PART_START)
+                if (bit)
+                  validParts.push(bit[1])
+                  notHost.unshift(bit[2])
+                end
+                if (notHost.length)
+                  rest = notHost.join('.') + rest
+                end
+                @hostname = validParts.join('.')
+                break
+              end
+            end
+          end
+        end
+
+        if (@hostname.length > HOSTNAME_MAX_LEN)
+          @hostname = ''
+        end
+
+        # strip [ and ] from the hostname
+        # the host field still retains them, though
+        if (ipv6Hostname)
+          @hostname = @hostname[1, @hostname.length - 2]
+        end
+      end
+
+      # chop off from the tail first.
+      hash = rest.index('#')
+      if (hash != nil)
+        # got a fragment string.
+        @hash = rest.slice(hash..-1)
+        rest  = rest.slice(0...hash)
+      end
+      qm = rest.index('?')
+      if (qm != nil)
+        @search = rest.slice(qm..-1)
+        rest    = rest.slice(0...qm)
+      end
+      @pathname = rest if !rest.nil? && rest != ''
+      if (SLASHED_PROTOCOL[lowerProto] &&
+          @hostname && !@pathname)
+        @pathname = ''
+      end
+
+      return self
+    end
+
+    #------------------------------------------------------------------------------
+    def parseHost(host)
+      port = PORT_PATTERN.match(host)
+      if (port)
+        port = port[0]
+        if (port != ':')
+          @port = port.slice(1..-1)
+        end
+        host = host[0, host.length - port.length]
+      end
+      @hostname = host if (host)
+    end
+
+  end
+end

data/lib/mdurl-rb/version.rb

@@ -0,0 +1,5 @@
+module MDUrl
+
+  VERSION = '1.0.0.1'
+
+end