boot-cli 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 113a1635d8b52e8ad875680df5c22f26f4b4a31a
+  data.tar.gz: 1cab1f0e69adf3d67bac015ccba796831efbcf5b
+SHA512:
+  metadata.gz: b967c7b3be504a742067e59cd4b955abb5cd7c95c9e3461be03e41f8a40e62e0594775c2bbbf9c86cd479ca9fc2a7ed2ba164209c5b48634303f064fc792910f
+  data.tar.gz: 040e309eec454bc822ef2b98bf692170cb52aaab6e05a621a846906d765c6d3f45d784127bcfd8c28c87a70c18dd405cc390d1a3533f7b11886bbd5f9db84894

data/bin/boot

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+# Ad lib to include path
+$:.unshift File.dirname(File.expand_path(File.dirname(__FILE__))) + '/lib'
+
+# Require sub commands
+require 'Boot/Lib/autoload.rb'
+require 'boot.rb'
+Boot.main

data/lib/Boot/Lib/Commands/Config.rb

@@ -0,0 +1,28 @@
+include Boot::Lib::Core
+
+require 'JSON'
+
+module Boot::Lib::Commands
+  options_obj = Slop::Options.new
+  options_obj.on "--all", "Print all config options. Can not be used with any other arguments."
+  
+  Config = SubCommand.new(
+    'config', # Name of the sub command
+    'Read configuration options',
+    options_obj
+  ) { |options, args|
+    parsed_options = options.parse(args);
+    if (!parsed_options[:all])
+      option_name = args[0]
+      option_val = Boot.config.config[option_name]
+      if (option_val == nil)
+        puts "No option '#{option_name}'"
+      else
+        puts "#{option_name} = #{option_val}"
+      end
+    else
+      puts JSON.pretty_generate(Boot.config.config)
+    end
+  }
+  @Config
+end

data/lib/Boot/Lib/Commands/Help.rb

@@ -0,0 +1,17 @@
+include Boot::Lib::Core
+
+module Boot::Lib::Commands
+  options_obj = Slop::Options.new
+
+  Help = SubCommand.new(
+    'help', # Name of the command
+    'Print the help message', # Description
+    options_obj, # Has no options
+    false
+  ) do |_options, _args|
+    Boot.sub_commands.each do |_key, cmd|
+      cmd.print_help_message
+    end
+  end
+  @Help
+end

data/lib/Boot/Lib/Commands/New.rb

@@ -0,0 +1,77 @@
+include Boot::Lib::Core
+include Boot::Lib
+
+module Boot::Lib::Commands
+  options_obj = Slop::Options.new suppress_errors: true
+  options_obj.string '-o', '--out', 'Spesify where to save the template.', default: File.dirname(__FILE__)
+  options_obj.banner = "Usage: boot new 'template-name' [--out 'out-dir'] [-- 'template-options']"
+
+  New = SubCommand.new(
+    'new', # Name of the sub command
+    'Creates a new project from a template',
+    options_obj
+  ) { |options, args|
+    parsed_options = options.parse(args)
+
+    # The first argument, as long as not a option
+    # is the template
+    if (!Boot::Lib::Core::SubCommand.is_flag(args[0]))
+      template_name = args[0]
+    else
+      puts options_obj.banner
+      next
+    end
+
+
+    output_path = !parsed_options[:out].nil? ? Dir.pwd + '/' + parsed_options[:out] : Dir.pwd
+
+    if (Dir.exists?(output_path) && !(Dir.entries(output_path) - %w{ . .. }).empty?)
+      puts "Error: #{output_path} exists and is not empty"
+      next # terminate
+    end
+
+    if (File.exists?(output_path))
+      puts "Error: #{output_path} exists and is a file"
+      next # terminate
+    end
+
+    # Strip all args before the -- arg, signaling args to the template
+    c = 0
+    while c < args.length do
+      break if (args[c] == '--')
+      c+=1
+    end
+    template_args = args[c+1..-1]
+    if (template_args.nil?) # no -- found
+      template_args = []
+    end
+
+    # Get template by name
+    template = Core::Template.get_template_by_name(template_name)
+    if template.nil?
+      puts "Fatal: Could not find template #{template_name}"
+      exit(1)
+    end
+
+    # Create a project base on the template
+    puts "Creating #{output_path} based on '#{template.name}' template"
+    creation_thread = Thread.new {
+      begin
+        template.create(template_args, output_path)
+      rescue ArgumentError => e
+        puts e.message
+      end
+    }
+    loading_thread = Thread.new {
+      print "Doing stuff"
+      while true do
+        print ".."
+        sleep 0.3
+      end
+    }
+    creation_thread.join
+    loading_thread.exit
+    puts "\nDone!"
+  }
+  @New
+end

