cdnget 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9204fce30417104ddfeb1a49af1c1e770c630cc1
+  data.tar.gz: 1e9dc0c2d1fba34882a0dd5c6fc26a8ccc6edb57
+SHA512:
+  metadata.gz: 087992a00501a6d1f3dd179a741b708eed1c80266666c0a61f8465325d2c7f0f7592ecc8015c3edb7e0987613a811e92fba0e4b7ecdb058a54b68f3f8a0b6f43
+  data.tar.gz: 1bed28d10dc90f2e2ab241178dc74a9762a866efe5860f31c2eab01a4f6377978653756932ddd8a2a170bbd9061fa3a77a78ecb5493dbf05b48ce0fdf76a27ce

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+$Copyright: copyright(c) 2016 kuwata-lab.com all rights reserved $
+
+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.

data/README.md

@@ -0,0 +1,45 @@
+CDNget
+======
+
+($Release: 0.1.0 $)
+
+CDNget is a utility script to download files from CDNJS, jsDelivr or Google.
+
+
+Install
+-------
+
+    $ gem install cdnget
+
+Or:
+
+    $ curl -sO https://github.com/kwatch/cdnget/raw/ruby-release/bin/cdnget
+    $ chmod a+x cdnget
+    $ sudo cp cdnget /usr/local/bin
+
+CDNget is implemented in Ruby and requires Ruby >= 2.0.
+
+
+Usage
+-----
+
+    $ cdnget                               # list CDN (cdnjs/jsdelivr/google)
+    $ cdnget [-q] cdnjs                    # list libraries
+    $ cdnget [-q] cdnjs '*jquery*'         # search libraries
+    $ cdnget [-q] cdnjs jquery             # list library versions
+    $ cdnget [-q] cdnjs jquery 2.2.0       # list library files
+    $ cdnget [-q] cdnjs jquery 2.2.0 /tmp  # download files
+    /tmp/jquery/2.2.0/jquery.js ... Done (258,388 byte)
+    /tmp/jquery/2.2.0/jquery.min.js ... Done (85,589 byte)
+    /tmp/jquery/2.2.0/jquery.min.map ... Done (129,544 byte)
+
+    $ ls /tmp/jquery/2.2.0
+    jquery.js	jquery.min.js	jquery.min.map
+
+
+Copyright and License
+---------------------
+
+$Copyright: copyright(c) 2016 kuwata-lab.com all rights reserved $
+
+$License: MIT License $

