boilerpl8 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fb49c7054f7c6e79c7a1eae55ab92aff27410956
+  data.tar.gz: 1b169216fba70c65332f0162885d6390de34d83f
+SHA512:
+  metadata.gz: b34f424994767306c2d8aef57a6d3768b93f8e9568d02a14179053359f83f6ae48f7e66b0b12484bb40deef571462b0c190c919e0987dff5f7671429b6172d10
+  data.tar.gz: 205fdebae935f1f716e85bc12a51e5d65c7210a5f37dedaf90d21929b76009a4ff4f17d2e5e4a725b8f1a62558014fea52ab84bf83a6503da33fe6948abcb639

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 kuwata-lab.com
+
+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,68 @@
+============
+Boilerpl8.rb
+============
+
+($Release: 0.1.0 $)
+
+
+Abount
+------
+
+Boilerpl8.rb is a scaffolding tool to download and expand boilerplate files.
+
+
+Install
+-------
+
+```console
+$ gem install boilerpl8
+$ boilerpl8 --help
+```
+
+
+Examples
+--------
+
+For Ruby project:
+
+```console
+### download boilerplate files from github.com/kwatch/hello-ruby-boilerpl8
+$ boilerpl8 github:kwatch/hello-ruby myproj
+```
+
+For Keight.rb framework:
+
+```console
+### download boilerplate files from github.com/kwatch/keight-ruby-boilerpl8
+$ boilerpl8 github:kwatch/keight-ruby myapp1
+```
+
+For HTML5 web site:
+
+```console
+### download boilerplate files from github.com/h5bp/html5-boilerplate
+### ('-B' option doesn't append '-boilerpl8' to github repo name.)
+$ boilerpl8 -B github:h5bp/html5-boilerplate website1
+```
+
+You can expand local *.zip or *.tar.gz file:
+
+```console
+$ url="https://github.com/kwatch/hello-ruby-boilerpl8/archive/v0.2.0.zip"
+$ wget -O hello-ruby-v0.2.0.zip $url
+$ ls hello-ruby-v0.2.0.zip
+hello-ruby-v0.2.0.zip
+$ boilerpl8 file:hello-ruby-v0.2.0.zip myapp1
+```
+
+
+Todo
+----
+
+* [_] List github repositories which name ends with `-boilerpl8`.
+
+
+License
+-------
+
+MIT License

data/Rakefile

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+
+PROJECT  = "boilerpl8"
+SPECFILE = PROJECT + ".gemspec"
+
+
+##
+## tasks
+##
+
+task :default => :howto
+
+
+desc "show how to release"
+task :howto do
+  puts <<'END'
+How to release:
+
+  $ git diff                     # confirm that no diff
+  $ rake test
+  $ rake prepare release=0.0.0   # update release number
+  $ rake package
+  $ rake release
+  $ git checkout .               # reset release number
+  $ git tag ruby-0.0.0
+  $ git push --tags
+
+END
+end
+
+
+desc "run test scripts"
+task :test do
+  $LOAD_PATH << File.join(File.dirname(__FILE__), "lib")
+  #sh "ruby test/**/*_{test,spec}.rb"   # not work
+  pattern = 'test/**/*_{test,spec}.rb'
+  files = Dir.glob(pattern)
+  files = [pattern] if files.empty?
+  puts "ruby #{pattern}"
+  sh "ruby", *files, :verbose=>false
+end
+### or
+#require 'rake/testtask'
+#Rake::TestTask.new do |test|
+#  #test.libs << 'lib' << 'test'
+#  test.test_files = Dir.glob('test/**/*_{test,spec}.rb')
+#  test.verbose = true
+#end
+
+
+desc "update release number"
+task :prepare do
+  release = release_number_required(:prepare)
+  spec = load_gemspec_file(SPECFILE)
+  edit(spec.files) {|s|
+    s.gsub(/\$(Release):.*?\$/,   "$Release\: #{release} $") \
+     .gsub(/\$(Release)$/,        release)
+  }
+end
+
+
+desc "create gem package"
+task :package do
+  sh "gem build #{SPECFILE}"
+end
+
+
+desc "upload gem to rubygems.org"
+task :release => :package do
+  spec = load_gemspec_file(SPECFILE)
+  release = spec.version
+  print "*** Are you sure to upload #{PROJECT}-#{release}.gem? [y/N]: "
+  answer = $stdin.gets().strip()
+  if answer =~ /\A[yY]/
+    #sh "git tag ruby-#{release}"
+    sh "gem push #{PROJECT}-#{release}.gem"
+  end
+end
+
+
+##
+## helpers
+##
+
+def edit(*filepaths)
+  filepaths.flatten.each do |fpath|
+    next if ! File.file?(fpath)
+    File.open(fpath, 'r+b:utf-8') do |f|
+      s = f.read()
+      new_s = yield s
+      if new_s != s
+        f.rewind()
+        f.truncate(0)
+        f.write(new_s)
+        puts "[Change] #{fpath}"
+      end
+    end
+  end
+end
+
+def load_gemspec_file(gemspec_file)
+  require 'rubygems'
+  return Gem::Specification::load(gemspec_file)
+end
+
+def release_number_required(task_name)
+  release = ENV['release']
+  unless release
+    $stderr.puts <<"END"
+##
+## ERROR: rake #{task_name}: requires 'release=X.X.X' option.
+##        For example:
+##           $ rake #{task_name} release=1.0.0
+##
+END
+    errmsg = "rake #{task_name}: requires 'release=X.X.X' option."
+    raise ArgumentError.new(errmsg)
+  end
+  return release
+end