data/lib/Boot/Lib/Commands/Template.rb

@@ -0,0 +1,87 @@
+include Boot::Lib::Core
+include Boot::Lib
+
+require 'JSON'
+
+module Boot::Lib::Commands
+  options_obj = Slop::Options.new
+  options_obj.on "--list", "List all template names"
+  options_obj.on "-v", "--verbose", "Print more info"
+  
+  Template = SubCommand.new(
+    'template', # Name of the sub command
+    'Print info for a template',
+    options_obj
+  ) { |options, args|
+    parsed_options = options.parse(args)
+    if (parsed_options[:list])
+      templates = {}
+
+      Boot.config.templates_path.each do |dir|
+        Dir[dir + "/*"].each do |template_path|
+          name = template_path.split('/')[-1]
+          if (templates[name].nil?)
+            templates[name] = Core::Template.get_template_by_name(name)
+          end
+        end
+      end
+
+      templates.each do |key, value|
+        if (parsed_options[:verbose])
+          puts "key:      " + key
+          puts "name:     " + value.name
+          puts "location: " + value.path
+          puts "description:\n"
+          puts value.description
+          puts
+        else
+          puts key
+        end
+      end
+
+      next
+    end
+
+    if (args.length != 1)
+      puts "usage 'boot template [template name]'"
+    end
+
+    template_name = args[0]
+    template = Core::Template.get_template_by_name(template_name)
+
+    if (template.nil?)
+      puts "Could not find template '#{template_name}'"
+    else
+      msg = ''
+      msg << 'Template:    ' + template.name + "\n"
+      msg << 'Description: ' + template.description + "\n"
+      msg << 'Location:    ' + template.path + "\n"
+      msg << "\nOptions\n"
+      
+      template.template_options.each do |key, value|
+        msg << key
+        msg << ' '
+
+        if (!value['values'].nil?)
+          msg << '['
+          value['values'].each do |key,value|
+            msg << "#{key}/"
+          end
+          msg = msg[0..-2] # Remove the last /
+          msg << "]\n"
+        elsif(!value['symbol'].nil?)
+          msg << value['symbol']
+          msg << "\n"
+        else
+          fail if (value['files'].nil?) # Assertion
+          msg << "\n"
+        end
+        msg << "\t" + value['description']
+        msg << "\n\n"
+      end
+
+      puts msg
+    end
+  }
+  @Template
+end

data/lib/Boot/Lib/Commands/Version.rb

@@ -0,0 +1,15 @@
+include Boot::Lib::Core
+
+module Boot::Lib::Commands
+  options_obj = Slop::Options.new
+  
+  Version = SubCommand.new(
+    'version', # Name of the sub command
+    'Print the version',
+    options_obj,
+    false
+  ) { |options, args|
+    puts Boot::VERSION
+  }
+  @Version
+end

data/lib/Boot/Lib/Core/Config.rb