data/Rakefile

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+
+###
+
+RELEASE   = '$Release: 0.1.0 $'.split()[1]
+COPYRIGHT = 'copyright(c) 2016 kuwata-lab.com all rights reserved'
+LICENSE   = 'MIT License'
+
+PROJECT   = 'cdnget'
+
+
+### helpers
+
+def run(command)
+  print '[rake]$ '; sh command
+end
+
+def edit_content(content, release=RELEASE)
+  s = content
+  s = s.gsub /\$Release\:.*?\$/,   "$Release\: #{release} $"
+  s = s.gsub /\$Copyright\:.*?\$/, "$Copyright\: #{COPYRIGHT} $"
+  s = s.gsub /\$License\:.*?\$/,   "$License\: #{LICENSE} $"
+  s = s.gsub /\$Release\$/,   release
+  s = s.gsub /\$Copyright\$/, COPYRIGHT
+  s = s.gsub /\$License\$/,   LICENSE
+  s
+end
+
+def load_gemspec
+  spec = eval File.read("#{PROJECT}.gemspec", encoding: 'utf-8')
+  return spec
+end
+
+
+### tasks
+
+
+#task :default => :test
+
+desc "run test scripts"
+task :test do
+  #sh "ruby -r minitest/autorun test/*_test.rb"
+  run "ruby test/#{PROJECT}_test.rb"
+end
+
+
+desc "remove *.rbc"
+task :clean do
+  rm_f [Dir.glob("lib/**/*.rbc"), Dir.glob("test/**/*.rbc")]
+end
+
+
+desc "how to release"
+task :howtorelease do
+  rel = ENV['rel'] || RELEASE
+  ver = rel.sub(/\.\d+$/,'')
+  patch_zero = !! (rel =~ /\.0$/)
+  puts <<END
+$ git branch | grep '\*'
+* ruby-dev
+$ git checkout #{patch_zero ? '-b ': ''}ruby-#{ver}
+$ rake edit rel=#{rel}
+$ git diff
+$ git commit -a -m "ruby: release preparation for #{rel}"
+$ rake package
+$ rake publish
+END
+end
+
+
+desc "create 'bin/cdnget'"
+task :bin do
+  material = "lib/cdnget.rb"
+  product  = "bin/cdnget"
+  run %Q`cat #{material} | awk '{c=""}/if __FILE__/{f=1;c="#"}f&&/end/{c="#"}{print c $0}' > #{product}`
+  run %Q`chmod a+x #{product}`
+end
+
+
+desc "edit '$Release\:...$' in files"
+task :edit => :bin do
+  rel = ENV['rel']
+  unless rel
+    $stderr.puts "*** Release number is not speicified"
+    $stderr.puts "*** Usage: rake edit rel=X.X.X"
+    raise StandardError
+  end
+  spec = load_gemspec()
+  spec.files.each do |fpath|
+    if fpath =~ /\.(gz|jpg|png|form)\z/
+      puts "[ignore] #{fpath}"
+      next
+    end
+    s1 = File.open(fpath, encoding: 'utf-8') {|f| f.read() }
+    s2 = edit_content(s1, rel)
+    if s1 == s2
+      puts "[skip] #{fpath}"
+    else
+      puts "[Edit] #{fpath}"
+      File.open(fpath, 'w', encoding: 'utf-8') {|f| f.write(s2) }
+    end
+  end
+end
+
+
+desc "create rubygem pacakge"
+task :package do
+  spec = load_gemspec()
+  name = spec.name
+  ver  = spec.version
+  run "gem build #{name}.gemspec"
+  puts ""
+  puts "## files"
+  puts spec.files.collect {|x| "- #{x}" }
+end
+
+
+desc "release gem"
+task :publish do
+  diff = `git diff --stat`
+  if diff && ! diff.empty?
+    raise "[ERROR] Please commit changes before publishing gem."
+  end
+  #
+  spec = load_gemspec()
+  name = spec.name
+  ver  = spec.version
+  #
+  gem = "#{name}-#{ver}.gem"
+  File.exist?(gem)  or
+    raise "[ERROR] run 'rake package' before publishing gem."
+  mtime = File.mtime(gem)
+  ! spec.files.any? {|fpath| File.mtime(fpath) >= mtime }  or
+    raise "[ERROR] run 'rake package' again because gem file seems obsoleted."
+  #
+  print "Upload #{gem}. OK? [y/N]: "
+  if $stdin.gets() =~ /[yY]/
+    run "gem push #{gem}"
+    run "git push -u origin `git rev-parse --abbrev-ref HEAD`"
+    run "git push -f origin ruby-release"
+    run "git tag ruby-#{ver}"
+    run "git push --tags"
+  end
+end

data/bin/cdnget