data/bin/boilerpl8

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'boilerpl8'
+
+Boilerpl8::MainApp.main()

data/boilerpl8.gemspec

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+Gem::Specification.new do |spec|
+  spec.name            = 'boilerpl8'
+  spec.version         = '$Release: 0.1.0 $'.split()[1]
+  spec.author          = 'makoto kuwata'
+  spec.email           = 'kwa@kuwata-lab.com'
+  spec.platform        = Gem::Platform::RUBY
+  spec.homepage        = 'https://github.com/kwatch/boilerpl8/tree/ruby'
+  spec.summary         = "download and expand boilerplate files"
+  spec.description     = <<-'END'
+Scaffolding tool to download and expand boilerplate files.
+END
+  spec.license         = 'MIT'
+  spec.files           = Dir[*%w[
+                           README.md MIT-LICENSE Rakefile boilerpl8.gemspec
+                           bin/*
+                           lib/**/*.rb
+                           test/**/*.rb
+                         ]]
+  spec.executables     = ['boilerpl8']
+  spec.bindir          = 'bin'
+  spec.require_path    = 'lib'
+  spec.test_files      = Dir['test/**/*_test.rb']
+
+  spec.add_development_dependency 'minitest'   , '~> 0'
+  spec.add_development_dependency 'minitest-ok', '~> 0'
+end

data/lib/boilerpl8.rb