@@ -0,0 +1,84 @@
+require 'JSON'
+
+include Boot::Lib::Core
+
+module Boot::Lib::Core
+  class Config
+    #config array
+    attr_reader :config
+
+    # The include paths
+    attr_reader :templates_path
+    
+    def initialize(config)
+      @config = config
+
+      # Append the lib/templates dir to templates_path in config
+      if (@config.key?('templates_path'))
+        if (@config['templates_path'].is_a?(String))
+          @config['templates_path'] = [@config['templates_path']]
+        end
+
+        if (!@config['templates_path'].is_a?(Array))
+            msg = "templates_path in config must be either a string or array"
+            fail InvalidConfigException.new msg
+        end
+
+        i = 0
+        while (i < @config['templates_path'].length)
+          # Expand all paths in templates_path
+          # Starting in the user directory
+          user_dir = File.expand_path('~/')
+          path = @config['templates_path'][i]
+          @config['templates_path'][i] = File.expand_path(path, user_dir)
+          i+=1
+        end
+      else
+        @config['templates_path'] = []
+      end
+      
+      # Add lib/templates
+      # This will be the last place to look for a template
+      @config['templates_path'].push(Boot.dir + "/templates/templates")
+
+      @templates_path = @config['templates_path']
+
+      # If templates_path is not defined
+      if @templates_path.nil?
+        msg = ''
+        msg << "Invalid config file: templates_path not defined\n"
+        msg << "Please set this to the directory(s) where your\n"
+        msg << "templates are located\n"
+        fail InvalidConfigException.new msg
+      end
+
+      # If templates_path is defined, but invalid path
+      if !@templates_path.is_a?(Array) && !File.directory?(@templates_path)
+        msg = ''
+        msg << "Invalid config file: '#{@templates_path}' is not a directory\n"
+        msg << "Please set this to the directory(s) where your "
+        msg << "templates are located\n"
+        fail InvalidConfigException.new msg
+      end
+
+      # If templates_path is an array
+      if @templates_path.is_a?(Array)
+        notDirs = []
+
+        # Add each path that is invalid to notDirs
+        @templates_path.each do |path|
+          notDirs.push(path) unless File.directory? path
+        end
+
+        # If any element in notDirs, invalid config
+        if notDirs.length > 0
+          msg = ''
+          msg << "Invalid config file:\n"
+          msg << 'the path(s): ' + notDirs.join(', ') + "\n"
+          msg << "Are not directories\n"
+          fail InvalidConfigException.new msg
+        end
+      end
+    end
+  end
+end

data/lib/Boot/Lib/Core/InvalidConfigException.rb

@@ -0,0 +1,4 @@
+module Boot::Lib::Core
+  class InvalidConfigException < Exception
+  end
+end

data/lib/Boot/Lib/Core/InvalidTemplateException.rb

@@ -0,0 +1,4 @@
+module Boot::Lib::Core
+  class InvalidTemplateException < Exception
+  end
+end

data/lib/Boot/Lib/Core/SubCommand.rb

@@ -0,0 +1,61 @@
+module Boot::Lib::Core
+  class SubCommand
+    attr_reader :name
+    attr_reader :description
+    attr_reader :options
+
+    # If true, print help message on empty args
+    attr_reader :assume_help
+
+    def initialize(name, description, options, assume_help = true, &block)
+      @name        = name
+      @description = description
+      @options     = options
+      @block       = block
+      @assume_help  = assume_help
+    end
+
+    def run(args)
+      begin
+        # If no option spesified, assume --help
+        # The underscore is a hack, see rescue block
+        if (assume_help)
+          fail Slop::UnknownOption.new "Unknown option --help", "--help" if (args.length == 0)
+        end
+
+        @options.parse(args); # Dryrun to check for argument errors
+        @block.call(@options, args)
+      rescue Slop::UnknownOption => e
+        # Hack to get around the lack of e.getUnknownOption()
+        # TODO Fix once avaiable
+        if (e.flag == '--help')
+          print_help_message
+        else
+          puts "#{e.message}. Try boot #{@name} --help"
+        end
+      end
+    end
+
+    def self.is_flag(str)
+      return str.start_with?("--") || (str.start_with?("-") && str.length == 2)
+    end
+
+    def print_help_message
+      puts 'boot ' + @name
+      if (@description != '')
+        puts "\tDescription:"
+        puts "\t" + @description
+      end
+      if @options.options.length > 0
+        puts
+        puts "\tArguments:"
+        @options.each do |a|
+          print "\t" + '%-16.16s' % (a.flags * ', ')
+          print "\t"
+          print a.desc + "\n"
+        end
+      end
+      puts
+    end
+  end
+end