@@ -0,0 +1,530 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+##
+## Download files from CDN (CDNJS, Google, jsDelivr).
+##
+## - CDNJS    (https://cdnjs.com/)
+## - Google   (https://developers.google.com/speed/libraries/)
+## - jsDelivr (https://www.jsdelivr.com/)
+##
+## Example:
+##  $ cdnget                                # list public CDN
+##  $ cdnget [-q] cdnjs                     # list libraries
+##  $ cdnget [-q] cdnjs jquery              # list versions
+##  $ cdnget [-q] cdnjs jquery 2.2.0        # list files
+##  $ cdnget [-q] cdnjs jquery 2.2.0 /tmp   # download files
+##
+
+require 'open-uri'
+require 'json'
+require 'fileutils'
+
+
+module CDNGet
+
+
+  RELEASE = '$Release: 0.1.0 $'.split()[1]
+
+  CLASSES = []
+
+
+  class Base
+
+    def self.inherited(klass)
+      CLASSES << klass
+    end
+
+    def list()
+      raise NotImplementedError.new("#{self.class.name}#list(): not implemented yet.")
+    end
+
+    def find(library)
+      raise NotImplementedError.new("#{self.class.name}#find(): not implemented yet.")
+    end
+
+    def get(library, version)
+      raise NotImplementedError.new("#{self.class.name}#get(): not implemented yet.")
+    end
+
+    def download(library, version, basedir=".", quiet: false)
+      validate(library, version)
+      File.exist?(basedir)  or
+        raise CommandError.new("#{basedir}: not exist.")
+      File.directory?(basedir)  or
+        raise CommandError.new("#{basedir}: not a directory.")
+      target_dir = File.join(basedir, library, version)
+      d = get(library, version)
+      d[:files].each do |file|
+        filepath = File.join(target_dir, file)
+        dirpath  = File.dirname(filepath)
+        print "#{filepath} ..." unless quiet
+        url = File.join(d[:baseurl], file)   # not use URI.join!
+        content = fetch(url)
+        content = content.force_encoding('ascii-8bit')
+        print " Done (#{format_integer(content.bytesize)} byte)" unless quiet
+        FileUtils.mkdir_p(dirpath) unless File.exist?(dirpath)
+        unchanged = File.exist?(filepath) && File.read(filepath, mode: 'rb') == content
+        if unchanged
+          print " (Unchanged)" unless quiet
+        else
+          File.open(filepath, 'wb') {|f| f.write(content) }
+        end
+        puts() unless quiet
+      end
+      nil
+    end
+
+    protected
+
+    def fetch(url, library=nil)
+      begin
+        html = open(url, 'rb') {|f| f.read() }
+        return html
+      rescue OpenURI::HTTPError => ex
+        raise CommandError.new("GET #{url} : #{ex.message}")
+      end
+    end
+
+    def validate(library, version)
+      if library
+        library =~ /\A[-.\w]+\z/  or
+          raise ArgumentError.new("#{library.inspect}: Unexpected library name.")
+      end
+      if version
+        version =~ /\A\d+(\.\d+)+([-.\w]+)?/  or
+          raise ArgumentError.new("#{version.inspect}: Unexpected version number.")
+      end
+    end
+
+    def format_integer(value)
+      return value.to_s.reverse.scan(/..?.?/).collect {|s| s.reverse }.reverse.join(',')
+    end
+
+  end
+
+
+  class HttpError < StandardError
+  end
+
+
+  class CDNJS < Base    # TODO: use jsdelivr api
+    CODE = "cdnjs"
+    SITE_URL = 'https://cdnjs.com/'
+
+    def fetch(url, library=nil)
+      begin
+        html = open(url, 'rb') {|f| f.read() }
+        if library
+          html =~ /<h1\b.*?>(.*?)<\/h1>/  or
+            raise CommandError.new("#{library}: Library not found.")
+          library == $1.strip()  or
+            raise CommandError.new("#{library}: Library not found (maybe '#{$1.strip()}'?).")
+        end
+        return html
+      rescue OpenURI::HTTPError => ex
+        raise HttpError.new("GET #{url} : #{ex.message}")
+      end
+    end
+    protected :fetch
+
+    def list
+      libs = []
+      html = fetch("https://cdnjs.com/libraries")
+      html.scan(/<td\b(.*?)<\/td>/m) do |str,|
+        name = desc = nil
+        name = $1 if str =~ /href="\/libraries\/([-.\w]+)">\s*\1\s*<\/a>/
+        desc = $1.strip if str =~ /<div style="display: none;">(.*?)<\/div>/m
+        libs << {name: name, desc: desc} if name
+      end
+      return libs.sort_by {|d| d[:name] }.uniq
+    end
+
+    def find(library)
+      validate(library, nil)
+      html = fetch("https://cdnjs.com/libraries/#{library}", library)
+      versions = []
+      html.scan(/<option value="([^"]+)" *(?:selected)?>/) do |ver,|
+        versions << ver
+      end
+      desc = tags = nil
+      if html =~ /<p>(.*?)<\/p>\s*<em>(.*?)<\/em>/
+        desc = $1
+        tags = $2
+      end
+      return {
+        name: library,
+        desc: desc,
+        tags: tags,
+        versions: versions,
+      }
+    end
+
+    def get(library, version)
+      validate(library, version)
+      html = fetch("https://cdnjs.com/libraries/#{library}/#{version}", library)
+      baseurl = "https://cdnjs.cloudflare.com/ajax/libs/#{library}/#{version}"
+      urls  = []
+      files = []
+      rexp = %r`>(#{Regexp.escape(baseurl)}/([^<]+))<\/p>`
+      html.scan(%r`>(#{Regexp.escape(baseurl)}/([^<]+))<\/p>`) do |url, file|
+        urls  << url .gsub(/&#x2F;/, '/')
+        files << file.gsub(/&#x2F;/, '/')
+      end
+      return {
+        name:     library,
+        version:  version,
+        urls:     urls,
+        files:    files,
+        baseurl:  baseurl,
+      }
+    end
+
+  end
+
+
+  class JSDelivr < Base
+    CODE = "jsdelivr"
+    SITE_URL = "https://www.jsdelivr.com/"
+    API_URL  = "https://api.jsdelivr.com/v1/jsdelivr/libraries"
+
+    def list
+      json = fetch("#{API_URL}?fields=name,description,homepage")
+      arr = JSON.load(json)
+      return arr.collect {|d|
+        {name: d["name"], desc: d["description"], site: d["homepage"] }
+      }
+    end
+
+    def find(library)
+      validate(library, nil)
+      json = fetch("#{API_URL}?name=#{library}&fields=name,description,homepage,versions")
+      arr = JSON.load(json)
+      d = arr.first  or
+        raise CommandError.new("#{library}: Library not found.")
+      return {
+        name:     d['name'],
+        desc:     d['description'],
+        site:     d['homepage'],
+        versions: d['versions'],
+      }
+    end
+
+    def get(library, version)
+      validate(library, version)
+      baseurl = "https://cdn.jsdelivr.net/#{library}/#{version}"
+      url = "#{API_URL}/#{library}/#{version}"
+      json  = fetch("#{API_URL}/#{library}/#{version}")
+      files = JSON.load(json)
+      ! files.empty?  or
+        raise CommandError.new("#{library}: Library not found.")
+      urls  = files.collect {|x| "#{baseurl}/#{x}" }
+      return {
+        name:     library,
+        version:  version,
+        urls:     urls,
+        files:    files,
+        baseurl:  baseurl,
+      }
+    end
+
+  end
+
+
+  class GoogleCDN < Base    # TODO: use jsdelivr api
+    CODE = "google"
+    SITE_URL = 'https://developers.google.com/speed/libraries/'
+
+    def list
+      libs = []
+      html = fetch("https://developers.google.com/speed/libraries/")
+      rexp = %r`"https://ajax\.googleapis\.com/ajax/libs/([^/]+)/([^/]+)/([^"]+)"`
+      html.scan(rexp) do |lib, ver, file|
+        libs << {name: lib, desc: "latest version: #{ver}" }
+      end
+      return libs.sort_by {|d| d[:name] }.uniq
+    end
+
+    def find(library)
+      validate(library, nil)
+      html = fetch("https://developers.google.com/speed/libraries/")
+      rexp = %r`"https://ajax\.googleapis\.com/ajax/libs/#{library}/`
+      site_url = nil
+      versions = []
+      urls = []
+      found = false
+      html.scan(/<h3\b.*?>.*?<\/h3>\s*<dl>(.*?)<\/dl>/m) do |text,|
+        if text =~ rexp
+          found = true
+          if text =~ /<dt>.*?snippet:<\/dt>\s*<dd>(.*?)<\/dd>/m
+            s = $1
+            s.scan(/\b(?:src|href)="([^"]*?)"/) do |href,|
+              urls << href
+            end
+          end
+          if text =~ /<dt>site:<\/dt>\s*<dd>(.*?)<\/dd>/m
+            s = $1
+            if s =~ %r`href="([^"]+)"`
+              site_url = $1
+            end
+          end
+          text.scan(/<dt>(?:stable |unstable )?versions:<\/dt>\s*<dd\b.*?>(.*?)<\/dd>/m) do
+            s = $1
+            vers = s.split(/,/).collect {|x| x.strip() }
+            versions.concat(vers)
+          end
+          break
+        end
+      end
+      found  or
+        raise CommandError.new("#{library}: Library not found.")
+      return {
+        name: library,
+        site: site_url,
+        urls: urls,
+        versions: versions,
+      }
+    end
+
+    def get(library, version)
+      validate(library, version)
+      d = find(library)
+      d[:versions].find(version)  or
+        raise CommandError.new("#{version}: No such version of #{library}.")
+      urls = d[:urls]
+      if urls
+        rexp = /(\/libs\/#{library})\/[^\/]+/
+        urls = urls.collect {|x| x.gsub(rexp, "\\1/#{version}") }
+      end
+      baseurl = "https://ajax.googleapis.com/ajax/libs/#{library}/#{version}"
+      files = urls ? urls.collect {|x| x[baseurl.length..-1] } : nil
+      return {
+        name:    d[:name],
+        site:    d[:site],
+        urls:    urls,
+        files:   files,
+        baseurl: baseurl,
+        version: version,
+      }
+    end
+
+  end
+
+
+  #class JQueryCDN < Base
+  #  CODE = "jquery"
+  #  SITE_URL = 'https://code.jquery.com/'
+  #end
+
+
+  #class ASPNetCDN < Base
+  #  CODE = "aspnet"
+  #  SITE_URL = 'https://www.asp.net/ajax/cdn/'
+  #end
+
+
+  class CommandError < StandardError
+  end
+
+
+  class Main
+
+    def initialize(script=nil)
+      @script = script || File.basename($0)
+    end
+
+    def help_message
+      script = @script
+      return <<END
+#{script}  -- download files from public CDN
+
+Usage: #{script} [options] [CDN] [library] [version] [directory]
+
+Options:
+  -h, --help        : help
+  -v, --version     : version
+  -q, --quiet       : minimal output
+
+Example:
+  $ #{script}                                # list public CDN
+  $ #{script} [-q] cdnjs                     # list libraries
+  $ #{script} [-q] cdnjs jquery              # list versions
+  $ #{script} [-q] cdnjs jquery 2.2.0        # list files
+  $ #{script} [-q] cdnjs jquery 2.2.0 /tmp   # download files
+END
+    end
+
+    def self.main(args=nil)
+      args ||= ARGV
+      s = self.new().run(*args)
+      puts s if s
+      exit 0
+    rescue CommandError => ex
+      $stderr.puts ex.message
+      exit 1
+    end
+
+    def run(*args)
+      cmdopts = parse_cmdopts(args, "hvq", ["help", "version", "quiet"])
+      return help_message() if cmdopts['h'] || cmdopts['help']
+      return RELEASE + "\n" if cmdopts['v'] || cmdopts['version']
+      @quiet = cmdopts['quiet'] || cmdopts['q']
+      #
+      validate(args[1], args[2])
+      #
+      case args.length
+      when 0
+        return do_list_cdns()
+      when 1
+        cdn_code = args[0]
+        return do_list_libraries(cdn_code)
+      when 2
+        cdn_code, library = args
+        if library.include?('*')
+          return do_search_libraries(cdn_code, library)
+        else
+          return do_find_library(cdn_code, library)
+        end
+      when 3
+        cdn_code, library, version = args
+        return do_get_library(cdn_code, library, version)
+      when 4
+        cdn_code, library, version, basedir = args
+        do_download_library(cdn_code, library, version, basedir)
+        return ""
+      else
+        raise CommandError.new("'#{args[4]}': Too many arguments.")
+      end
+    end
+
+    def validate(library, version)
+      if library && ! library.include?('*')
+        library =~ /\A[-.\w]+\z/  or
+          raise CommandError.new("#{library}: Unexpected library name.")
+      end
+      if version
+        version =~ /\A[-.\w]+\z/  or
+          raise CommandError.new("#{version}: Unexpected version number.")
+      end
+    end
+
+    def parse_cmdopts(cmdargs, short_opts, long_opts)
+      cmdopts = {}
+      while cmdargs[0] && cmdargs[0].start_with?('-')
+        cmdarg = cmdargs.shift
+        if cmdarg == '--'
+          break
+        elsif cmdarg.start_with?('--')
+          cmdarg =~ /\A--(\w[-\w]+)(=.*?)?/  or
+            raise CommandError.new("#{cmdarg}: invalid command option.")
+          name  = $1
+          value = $2 ? $2[1..-1] : true
+          long_opts.include?(name)  or
+            raise CommandError.new("#{cmdarg}: unknown command option.")
+          cmdopts[name] = value
+        elsif cmdarg.start_with?('-')
+          cmdarg[1..-1].each_char do |c|
+            short_opts.include?(c)  or
+              raise CommandError.new("-#{c}: unknown command option.")
+            cmdopts[c] = true
+          end
+        else
+          raise "unreachable"
+        end
+      end
+      return cmdopts
+    end
+
+    def find_cdn(cdn_code)
+      klass = CLASSES.find {|c| c::CODE == cdn_code }  or
+        raise CommandError.new("#{cdn_code}: no such CDN.")
+      return klass.new
+    end
+
+    def render_list(list)
+      if @quiet
+        return list.collect {|d| "#{d[:name]}\n" }.join()
+      else
+        return list.collect {|d| "%-20s  # %s\n" % [d[:name], d[:desc]] }.join()
+      end
+    end
+
+    def do_list_cdns
+      if @quiet
+        return CLASSES.map {|c| "#{c::CODE}\n" }.join()
+      else
+        return CLASSES.map {|c| "%-10s  # %s\n" % [c::CODE, c::SITE_URL] }.join()
+      end
+    end
+
+    def do_list_libraries(cdn_code)
+      cdn = find_cdn(cdn_code)
+      return render_list(cdn.list)
+    end
+
+    def do_search_libraries(cdn_code, pattern)
+      cdn = find_cdn(cdn_code)
+      rexp_str = pattern.split('*', -1).collect {|x| Regexp.escape(x) }.join('.*')
+      rexp = Regexp.compile("\\A#{rexp_str}\\z", Regexp::IGNORECASE)
+      return render_list(cdn.list.select {|a| a[:name] =~ rexp })
+    end
+
+    def do_find_library(cdn_code, library)
+      cdn = find_cdn(cdn_code)
+      d = cdn.find(library)
+      s = ""
+      if @quiet
+        d[:versions].each do |ver|
+          s << "#{ver}\n"
+        end if d[:versions]
+      else
+        s << "name:  #{d[:name]}\n"
+        s << "desc:  #{d[:desc]}\n" if d[:desc]
+        s << "tags:  #{d[:tags]}\n" if d[:tags]
+        s << "site:  #{d[:site]}\n" if d[:site]
+        s << "snippet: |\n" << d[:snippet].gsub(/^/, '    ') if d[:snippet]
+        s << "versions:\n"
+        d[:versions].each do |ver|
+          s << "  - #{ver}\n"
+        end if d[:versions]
+      end
+      return s
+    end
+
+    def do_get_library(cdn_code, library, version)
+      cdn = find_cdn(cdn_code)
+      d = cdn.get(library, version)
+      s = ""
+      if @quiet
+        d[:urls].each do |url|
+          s << "#{url}\n"
+        end if d[:urls]
+      else
+        s << "name:     #{d[:name]}\n"
+        s << "version:  #{d[:version]}\n"
+        s << "tags:     #{d[:tags]}\n" if d[:tags]
+        s << "site:     #{d[:site]}\n" if d[:site]
+        s << "snippet: |\n" << d[:snippet].gsub(/^/, '    ') if d[:snippet]
+        s << "urls:\n"  if d[:urls]
+        d[:urls].each do |url|
+          s << "  - #{url}\n"
+        end if d[:urls]
+      end
+      return s
+    end
+
+    def do_download_library(cdn_code, library, version, basedir)
+      cdn = find_cdn(cdn_code)
+      cdn.download(library, version, basedir, quiet: @quiet)
+      return nil
+    end
+
+  end
+
+
+end
+
+
+#if __FILE__ == $0
+  CDNGet::Main.main()
+#end