@@ -0,0 +1,366 @@
+# -*- coding: utf-8 -*-
+
+###
+### $Release: 0.1.0 $
+### $Copyright: copyright(c) 2016 kuwata-lab.com all rights reserved $
+### $License: MIT License $
+###
+
+require 'open-uri'
+require 'json'
+require 'fileutils'
+
+
+module Boilerpl8
+
+
+  RELEASE = '$Release: 0.1.0 $'.split()[1]
+
+
+  module ShellHelper
+
+    def rm_rf(path)
+      puts "$ rm -rf #{path}"
+      FileUtils.rm_rf path
+    end
+
+    def mv(oldpath, newpath)
+      puts "$ mv #{oldpath} #{newpath}"
+      File.rename oldpath, newpath
+    end
+
+    def sys(command)
+      puts "$ #{command}"
+      system command
+    end
+
+    def chdir(dir, &block)
+      puts "$ cd #{dir}"
+      Dir.chdir(dir, &block)
+      puts "$ cd -"
+    end
+
+  end
+
+
+  INITIALIZER_SCRIPTS = [
+    ["__init.rb"   , "ruby"  ],
+    ["__init.py"   , "python"],
+    ["__init.js"   , "node"  ],
+    ["__init.pl"   , "perl"  ],
+    ["__init.php"  , "php"   ],
+    ["__init.lua"  , "lua"   ],
+    ["__init.exs"  , "elixir"],
+    ["__init.sh"   , "bash"  ],
+  ]
+
+
+  class Operation
+    include ShellHelper
+
+    def do_everything(boilerplate_name, target_dir, options)
+      url, filename = resolve(boilerplate_name, options)
+      filepath = download(url, filename)
+      basedir = extract(filepath, target_dir)
+      kick_initializer(basedir)
+    end
+
+    protected
+
+    def resolve(arg, options)
+      raise NotImplementedError.new("#{self.class.name}#resolve(): not implemented yet.")
+    end
+
+    def download(url, filename)
+      print "Download from #{url} ..."
+      content = open(url) {|f| f.read }
+      puts " done."
+      File.open(filename, 'wb') {|f| f.write(content) }
+      return filename
+    end
+
+    def extract(filename, basedir)
+      filename =~ /\.(zip|tgz|tar\.(gz|bz2|xz))\z/  or
+        err("#{filename}: expected '*.zip' or '*.tar.gz'")
+      base = File.basename($`)
+      basedir ||= base
+      rm_rf basedir if File.exist?(basedir)
+      #
+      case filename
+      when /\.zip\z/
+        tmpdir = basedir + ".tmp"
+        sys "unzip -q -d #{tmpdir} #{filename}"
+        paths = Dir.glob("#{tmpdir}/*")
+        if paths.length == 1 && File.directory?(paths[0])
+          mv paths[0], basedir
+          rm_rf tmpdir
+        else
+          mv tmpdir, basedir
+        end
+      else
+        sys "tar xf #{filename}"
+        mv base, basedir if base != basedir
+      end
+      #
+      return basedir
+    end
+
+    def kick_initializer(basedir)
+      chdir(basedir) do
+        INITIALIZER_SCRIPTS.each do |script, lang|
+          if File.exist?(script)
+            sys "#{lang} #{script}"
+            break
+          end
+        end
+      end
+    end
+
+    def err(msg)
+      raise CommandOptionError.new(msg)
+    end
+
+    def self.err(msg)
+      raise CommandOptionError.new(msg)
+    end
+
+    public
+
+    ALL = []
+
+    def self.inherited(klass)
+      ALL << klass
+    end
+
+    def self.create(boilerplate_name)
+      boilerplate_name =~ /\A(\w+:)/  or
+        err("#{args[0]}: expected 'github:' or 'file:' schema.")
+      schema = $1
+      klass = ALL.find {|cls| cls.const_get(:SCHEMA) == schema }  or
+        err("#{args[0]}: unknown schema.")
+      return klass.new()
+    end
+
+  end
+
+
+  class FileSystemOp < Operation
+
+    SCHEMA = "file:"
+
+    protected
+
+    def resolve(arg, options)
+      arg =~ %r'\Afile:(.+)'  or err("#{arg}: unexpected format.")
+      filepath = $1
+      return filepath, File.basename(filepath)
+    end
+
+    def download(filepath, filename)
+      return filepath
+    end
+
+  end
+
+
+  class GithubOp < Operation
+
+    SCHEMA = "github:"
+
+    protected
+
+    def resolve(arg, options)
+      arg =~ %r'\Agithub:([^/]+)/([^/]+)\z'  or err("#{arg}: unexpected format.")
+      user, repo = $1, $2
+      #
+      suffix = options['B'] ? "" : "-boilerpl8"
+      api_url = "https://api.github.com/repos/#{user}/#{repo}#{suffix}/releases"
+      begin
+        json_str = open(api_url) {|f| f.read }
+      rescue OpenURI::HTTPError => ex
+        hint = options['B'] \
+             ? "confirm repository name, or try without '-B' option." \
+             : "confirm repository name, or maybe you missed '-B' option."
+        err("#{arg}: repository not found\n  (api: GET #{api_url})\n  (Hint: #{hint})")
+      end
+      #
+      json_arr = JSON.parse(json_str)
+      dict = json_arr[0]
+      asset = (dict["assets"] || [])[0]
+      if asset
+        zip_url = asset["browser_download_url"]
+        filename = zip_url ? File.basename(zip_url) : nil
+      else
+        zip_url = dict["zipball_url"]
+        filename = "#{repo}_#{dict['tag_name']}.zip"
+      end
+      zip_url  or
+        err("ERROR: can't find zip file under github.com/#{user}/#{repo}/releases")
+      return zip_url, filename
+    end
+
+  end
+
+
+  class MainApp
+
+    COMMAND_OPTIONS = [
+      "-h, --help       :  help",
+      "-v, --version    :  version",
+      "-B               :  not append '-boilerpl8' to github repo name",
+    ]
+
+    def self.main
+      begin
+        self.new.run(*ARGV)
+        exit 0
+      rescue CommandOptionError => ex
+        $stderr.puts ex.message
+        exit 1
+      end
+    end
+
+    def initialize(script_name=nil)
+      @script_name = script_name || File.basename($0)
+    end
+
+    def run(*args)
+      parser = CommandOptionParser.new(COMMAND_OPTIONS)
+      options = parser.parse(args)
+      #
+      if options['help']
+        puts help_message()
+        return 0
+      end
+      #
+      if options['version']
+        puts RELEASE
+        return 0
+      end
+      #
+      ! args.empty?  or err("#{@script_name}: argument required.")
+      boilerplate_name = args[0]   # ex: "github:kwatch/hello-ruby"
+      target_dir       = args[1]   # ex: "mygem1"
+      op = Operation.create(boilerplate_name)
+      op.do_everything(boilerplate_name, target_dir, options)
+      return 0
+    end
+
+    def help_message
+      script = @script_name
+      buf = <<"END"
+#{script} -- download boilerplate files
+
+Usage:
+  #{script} [options] github:<USER>/<REPO> <DIR>
+  #{script} [options] file:<PATH> <DIR>
+
+Options:
+END
+      COMMAND_OPTIONS.each {|s| buf << "  #{s}\n" }
+      buf << <<"END"
+
+Examples:
+
+  ## download boilerplate files from github
+  $ #{script} github:kwatch/hello-ruby mygem1             # for ruby
+  $ #{script} github:kwatch/hello-python mypkg1           # for python
+  $ #{script} github:kwatch/keight-ruby myapp1            # for keight.rb
+
+  ## '-B' option doesn't append '-boilerpl8' to github repo name
+  $ #{script} -B github:h5bp/html5-boilerplate website1   # for html5
+
+  ## expand boilerplate files
+  $ #{script} file:./keight-ruby.tar.gz myapp1
+
+END
+    end
+
+    private
+
+    def err(msg)
+      raise CommandOptionError.new(msg)
+    end
+
+  end
+
+
+  class CommandOptionError < StandardError
+  end
+
+
+  CommandOptionDefinition = Struct.new(:short, :long, :param, :desc)
+
+
+  class CommandOptionParser
+
+    def initialize(optdef_strs)
+      @optdef_strs = optdef_strs
+      @optdefs = []
+      optdef_strs.each do |optdef_str|
+        case optdef_str
+        when /-(\w), --(\w[-\w]*)(?:=(\S+))?\s*:\s*(\S.*)?/ ; t = [$1, $2, $3, $4]
+        when /-(\w)(?:\s+(\S+))?\s*:\s*(\S.*)?/             ; t = [$1, nil, $2, $3]
+        when /--(\w[-\w]*)(?:=(\S+))?\s*:\s*(\S.*)?/        ; t = [nil, $1, $2, $3]
+        else
+          raise "unexpected option definition: #{optdef_str}"
+        end
+        short, long, param, desc = t
+        @optdefs << CommandOptionDefinition.new(short, long, param, desc)
+      end
+    end
+
+    attr_reader :optdefs
+
+    def parse(args)
+      options = {}
+      while ! args.empty? && args[0].start_with?('-')
+        argstr = args.shift
+        if argstr.start_with?('--')
+          rexp = /\A--([-\w]+)(?:=(.*))?\z/
+          argstr =~ rexp                   or err("#{argstr}: invalid option format.")
+          name, value = $1, $2
+          optdef = find_by(:long, name)    or err("--#{name}: unknown option.")
+          optdef.param.nil? || value       or err("#{argstr}: argument required.")
+          optdef.param      || value.nil?  or err("#{argstr}: unexpected argument.")
+          options[optdef.long] = value || true
+        else
+          n = argstr.length
+          i = 0
+          while (i += 1) < n
+            ch = argstr[i]
+            optdef = find_by(:short, ch)   or err("-#{ch}: unknown option.")
+            if optdef.param.nil?   # no arguments
+              options[optdef.long || optdef.short] = true
+            else                   # argument required
+              param = argstr[(i+1)..-1]
+              param = args.shift if param.empty?
+              param  or err("-#{ch}: argument required.")
+              options[optdef.long || optdef.short] = param
+              break
+            end
+          end
+        end
+      end
+      return options
+    end
+
+    private
+
+    def find_by(key, value)
+      return @optdefs.find {|x| x.__send__(key) == value }
+    end
+
+    def err(msg)
+      raise CommandOptionError.new(msg)
+    end
+
+  end
+
+
+end
+
+
+if __FILE__ == $0
+  Boilerpl8::MainApp.main()
+end

data/test/boilerpl8_test.rb

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/ok'
+
+require 'fileutils'
+
+require_relative '../lib/boilerpl8'
+
+
+describe Boilerpl8::MainApp do
+
+  help_message = <<END
+#{File.basename(__FILE__)} -- download boilerplate files
+
+Usage:
+  boilerpl8_test.rb [options] github:<USER>/<REPO> <DIR>
+  boilerpl8_test.rb [options] file:<PATH> <DIR>
+
+Options:
+  -h, --help       :  help
+  -v, --version    :  version
+  -B               :  not append '-boilerpl8' to github repo name
+
+Examples:
+
+  ## download boilerplate files from github
+  $ boilerpl8_test.rb github:kwatch/hello-ruby mygem1             # for ruby
+  $ boilerpl8_test.rb github:kwatch/hello-python mypkg1           # for python
+  $ boilerpl8_test.rb github:kwatch/keight-ruby myapp1            # for keight.rb
+
+  ## '-B' option doesn't append '-boilerpl8' to github repo name
+  $ boilerpl8_test.rb -B github:h5bp/html5-boilerplate website1   # for html5
+
+  ## expand boilerplate files
+  $ boilerpl8_test.rb file:./keight-ruby.tar.gz myapp1
+
+END
+
+  describe '#run()' do
+
+    it "prints help message when '-h' or '--help' specified." do
+      expected = help_message
+      #
+      status = nil
+      pr = proc { status = Boilerpl8::MainApp.new.run("-hv") }
+      ok {pr}.output?(expected)
+      ok {status} == 0
+      #
+      status = nil
+      pr = proc { status = Boilerpl8::MainApp.new.run("--help", "foo", "bar") }
+      ok {pr}.output?(expected)
+      ok {status} == 0
+    end
+
+    it "prints version number when '-v' or '--version' specified." do
+      expected = "#{Boilerpl8::RELEASE}\n"
+      #
+      status = nil
+      pr = proc { status = Boilerpl8::MainApp.new.run("-v") }
+      ok {pr}.output?(expected)
+      ok {status} == 0
+      #
+      status = nil
+      pr = proc { status = Boilerpl8::MainApp.new.run("--version", "foo", "bar") }
+      ok {pr}.output?(expected)
+      ok {status} == 0
+    end
+
+    it "downloads and expand github:kwatch/hello-ruby" do
+      target_dir = "test-app1"
+      begin
+        status = Boilerpl8::MainApp.new.run("github:kwatch/hello-ruby", target_dir)
+        ok {target_dir}.dir_exist?
+        ok {"#{target_dir}/#{target_dir}.gemspec"}.file_exist?
+        ok {"#{target_dir}/hello.gemspec"}.NOT.file_exist?
+        ok {"#{target_dir}/__init.rb"}.NOT.file_exist?
+        ok {status} == 0
+      ensure
+        FileUtils.rm_rf target_dir
+        FileUtils.rm_rf Dir.glob("hello-ruby_*.zip")
+      end
+    end
+
+    it "downloads and expand with '-B' option" do
+      target_dir = "test-site1"
+      begin
+        status = Boilerpl8::MainApp.new.run("-B", "github:h5bp/html5-boilerplate", target_dir)
+        ok {target_dir}.dir_exist?
+        ok {status} == 0
+      ensure
+        FileUtils.rm_rf target_dir
+        FileUtils.rm_rf Dir.glob("html5-boilerplate_*.zip")
+      end
+    end
+
+  end
+
+
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: boilerpl8
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- makoto kuwata
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-ok
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'Scaffolding tool to download and expand boilerplate files.
+
+'
+email: kwa@kuwata-lab.com
+executables:
+- boilerpl8
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- bin/boilerpl8
+- boilerpl8.gemspec
+- lib/boilerpl8.rb
+- test/boilerpl8_test.rb
+homepage: https://github.com/kwatch/boilerpl8/tree/ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: download and expand boilerplate files
+test_files:
+- test/boilerpl8_test.rb