data/lib/Boot/Lib/Core/Template.rb

@@ -0,0 +1,375 @@
+require 'fileutils.rb'
+require 'json-schema'
+require 'JSON'
+
+include Boot::Lib::Core
+
+module Boot::Lib::Core
+  class Template
+    attr_reader :name
+    attr_reader :description
+    attr_reader :static_files
+    attr_reader :path
+
+    # Non static files, based on arguments
+    # Arguments with values, fx. --vcs git, or --vcs=git
+    #
+    # Structure
+    # "--vcs" : {     //Argument options, requires a value
+    #   "values" : {
+    #     "git" : [{"vcs/.gitignore":".gitignore"}],
+    #     "svn" : [{"vcs/.svnignore":".svnignore"}]
+    #   }
+    #   "alias" : ["-v"] //Not implemented yet
+    #   "description" : "Choose version controll system for the project",
+    #   "required" : false,
+    #   "default" : "git" //Can not be used with require:true
+    # }
+    #
+    # "--on-or-off" : {
+    #   "alias" : ["-o", "--on"] //Not implemented yet
+    #   "files" : [{"files/to/add":"some/dir/file"}, {"if/present":"some/dir/file"}],
+    #   "description" : "some description",
+    # }
+    attr_reader :option_files
+
+    # Slop options object
+    attr_reader :options
+
+    # Symbols
+    # {
+    #   "--flag" : {
+    #     "symbol"   : "name"
+    #     "required" : true/false
+    #     "default"  : "" //Not present if require is true
+    #   }
+    # }
+    attr_reader :symbols
+
+    attr_reader :template_options
+
+    # Creates a Template object
+    # Might throw an InvalidTemplateException
+    def initialize(path)
+      # Check the template
+      if (!File.directory?(path))
+        fail InvalidTemplateException.new("Path is not a directory")
+      end
+      if (!File.exist?(path + "/template.json"))
+        fail InvalidTemplateException.new("Missing template.json file")
+      end
+
+      templateJsonFile = File.open(path + "/template.json", "r")
+      templateConfig = JSON.parse(templateJsonFile.read)
+      templateJsonFile.close
+
+      templateJsonSchemaFile = File.open(Boot::LIB_PATH + '/template.json-schema', "r")
+      templateJsonSchema = JSON.parse(templateJsonSchemaFile.read)
+      templateJsonSchemaFile.close
+
+      errors = JSON::Validator.fully_validate(templateJsonSchema, templateConfig)
+      if (errors.length > 0)
+        msg = ''
+        msg << 'Invalid template.json file for '
+        msg << "#{name} template in #{path}\n"
+        msg << errors * "\n"
+
+        fail InvalidTemplateException.new msg
+      end
+
+      @name = templateConfig['name'];
+      @description = templateConfig['description']
+      @static_files = templateConfig['static']
+
+      if ((!static_files.is_a?(Array)) && (!static_files.nil?))
+        @static_files = [@static_files]
+      end
+
+      @path = path
+      @template_options = templateConfig['options']
+      @template_options = {} if @template_options.nil?
+
+      @options = Slop::Options.new
+
+      options.banner = "usage: #{$0} new --template #{name} [--out DIR] [options]"
+
+      # Validate static folders
+      @static_files.each do |static_dir_path|
+        msg = ''
+        static_dir_path = path + '/' + static_dir_path
+        if (!File.exist?(static_dir_path) || File.file?(static_dir_path))
+          msg << "static: #{static_dir_path} is not a directory\n"
+        end
+        if (msg != '')
+          fail InvalidTemplateException.new msg
+        end
+      end
+
+      # Create slop option object
+      template_options.each do |option, value|
+        if (!value['files'].nil?) # This is a flag
+          options.on option, value['description']
+        elsif ((!value['values'].nil?) || (!value['symbol'].nil?))  # This is an argument
+          if (!value['default'].nil?)
+            options.string option, value['description'], default:value['default']
+          else
+            options.string option, value['description']
+          end
+        else
+          throw InvalidTemplateException.new "Inavlid template.json file for #{name}"
+        end
+      end
+      
+      # Parse out the symbols
+      @option_files = template_options.clone
+      @symbols = {}
+      template_options.each do |key, value|
+        if (!value['symbol'].nil?)
+          # Remove from option_files, this is a symbol
+          option_files.delete(key)
+          symbols[key] = {}
+          
+          symbols[key]['symbol'] = value['symbol']
+          if (!value['default'].nil?)
+            symbols[key]['require'] = false
+            symbols[key]['default'] = value['default']
+          else
+            symbols[key]['require'] = true
+          end
+        end
+      end
+      
+      # "Parse" option_files array
+      # Forces a spesific structure for this array
+      option_files.each do |flag, optionObject|
+        if (!optionObject['values'].nil?)   # IF IS ARGUMENT
+          values = optionObject['values']   
+          raise InvalidTemplateException.new if (!values.is_a?(Hash))
+
+          values.each do |valueKey, files|
+            begin
+              values[valueKey] = Template.structure_files(files)
+            rescue ArgumentError
+              throw new InvalidTemplateException
+            end
+          end
+        elsif (!optionObject['files'].nil?) # IF IS FLAG
+          begin
+            optionObject['files'] = Template.structure_files(optionObject['files'])
+          rescue ArgumentError
+            throw InvalidTemplateException.new
+          end
+        else
+          # Invalid, missing file/values
+        end
+      end
+    end
+
+
+    # Create a new "project" base
+    # on this template, to the directory
+    # "dir".
+    def create(args, dir)
+      # Make the output dir if
+      # it does not exist
+      begin
+        Dir.mkdir(dir) if (!Dir.exist?(dir))
+      rescue SystemCallError => e
+        puts e.message
+        exit(1)
+      end
+      
+      # Parse the arguments
+      parsedOptions = options.parse(args)
+
+      defined_symbols = {}
+      symbols.each do |flag, object|
+        if (!parsedOptions[flag].nil?)
+          defined_symbols[object['symbol']] = parsedOptions[flag]
+        elsif (object['require']) # Not defined and required
+          fail ArgumentError.new "Must define '#{flag}' for '#{name}' template"
+        end
+      end
+
+
+      # Copy over the static files
+      if (!static_files.nil?)
+        static_files.each do |static_files_path|
+          static_file_base = path + '/' + static_files_path
+          Dir[static_file_base + '/**/*'].each do |file_path|
+            # Do not copy dummy files
+            next if (File.basename(file_path) == "___dummy-file___")
+            
+            file_name = file_path[static_file_base.length..-1]
+            file_name = replace_symbols(file_name, defined_symbols)
+            if (File.directory?(file_path))
+              FileUtils.mkdir dir + file_name unless File.exist? dir + file_name
+            else
+              FileUtils.cp(file_path, dir + file_name)
+            end
+          end
+        end
+      end
+
+      # Copy non static files
+      option_files.each do |flag, object|
+        files = {}
+        if (!object['values'].nil?)
+          values = object['values']
+          files = values[parsedOptions[flag]]
+          if (files.nil?)
+            if (object['require'])
+              puts "Missing template argument #{flag}"
+              exit(1)
+            else
+              next
+            end
+          end
+        elsif (!object['files'].nil?)
+          if (!parsedOptions[flag])
+            if (object['require'])
+              puts "Missing template argument #{flag}"
+            else
+              next
+            end
+          end
+          files  = object['files']
+        else
+          raise InvalidTemplateException.new
+        end
+
+        files.each do |fileHash|
+          fileHash.each do |src, dest|
+            dest = replace_symbols(dest, defined_symbols)
+            FileUtils.cp(path + '/' + src, dir + '/' + dest)
+          end
+        end
+      end
+
+      options.each do |key, value|
+        option = option_files[key]
+        if (!option.nil?)
+          files_to_copy = nil
+          if (!option['values'].nil?) # Argument
+            files_to_copy = option['values'][value]
+          elsif (!option['files'].nil?) # Flag
+            files_to_copy = option['files']
+          else
+          end
+
+          files_to_copy.each do |file, out_file|
+            out_file = replace_symbols(out_file, defined_symbols)
+            FileUtils.cp(path + '/' + file, dir + '/' + out_file)
+          end
+        end
+      end
+
+      # Replace symbols in content of files
+      Dir.glob(dir + "/**/*").each do |file|
+        next unless File.file? file
+        file_object_r = File.open(file, "r")
+        file_content = file_object_r.read
+        file_object_r.close
+        file_object_w = File.open(file, "w")
+
+        # If this doesent work, dont stress
+        # Probably just not an UTF-8 text file error
+        begin
+          file_object_w.write replace_symbols(file_content, defined_symbols)
+        rescue ArgumentError => e
+          file_object_w.close
+          next
+        end
+        file_object_w.close
+      end
+    end
+
+    # Makes a file hash/array from a template json
+    # into a predictable structure
+    # For example 
+    # [
+    #   {
+    #     "somefile-src" : "dest",
+    #     "someother-src" : "somedest"
+    #   },
+    #   {
+    #     "file-src" : "somesomedest"
+    #   },
+    #   "filefile"
+    # ]
+    #
+    # will become
+    #
+    # [
+    #   { "somefile-src"  : "dest" },
+    #   { "someother-src" : "somedest"},
+    #   { "file-src"      : "somesomedest" },
+    #   { "filefile"      : "filefile"}
+    # ]
+    #
+    # Or
+    # somefile
+    # would become
+    # [{"somefile":"somefile"}]
+    def self.structure_files(files)
+      if (files.is_a?(String))
+        return [{"#{files}"=>"#{files}"}]
+      end
+
+      if (files.is_a?(Hash))
+        files = [files]
+      end
+
+      fail ArgumentError.new unless (files.is_a?(Array))
+
+      structFiles = []
+      files.each do |fileObject|
+        # File object may be a String or Hash
+        if (fileObject.is_a?(String))
+          structFiles.push({"#{fileObject}" => "#{fileObject}"})
+        elsif (fileObject.is_a?(Hash))
+          fileObject.each do |fileSrc, fileDest|
+            structFiles.push("#{fileSrc}" => "#{fileDest}")
+          end
+        else
+          fail ArgumentError.new
+        end
+      end
+
+      return structFiles
+    end
+
+    def replace_symbols(string, findReplace)
+      findReplace.each do |find, replace|
+        string = string.gsub("[[!" + find + "]]", replace)
+      end
+      return string
+    end
+
+    # --------- STATIC INTERFACE ----------
+
+    # Create a template object form name
+    # Tries to find the template in the
+    # include paths spesified in the condif
+    # file
+    # return nil if the template can no
+    # be found
+    def self.get_template_by_name(name)
+      config = Boot.config
+      includePaths = config.templates_path
+      path = '';
+      includePaths.each { |includePath|
+        testPath = includePath + '/' + name;
+        if File.directory?(testPath);
+          path = testPath;
+          break;
+        end
+      }
+      if path == ''
+        return nil
+      else
+        return Template.new(path);
+      end
+    end
+  end
+end