skippy 0.1.0.a

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6005a25ffc1f9757b4cf9656d97be15351463830
+  data.tar.gz: da9d85e6b9c72eeee60b18fed419722e13829a64
+SHA512:
+  metadata.gz: fc7071ef383374ae27cc9fa15d15544dac943d07a53832f91712f8f8a44d9c1d7eeb0286babae6a3cfdb3b4d91b074a4693f2ab825d6f700961942d6fd5ec4c4
+  data.tar.gz: 0ce7d0c9935e0f607e1367062a297ccc83788efebea2330f282bd1d6f8608b4a72f5fb158a8f26a5f5b9e893c94ef9727e29c2b15039cc5cf7d835ebb81dd508

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+*.sublime-workspace

data/.vscode/settings.json

@@ -0,0 +1,4 @@
+// Place your settings in this file to overwrite default and user settings.
+{
+  "editor.wrappingColumn": 80
+}

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in skippy.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Thomas Thomassen
+
+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,61 @@
+# Skippy
+
+Skippy is a Command Line Interface which aims to automate common developer tasks for SketchUp Ruby extension development.
+
+It is currently in very early stage of development so many things are incomplete. Feedback and contributions are welcome.
+
+Some of the main goals are:
+
+* Automate common tasks
+  * Packaging the extension
+  * Running build scripts
+* Easy interface to add per-project custom commands/tasks
+* Quick initialization of new project with templates
+* Library dependency management
+  * Pull in third-party modules into extension namespace
+  * Add/Remove/Update dependencies
+
+## Installation
+
+    $ gem install skippy
+
+## Usage
+
+TODO: Write more detailed usage instructions here.
+
+Install the gem on your system, afterwards the `skippy` command should become available.
+
+### Quick-Reference
+
+Type `skippy` to list available commands.
+
+Type `skippy help [COMMAND]` for more information on how to use each command.
+
+Use `skippy new` to create a new project in the current folder.
+
+You can add custom per-project commands to a `skippy` folder in your project. Look at `skippy/example.rb` for an example of a simple custom command.
+
+### Power of Thor
+
+Skippy is built on [Thor](https://github.com/erikhuda/thor). Refer to [Thor's Website](http://whatisthor.com/) and [documentation](http://www.rubydoc.info/github/wycats/thor/index) for details on creating commands.
+
+When creating Skippy command use the following replacements:
+
+* Instead of class `Thor`, use `Skippy::Command`
+* Instead of class `Thor::Group`, use `Skippy::Command::Group`
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/thomthom/skippy.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/Skippy.sublime-project

@@ -0,0 +1,25 @@
+{
+	"folders":
+	[
+		{
+			"path": "."
+		},
+		{
+			"path": "C:\\Users\\tthomas2\\SourceTree\\thor"
+		}
+	],
+	"settings":
+	{
+		"default_encoding": "UTF-8",
+		"ensure_newline_at_eof_on_save": true,
+		"rulers":
+		[
+			80
+		],
+		"show_encoding": true,
+		"show_line_endings": true,
+		"tab_size": 2,
+		"translate_tabs_to_spaces": true,
+		"trim_trailing_white_space_on_save": true
+	}
+}

data/app/boot.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+# Set the program name explicitly. Otherwise Thor will use the filename in the
+# banner for the command help.
+$PROGRAM_NAME = 'skippy'
+
+# TODO(thomthom): Temporary set for development without having to set the ENV.
+# Thor on Windows will by default not use colors. Using Cmder colors will work.
+# Also in the latest Windows 10 colors appear to work. Not sure how older
+# versions behave.
+ENV['THOR_SHELL'] = 'Color' if $stdout.isatty
+
+# Thor require DL which under Windows and Ruby 2.0 will yield a warning:
+#   DL is deprecated, please use Fiddle
+#
+# To avoid this appearing every time this tool is invoked, warnings are
+# temporarily suppressed.
+begin
+  original_verbose = $VERBOSE
+  $VERBOSE = nil
+  require 'thor'
+  # The Thor::Runner also needs to be loaded, as Skippy::CLI will call many of
+  # of the same methods - in many cases emulating what it do.
+  require "thor/runner"
+  # This is also needed to be set in order for Thor's utilities to output
+  # command names correctly.
+  $thor_runner = true
+ensure
+  $VERBOSE = original_verbose
+end
+
+# Load skippy components the bootstrapper needs.
+require 'skippy/app'
+Skippy::App.boot(__FILE__)
+
+# Everything is ready to start the CLI.
+require 'skippy/cli'
+require 'skippy/error'
+begin
+  Skippy::CLI.start
+rescue Skippy::Error => error
+  Skippy::CLI.display_error(error)
+end

data/app/commands/debug.rb

@@ -0,0 +1,15 @@
+require 'skippy/namespace'
+
+class Debug < Skippy::Command
+
+  include Thor::Actions
+
+  desc 'clean', 'Cleans out project files'
+  def clean
+    say "Cleaning out project files..."
+    remove_file Skippy::Project::PROJECT_FILENAME
+    remove_dir 'src'
+    remove_dir 'skippy'
+  end
+
+end

data/app/commands/new.rb

@@ -0,0 +1,97 @@
+require 'json'
+
+require 'skippy/app'
+require 'skippy/group'
+require 'skippy/project'
+require 'skippy/template'
+
+class New < Skippy::Command::Group
+
+  include Thor::Actions
+
+  argument :namespace,
+    :type => :string,
+    :desc => 'The namespace the extension will use'
+
+  class_option :template,
+    :type => :string,
+    :desc => 'The template used to generate the project files',
+    :default => 'standard'
+
+  source_paths << Skippy.app.resources
+
+  attr_reader :project
+
+  def initialize_project
+    @project = Skippy::Project.new(Dir.pwd)
+    if project.exist?
+      raise Skippy::Error, "A project already exist: #{project.filename}"
+    end
+    project.namespace = namespace
+  end
+
+  def validate_template
+    template_path = File.join(self.class.source_root, options[:template])
+    unless File.directory?(template_path)
+      raise Skippy::Error, %(Template "#{options[:template]}" not found)
+    end
+  end
+
+  def create_project_json
+    say ''
+    say 'Generating skippy.json...'
+    say ''
+    say project.filename
+    say project.to_json, :yellow
+    project.save
+  end
+
+  def compile_templates
+    say ''
+    say "Compiling template '#{options[:template]}'..."
+    say ''
+    directory(options[:template], 'src')
+  end
+
+  def create_extension_json
+    extension_info = {
+      name: project.name,
+      description: project.description,
+      creator: project.author,
+      copyright: project.copyright,
+      license: project.license,
+      product_id: project.namespace.to_a.join('_'),
+      version: "0.1.0",
+      build: "1",
+    }
+    json = JSON.pretty_generate(extension_info)
+    json_filename = "src/#{project.namespace.to_underscore}/extension.json"
+    create_file(json_filename, json)
+  end
+
+  def create_example_skippy_command
+    copy_file('commands/example.rb', 'skippy/example.rb')
+  end
+
+  def finalize
+    say ''
+    say "Project for #{namespace} created.", :green
+  end
+
+  # These are methods to be used by the template engine when it compiles the
+  # templates and expands the filenames.
+  no_commands do
+
+    # @return [String] The basename for the extension files.
+    def ext_name
+      project.namespace.to_underscore
+    end
+
+  end # no_commands
+
+  # Needed as base for Thor::Actions' file actions.
+  def self.source_root
+    Skippy.app.templates_source_path
+  end
+
+end

data/app/commands/template.rb

@@ -0,0 +1,27 @@
+class Template < Skippy::Command
+
+  desc 'list', 'List all known templates'
+  def list
+    say 'Available templates:', :yellow
+    templates = Skippy.app.templates
+    if templates.empty?
+      say '  No templates found'
+    else
+      templates.each { |template|
+        say "  #{template.name}", :green
+      }
+    end
+  end
+  default_command(:list)
+
+  desc 'install', 'Install a new template'
+  def install(source)
+    raise Skippy::Error, 'Not implemented'
+  end
+
+  desc 'remove', 'Remove an installed template'
+  def remove(template_name)
+    raise Skippy::Error, 'Not implemented'
+  end
+
+end

data/app/resources/commands/example.rb

@@ -0,0 +1,14 @@
+class Hello < Skippy::Command
+
+  desc 'world PERSON', 'Oh, hi there!'
+  def world(person)
+    say "Hello #{person}"
+  end
+  default_command(:world)
+
+  desc 'universe', 'Greets the universe in general'
+  def universe(person)
+    say "DARK IN HERE, ISN'T IT?"
+  end
+
+end

data/app/templates/standard/%ext_name%.rb.tt

@@ -0,0 +1,45 @@
+#-------------------------------------------------------------------------------
+#
+#    Author: <%= project.author %>
+# Copyright: <%= project.copyright %>
+#   License: <%= project.license %>
+#
+#-------------------------------------------------------------------------------
+
+require 'json'
+
+require 'extensions.rb'
+require 'sketchup.rb'
+
+<%= project.namespace.open %>
+
+  file = __FILE__.dup
+  # Account for Ruby encoding bug under Windows.
+  file.force_encoding('UTF-8') if file.respond_to?(:force_encoding)
+  # Support folder should be named the same as the root .rb file.
+  folder_name = File.basename(file, '.*')
+
+  # Path to the root .rb file (this file).
+  PATH_ROOT = File.dirname(file).freeze
+
+  # Path to the support folder.
+  PATH = File.join(PATH_ROOT, folder_name).freeze
+
+  # Extension information.
+  extension_json_file = File.join(PATH, 'extension.json')
+  extension_json = File.read(extension_json_file)
+  EXTENSION = ::JSON.parse(extension_json, symbolize_names: true).freeze
+
+  unless file_loaded?(__FILE__)
+    loader = File.join(PATH, 'bootstrap')
+    @extension = SketchupExtension.new(EXTENSION[:name], loader)
+    @extension.description = EXTENSION[:description]
+    @extension.version     = EXTENSION[:version]
+    @extension.copyright   = EXTENSION[:copyright]
+    @extension.creator     = EXTENSION[:creator]
+    Sketchup.register_extension(@extension, true)
+  end
+
+<%= project.namespace.close %>
+
+file_loaded(__FILE__)

data/app/templates/standard/%ext_name%/main.rb.tt

@@ -0,0 +1,21 @@
+require 'sketchup.rb'
+
+module <%= project.namespace %>
+
+  unless file_loaded?(__FILE__)
+    menu = UI.menu('Plugins').add_submenu(EXTENSION[:name])
+    menu.add_item('Make Magic') { self.make_magic }
+    menu.add_separator
+    menu.add_item('Help...') { self.open_help }
+    file_loaded(__FILE__)
+  end
+
+  def self.make_magic
+    # Do magic here...
+  end
+
+  def self.open_help
+    UI.openURL(EXTENSION[:url])
+  end
+
+end # module

data/app/templates/webdialog/extension.rb.erb

@@ -0,0 +1,45 @@
+#-------------------------------------------------------------------------------
+#
+#    Author: <%= project.author %>
+# Copyright: <%= project.copyright %>
+#   License: <%= project.license %>
+#
+#-------------------------------------------------------------------------------
+
+require 'json'
+
+require 'extensions.rb'
+require 'sketchup.rb'
+
+<%= project.namespace.open %>
+
+  file = __FILE__.dup
+  # Account for Ruby encoding bug under Windows.
+  file.force_encoding('UTF-8') if file.respond_to?(:force_encoding)
+  # Support folder should be named the same as the root .rb file.
+  folder_name = File.basename(file, '.*')
+
+  # Path to the root .rb file (this file).
+  PATH_ROOT = File.dirname(file).freeze
+
+  # Path to the support folder.
+  PATH = File.join(PATH_ROOT, folder_name).freeze
+
+  # Extension information.
+  extension_json_file = File.join(PATH, 'extension.json')
+  extension_json = File.read(extension_json_file)
+  EXTENSION = ::JSON.parse(extension_json, symbolize_names: true).freeze
+
+  unless file_loaded?(__FILE__)
+    loader = File.join(PATH, 'bootstrap')
+    @extension = SketchupExtension.new(EXTENSION[:name], loader)
+    @extension.description = EXTENSION[:description]
+    @extension.version     = EXTENSION[:version]
+    @extension.copyright   = EXTENSION[:copyright]
+    @extension.creator     = EXTENSION[:creator]
+    Sketchup.register_extension(@extension, true)
+  end
+
+<%= project.namespace.close %>
+
+file_loaded(__FILE__)

data/app/templates/webdialog/extension/html/dialog.html

@@ -0,0 +1,6 @@
+<!DOCTYPE html>
+<html>
+<body>
+  Hello World
+</body>
+</html>

data/app/templates/webdialog/extension/main.rb.erb

@@ -0,0 +1,24 @@
+require 'sketchup.rb'
+
+module <%= project.namespace %>
+
+  unless file_loaded?(__FILE__)
+    menu = UI.menu('Plugins').add_submenu(EXTENSION[:name])
+    menu.add_item('Open Dialog') { self.open_dialog }
+    menu.add_separator
+    menu.add_item('Help...') { self.open_help }
+    file_loaded(__FILE__)
+  end
+
+  def self.open_dialog
+    file_path = File.join(PATH, 'html', 'dialog.html')
+    @dialog = UI::WebDialog.new
+    @dialog.set_file(file_path)
+    @dialog.show
+  end
+
+  def self.open_help
+    UI.openURL(EXTENSION[:url])
+  end
+
+end # module

data/bin/bundler

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'bundler' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("bundler", "bundler")

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "skippy"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/rake

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/skippy

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'skippy' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("skippy", "skippy")

data/bin/thor

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'thor' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("thor", "thor")

data/exe/skippy

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require_relative '../app/boot'

data/lib/skippy.rb

@@ -0,0 +1,5 @@
+require "skippy/version"
+
+module Skippy
+  # Your code goes here...
+end

data/lib/skippy/app.rb

@@ -0,0 +1,62 @@
+require 'pathname'
+
+require 'skippy/command'
+require 'skippy/group'
+require 'skippy/template'
+require 'skippy/skippy'
+
+class Skippy::App
+
+  # @param [String] boot_loader_path
+  # @return [Skippy::App]
+  def self.boot(boot_loader_path)
+    Skippy.app = Skippy::App.new(boot_loader_path)
+    Skippy.app.boot
+  end
+
+  attr_reader :path
+
+  # @param [String] boot_loader_path
+  def initialize(boot_loader_path)
+    @boot_loader_path = File.expand_path(boot_loader_path)
+    @path = File.dirname(@boot_loader_path)
+  end
+
+  def boot
+    boot_commands
+  end
+
+  def resources(item = nil)
+    resource = Pathname.new(File.join(path, 'resources'))
+    item ? resource.join(item) : resource
+  end
+
+  # @return [Array<String>]
+  def templates_source_path
+    Pathname.new(File.join(path, 'templates'))
+  end
+
+  def templates
+    result = []
+    templates_source_path.entries.each { |entry|
+      template_path =  templates_source_path.join(entry)
+      next unless template_path.directory?
+      next if %[. ..].include?(entry.basename.to_s)
+      result << Skippy::Template.new(entry)
+    }
+    result
+  end
+
+  private
+
+  # @return [Array<String>] loaded files
+  def boot_commands
+    # Load the default skippy commands.
+    path_commands = File.join(path, 'commands')
+    commands_pattern = File.join(path_commands, '*.rb')
+    Dir.glob(commands_pattern) { |filename|
+      require filename
+    }
+  end
+
+end

data/lib/skippy/cli.rb

@@ -0,0 +1,191 @@
+require 'skippy/app'
+require 'skippy/command'
+require 'skippy/group'
+require 'skippy/project'
+require 'skippy/version'
+
+# The Skippy::CLI class emulates much of what Thor::Runner do. It takes care of
+# finding skippy projects and loading commands.
+#
+# The difference is mainly in how skippy vs thor present the commands.
+#
+# TODO(thomthom): ...or should it?
+# Thor let you install commands globally, where as skippy does not.
+#
+# Skippy will list all known commands when invoked without any arguments.
+#
+# The code in this class will often refer to thor - when things have been copied
+# verbatim. Makes it easier to update if needed.
+class Skippy::CLI < Skippy::Command
+
+  class << self
+
+    # @param [Skippy::Error] error
+    def display_error(error)
+      shell = Thor::Base.shell.new
+      message = " #{error.message} "
+      message = shell.set_color(message, :white)
+      message = shell.set_color(message, :on_red)
+      shell.error message
+    end
+
+  end # Class methods
+
+  default_command :list
+
+  # Verbatim copy from Thor::Runner:
+  # Override Thor#help so it can give information about any class and any method.
+  #
+  def help(meth = nil)
+    if meth && !self.respond_to?(meth)
+      initialize_thorfiles(meth)
+      klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
+      self.class.handle_no_command_error(command, false) if klass.nil?
+      klass.start(["-h", command].compact, :shell => shell)
+    else
+      super
+    end
+  end
+
+  # Verbatim copy from Thor::Runner:
+  # If a command is not found on Thor::Runner, method missing is invoked and
+  # Thor::Runner is then responsible for finding the command in all classes.
+  #
+  def method_missing(meth, *args)
+    meth = meth.to_s
+    initialize_thorfiles(meth)
+    klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
+    self.class.handle_no_command_error(command, false) if klass.nil?
+    args.unshift(command) if command
+    klass.start(args, :shell => shell)
+  end
+
+  # Verbatim copy from Thor::Runner:
+  desc "list [SEARCH]", "List the available #{$PROGRAM_NAME} commands (--substring means .*SEARCH)"
+  method_options :substring => :boolean, :group => :string, :all => :boolean, :debug => :boolean
+  def list(search = "")
+    initialize_thorfiles
+
+    search = ".*#{search}" if options["substring"]
+    search = /^#{search}.*/i
+    group  = options[:group] || "standard"
+
+    klasses = Thor::Base.subclasses.select do |k|
+      (options[:all] || k.group == group) && k.namespace =~ search
+    end
+
+    display_klasses(false, false, klasses)
+  end
+
+  private
+
+  # Based on Thor::Runner, with exception of program name.
+  def self.banner(command, all = false, subcommand = false)
+    "#{$PROGRAM_NAME} " + command.formatted_usage(self, all, subcommand)
+  end
+
+  # Verbatim copy from Thor::Runner:
+  def self.exit_on_failure?
+    true
+  end
+
+  # This is one of the places this runner differ from Thor::Runner. It will
+  # instead load files for the current project.
+  #
+  # TODO(thomthom): Original arguments kept around for now, so avoid altering
+  # the methods that calls this. It might be that these arguments might be
+  # useful for optimizations later.
+  def initialize_thorfiles(_relevant_to = nil, _skip_lookup = false)
+    project = Skippy::Project.new(Dir.pwd)
+    return unless project.exist?
+    project.command_files { |filename|
+      unless Thor::Base.subclass_files.keys.include?(File.expand_path(filename))
+        Thor::Util.load_thorfile(filename, nil, options[:debug])
+      end
+    }
+  end
+
+  def display_app_banner
+    program_name = shell.set_color($PROGRAM_NAME.capitalize, :green)
+    version = shell.set_color('version', :clear)
+    program_version = shell.set_color(Skippy::VERSION, :yellow)
+    say "#{program_name} #{version} #{program_version}"
+  end
+
+  # Based on Thor::Runner:
+  def display_klasses(with_modules = false, show_internal = false, klasses = Thor::Base.subclasses)
+    unless show_internal
+      klasses -= [
+        Thor, Thor::Runner, Thor::Group,
+        Skippy, Skippy::CLI, Skippy::Command, Skippy::Command::Group
+      ]
+    end
+
+    fail Error, "No #{$PROGRAM_NAME.capitalize} commands available" if klasses.empty?
+
+    list = Hash.new { |h, k| h[k] = [] }
+    groups = klasses.select { |k| k.ancestors.include?(Thor::Group) }
+
+    # Get classes which inherit from Thor
+    (klasses - groups).each { |k|
+      list[k.namespace.split(":").first] += k.printable_commands(false)
+    }
+
+    # Get classes which inherit from Thor::Base
+    groups.map! { |k| k.printable_commands(false).first }
+    # Thor:Runner put these under 'root', but here we just avoid any name at
+    # all together.
+    list[''] = groups
+
+    display_app_banner
+    say
+    say 'Available commands:', :yellow
+
+    # Align all command descriptions. This means computing a fixed width for
+    # the first column.
+    col_width = list.map { |_, rows|
+      rows.map { |col| col.first.size }.max || 0
+    }.max
+
+    # Order namespaces with default coming first
+    list = list.sort { |a, b|
+      a[0].sub(/^default/, "") <=> b[0].sub(/^default/, "")
+    }
+    list.each { |n, commands|
+      display_commands(n, commands, col_width) unless commands.empty?
+    }
+  end
+
+  # Based on Thor::Runner:
+  def display_commands(namespace, list, col_width)
+    list.sort! { |a, b| a[0] <=> b[0] }
+
+    say shell.set_color(namespace, :yellow, true) unless namespace.empty?
+
+    list.each { |row|
+      row[0] = shell.set_color(row[0], :green) + shell.set_color('', :clear)
+    }
+    # TODO(thomthom): For some reason the column appear as half the width.
+    # Not sure why, so for now we apply this hack.
+    # TODO(thomthom): Because of the odd issue with col_width mentioned in
+    # `display_klasses` the table isn't truncated. Can probably re-enable if
+    # the col_width issue is fixed.
+    #print_table(list, :truncate => true, :indent => 2, :colwidth => col_width)
+    width = (col_width + 2) * 2
+    print_table(list, :indent => 2, :colwidth => width)
+  end
+  alias_method :display_tasks, :display_commands
+
+  # Based on Thor::Runner, skipping the yaml stuff:
+  def show_modules
+    info  = []
+    labels = %w[Modules Namespaces]
+
+    info << labels
+    info << ["-" * labels[0].size, "-" * labels[1].size]
+
+    print_table info
+    say ""
+  end
+
+end

data/lib/skippy/command.rb

@@ -0,0 +1,15 @@
+require 'thor'
+
+module Skippy
+  class Command < Thor
+
+    protected
+
+    # Customize the banner as we don't care for the 'skippy' prefix for each
+    # item in the list.
+    def self.banner(command, namespace = nil, subcommand = false)
+      "#{command.formatted_usage(self, true, subcommand)}"
+    end
+
+  end
+end

data/lib/skippy/error.rb

@@ -0,0 +1,4 @@
+module Skippy
+  class Error < StandardError
+  end
+end

data/lib/skippy/group.rb

@@ -0,0 +1,17 @@
+require 'thor/group'
+
+require 'skippy/command'
+
+module Skippy
+  class Command::Group < Thor::Group
+
+    protected
+
+    # Customize the banner as we don't care for the 'skippy' prefix for each
+    # item in the list.
+    def self.banner
+      "#{self_command.formatted_usage(self, false)}"
+    end
+
+  end
+end

data/lib/skippy/namespace.rb

@@ -0,0 +1,55 @@
+class Skippy::Namespace
+
+  def initialize(namespace)
+    unless valid?(namespace)
+      raise Skippy::Error, "'#{namespace}' is not a valid Ruby namespace"
+    end
+    @namespace = namespace
+  end
+
+  def basename
+    to_a.last
+  end
+
+  def open
+    @open ||= to_a.map { |part| "module #{part}" }.join("\n")
+    @open
+  end
+
+  def close
+    @close ||= to_a.reverse.map { |part| "end # module #{part}" }.join("\n")
+    @close
+  end
+
+  def to_a
+    parts(@namespace)
+  end
+
+  def to_name
+    basename_words(basename).join(' ')
+  end
+
+  def to_s
+    @namespace.dup
+  end
+
+  def to_underscore
+    basename_words(basename).map { |word| word.downcase }.join('_')
+  end
+
+  private
+
+  def basename_words(namespace_basename)
+    result = namespace_basename.scan(/[[:upper:]]+[[:lower:][:digit:]]*/)
+    result.empty? ? [namespace_basename.dup] : result
+  end
+
+  def parts(namespace)
+    namespace.split('::')
+  end
+
+  def valid?(namespace)
+    parts(namespace).all? { |part| /^[[:upper:]]/.match(part) }
+  end
+
+end

data/lib/skippy/project.rb

@@ -0,0 +1,90 @@
+require 'json'
+require 'pathname'
+
+require 'skippy/namespace'
+
+class Skippy::Project
+
+  PROJECT_FILENAME = 'skippy.json'.freeze
+
+  attr_reader :name, :namespace, :path, :author, :copyright, :license
+  attr_accessor :description
+
+  # Initialize a project for the provided path. If the path is within a project
+  # path the base path of the project will be found. Otherwise it's assumed that
+  # the path is the base for a new project.
+  #
+  # @param [Pathname, String] path
+  def initialize(path)
+    @path = find_project_path(path) || Pathname.new(path)
+    @namespace = Skippy::Namespace.new('Untitled')
+    @name = ''
+    @description = ''
+    @author = 'Unknown'
+    @copyright = "Copyright (c) #{Time.now.year}"
+    @license = 'None'
+  end
+
+  # @yield [filename]
+  # @yieldparam [String] filename the path to custom Skippy command
+  def command_files(&block)
+    files_pattern = File.join(path, 'skippy', '**', '*.rb')
+    Dir.glob(files_pattern) { |filename|
+      block.call(filename)
+    }
+  end
+
+  # Checks if a project exist on disk. If not it's just transient.
+  def exist?
+    File.exist?(filename)
+  end
+
+  # Full path to the project's configuration file. This file may not exist.
+  # @return [String]
+  def filename
+    File.join(path, PROJECT_FILENAME)
+  end
+
+  # @return [String]
+  def name
+    @name.empty? ? namespace.to_name : @name
+  end
+
+  # @param [String] namespace
+  def namespace=(namespace)
+    @namespace = Skippy::Namespace.new(namespace)
+  end
+
+  # Commits the project to disk.
+  def save
+    File.write(filename, to_json)
+  end
+
+  # @return [String]
+  def to_json
+    project_config = {
+      namespace: namespace,
+      name: name,
+      description: description
+    }
+    JSON.pretty_generate(project_config)
+  end
+
+  private
+
+  # Finds the root of a project based on any path within the project.
+  #
+  # @param [String] path
+  # return [Pathname, nil]
+  def find_project_path(path)
+    pathname = Pathname.new(path)
+    loop do
+      project_file = pathname.join(PROJECT_FILENAME)
+      return pathname if project_file.exist?
+      break if pathname.root?
+      pathname = pathname.parent
+    end
+    nil
+  end
+
+end

data/lib/skippy/skippy.rb

@@ -0,0 +1,9 @@
+require 'skippy/version'
+
+module Skippy
+
+  class << self
+    attr_accessor :app
+  end
+
+end

data/lib/skippy/version.rb

@@ -0,0 +1,3 @@
+module Skippy
+  VERSION = '0.1.0.a'.freeze
+end

data/skippy.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'skippy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "skippy"
+  spec.version       = Skippy::VERSION
+  spec.authors       = ["Thomas Thomassen"]
+  spec.email         = ["thomas@thomthom.net"]
+
+  spec.summary       = %q{CLI development tool for SketchUp extensions.}
+  spec.description   = %q{Automate common tasks for SketchUp extension development, including managing library dependencies.}
+  spec.homepage      = "https://github.com/thomthom/skippy"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+
+  spec.add_dependency "thor"
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: skippy
+version: !ruby/object:Gem::Version
+  version: 0.1.0.a
+platform: ruby
+authors:
+- Thomas Thomassen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Automate common tasks for SketchUp extension development, including managing
+  library dependencies.
+email:
+- thomas@thomthom.net
+executables:
+- skippy
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".vscode/settings.json"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- Skippy.sublime-project
+- app/boot.rb
+- app/commands/debug.rb
+- app/commands/new.rb
+- app/commands/template.rb
+- app/resources/commands/example.rb
+- app/templates/standard/%ext_name%.rb.tt
+- app/templates/standard/%ext_name%/main.rb.tt
+- app/templates/webdialog/extension.rb.erb
+- app/templates/webdialog/extension/html/dialog.html
+- app/templates/webdialog/extension/main.rb.erb
+- bin/bundler
+- bin/console
+- bin/rake
+- bin/setup
+- bin/skippy
+- bin/thor
+- exe/skippy
+- lib/skippy.rb
+- lib/skippy/app.rb
+- lib/skippy/cli.rb
+- lib/skippy/command.rb
+- lib/skippy/error.rb
+- lib/skippy/group.rb
+- lib/skippy/namespace.rb
+- lib/skippy/project.rb
+- lib/skippy/skippy.rb
+- lib/skippy/version.rb
+- skippy.gemspec
+homepage: https://github.com/thomthom/skippy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: CLI development tool for SketchUp extensions.
+test_files: []
+has_rdoc: