hotplate 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fba850693cc228819c3a4e0e52b62f2d6bbec008
+  data.tar.gz: 7b8636e8846d340bd2feb44198cdeafbf42d0c98
+SHA512:
+  metadata.gz: f29ba82dadbacc47cdb18130728cae5475cfcb71dee43c54858a9a77099bda47ccd340812244a9afd209381c7291c62e1bad1170f50ac94a89d18d812258aee2
+  data.tar.gz: e6b3dad697fb6826601f9794e2cd05874c61b948420f08b83371c23d57a438c701a60f33d781fcc8e162eb0d6e1cea74ea937d5753c1cb3f31619cc9ea648cfd

data/Gemfile

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

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/toast

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'hotplate'

data/hotplate.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hotplate/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hotplate"
+  spec.version       = HotPlate::VERSION
+  spec.authors       = ["Jaci R"]
+  spec.email         = ["jaci.brunning@gmail.com"]
+
+  spec.summary       = %q{Toast module deployment made easy}
+  spec.homepage      = "http://github.com/Open-RIO/HotPlate"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.bindir        = "bin"
+  spec.files = Dir.glob("lib/**/*") + ['Rakefile', 'hotplate.gemspec', 'Gemfile', 'Rakefile']
+  spec.executables   = ["toast"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+end

data/lib/hotplate/cli/build.rb

@@ -0,0 +1,51 @@
+if File.exist? "#{dir}/build.gradle"
+  puts "Attempting to build Java Project"
+  if os == :windows
+    system("(cd #{dir} && gradlew build)")
+  else
+    system("(cd #{dir} && ./gradlew build)")
+  end
+elsif File.exist? "#{dir}/module.json"
+  prebuild = File.absolute_path(File.join(dir, "prebuild.rb"))
+  build = File.absolute_path(File.join(dir, "build.rb"))
+
+  require prebuild if File.exist? prebuild
+
+  require 'zip'
+  puts "Attempting to build JavaScript project"
+  exppath = File.expand_path(".", dir)
+  buildfiles = Dir[exppath + "/**/*"]
+  exclusions = ["build", "build/*.jsm"]
+  exclusions << File.read("#{dir}/exclude.build").split(/\r?\n/) if File.exist? "#{dir}/exclude.build"
+  exclusion_list = []
+  exclusions = exclusions.flatten
+  exclusions.each {|excl| exclusion_list << Dir[exppath + "/" + excl]}
+  file_list = buildfiles - exclusion_list.flatten
+
+  moduleconfig = File.read(File.join(dir, "module.json"))
+  archive_name = moduleconfig.scan(/"name"\s*:\s*"(.*)"/)[0][0]
+  version_match = moduleconfig.scan(/"version"\s*:\s*"(.*)"/)
+  archive_name += "_#{version_match[0][0]}" if version_match.length > 0
+
+  archive_name += ".jsm"
+  FileUtils.mkdir "#{dir}/build" unless File.exist? "#{dir}/build"
+  archive_path = "#{dir}/build/#{archive_name}"
+
+  require build if File.exist? build
+
+  puts "Building Archive: #{archive_name}"
+  puts "Including Files: "
+  puts file_list.map {|x| "\t#{x.gsub(/\\/, "/").gsub(dir.gsub(/\\/, "/"), "")}\n"}
+
+  FileUtils.rm_rf archive_path if File.exist? archive_path
+  Zip::File.open(archive_path, Zip::File::CREATE) do |zipfile|
+    file_list.each do |fn|
+      relative = fn.gsub(/\\/, "/").gsub(dir.gsub(/\\/, "/"), "")
+      zipfile.add(relative[1..relative.length], fn)
+    end
+  end
+
+  puts "Build Complete"
+else
+  puts "Can't build: not a valid Toast Project"
+end

data/lib/hotplate/cli/init.rb

@@ -0,0 +1,64 @@
+require 'FileUtils'
+
+def java
+  puts "What is your Team Number? (0000)"
+  team = gets.chop!.to_i.to_s     # Ensures it's a proper number :)
+  clazz = "#{@path}/src/main/java/frc/team#{team}/#{@name}/RobotModule.java"
+  jin = File.expand_path "../../java", __FILE__
+  FileUtils.cp_r "#{jin}/.", @path
+
+  build = File.read File.join(@path, "build.gradle")
+  build = build.gsub "%%TEAM", team
+  build = build.gsub "%%NAME", @name
+  File.write File.join(@path, "build.gradle"), build
+
+  templ = File.join(@path, "template.java")
+  template = File.read templ
+  template = template.gsub "%%TEAM", team
+  template = template.gsub "%%NAMED", @name.downcase
+  template = template.gsub "%%NAME", @name
+  FileUtils.mkdir_p File.expand_path("..", clazz)
+  File.write clazz, template
+  File.delete templ
+
+  begin
+    FileUtils.chmod 0777, %w(build.gradle, gradlew)
+  rescue; end
+end
+
+def javascript
+  puts "What is your main script class name? [main.js]"
+  name = gets.chop!
+  name = "main.js" if name == ""
+  name += ".js" unless name =~ /^(.*)\.js$/
+  File.write("#{@path}/module.json", "{\n\t\"name\": \"#{@name}\",\n\t\"script\": \"#{name}\"\n}")
+  File.write("#{@path}/#{name}", "console.log('Hello Toast!');")
+end
+
+puts "Creating a new Toast Module."
+
+puts "What is the name of your Module?"
+@name = gets.chop!
+@path = File.join dir, @name
+if File.exist? @path
+  puts "Module already exists? Want to override? (THIS CANNOT BE UNDONE) [y/n]"
+  inp = gets.chop!
+  if inp =~ /(y(es)?)|1|(t(rue)?)/i
+    puts "Overriding..."
+    FileUtils.rm_rf @path
+  else
+    puts "Aborting..."
+    exit
+  end
+end
+FileUtils.mkdir @path
+
+puts "What kind of Toast Module would you like to create? [java/javascript] (java)"
+option = gets.chop!
+if option =~ /javas(cript)?/i
+  javascript
+else
+  java
+end
+
+puts "Toast Module Created! #{@name}"

data/lib/hotplate/cli/main.rb

@@ -0,0 +1,39 @@
+require 'optparse'
+
+trap("INT"){exit}
+
+OptionParser.new do |o|
+  o.on("-d DIRECTORY", "--directory", "The directory to start in") {|dir| @dir = dir}
+end.parse!
+
+def dir
+  @dir ||= "."
+  File.absolute_path @dir
+end
+
+def os
+  if (/Windows/ =~ ENV['OS']) != nil
+    return :windows
+  elsif (/darwin/ =~ RUBY_PLATFORM) != nil
+    return :darwin
+  else
+    return :linux
+  end
+end
+
+def gemload name
+    libroot = File.expand_path "../../gems", __FILE__
+    $:.unshift Dir[libroot + "/#{name}-*/lib"][0]
+end
+
+gemload "rubyzip"
+
+puts "Error: No option selected!" unless ARGV.length > 0
+first_arg = ARGV.shift
+
+begin
+  (puts "recursion is a bad idea idea idea idea"; exit;) if first_arg == 'main'
+  require_relative "#{first_arg}"
+rescue LoadError
+  puts "Invalid Option: #{first_arg}"
+end

data/lib/hotplate/gems/rubyzip-1.1.7/README.md

@@ -0,0 +1,271 @@
+# rubyzip
+[![Gem Version](https://badge.fury.io/rb/rubyzip.svg)](http://badge.fury.io/rb/rubyzip)
+[![Build Status](https://secure.travis-ci.org/rubyzip/rubyzip.svg)](http://travis-ci.org/rubyzip/rubyzip)
+[![Code Climate](https://codeclimate.com/github/rubyzip/rubyzip.svg)](https://codeclimate.com/github/rubyzip/rubyzip)
+[![Coverage Status](https://img.shields.io/coveralls/rubyzip/rubyzip.svg)](https://coveralls.io/r/rubyzip/rubyzip?branch=master)
+
+rubyzip is a ruby library for reading and writing zip files.
+
+## Important note
+
+Rubyzip interface changed!!! No need to do `require "zip/zip"` and `Zip` prefix in class names removed.
+
+If you have issues with any third-party gems that require an old version of rubyzip, you can use this workaround:
+
+```ruby
+gem 'rubyzip', '>= 1.0.0' # will load new rubyzip version
+gem 'zip-zip' # will load compatibility for old rubyzip API.
+```
+
+## Requirements
+
+* Ruby 1.9.2 or greater
+
+## Installation
+rubyzip is available on RubyGems, so:
+
+```
+gem install rubyzip
+```
+
+Or in your Gemfile:
+
+```ruby
+gem 'rubyzip'
+```
+
+## Usage
+
+### Basic zip archive creation
+
+```ruby
+require 'rubygems'
+require 'zip'
+
+folder = "Users/me/Desktop/stuff_to_zip"
+input_filenames = ['image.jpg', 'description.txt', 'stats.csv']
+
+zipfile_name = "/Users/me/Desktop/archive.zip"
+
+Zip::File.open(zipfile_name, Zip::File::CREATE) do |zipfile|
+  input_filenames.each do |filename|
+    # Two arguments:
+    # - The name of the file as it will appear in the archive
+    # - The original file, including the path to find it
+    zipfile.add(filename, folder + '/' + filename)
+  end
+  zipfile.get_output_stream("myFile") { |os| os.write "myFile contains just this" }
+end
+```
+
+### Zipping a directory recursively
+Copy from [here](https://github.com/rubyzip/rubyzip/blob/05916bf89181e1955118fd3ea059f18acac28cc8/samples/example_recursive.rb )
+
+```ruby
+require 'rubygems'
+require 'zip'
+# This is a simple example which uses rubyzip to
+# recursively generate a zip file from the contents of
+# a specified directory. The directory itself is not
+# included in the archive, rather just its contents.
+#
+# Usage:
+# require /path/to/the/ZipFileGenerator/Class
+# directoryToZip = "/tmp/input"
+# outputFile = "/tmp/out.zip"
+# zf = ZipFileGenerator.new(directoryToZip, outputFile)
+# zf.write()
+
+class ZipFileGenerator
+  # Initialize with the directory to zip and the location of the output archive.
+  def initialize(inputDir, outputFile)
+    @inputDir = inputDir
+    @outputFile = outputFile
+  end
+  # Zip the input directory.
+  def write()
+    entries = Dir.entries(@inputDir); entries.delete("."); entries.delete("..")
+    io = Zip::File.open(@outputFile, Zip::File::CREATE);
+    writeEntries(entries, "", io)
+    io.close();
+  end
+  # A helper method to make the recursion work.
+  private
+  def writeEntries(entries, path, io)
+    entries.each { |e|
+      zipFilePath = path == "" ? e : File.join(path, e)
+      diskFilePath = File.join(@inputDir, zipFilePath)
+      puts "Deflating " + diskFilePath
+      if File.directory?(diskFilePath)
+        io.mkdir(zipFilePath)
+        subdir =Dir.entries(diskFilePath); subdir.delete("."); subdir.delete("..")
+        writeEntries(subdir, zipFilePath, io)
+      else
+        io.get_output_stream(zipFilePath) { |f| f.print(File.open(diskFilePath, "rb").read())}
+      end
+    }
+  end
+end
+```
+
+### Save zip archive entries in sorted by name state
+
+To saving zip archives in sorted order like below you need to set `::Zip.sort_entries` to `true`
+
+```
+Vegetable/
+Vegetable/bean
+Vegetable/carrot
+Vegetable/celery
+fruit/
+fruit/apple
+fruit/kiwi
+fruit/mango
+fruit/orange
+```
+
+After this entries in zip archive will be saved in ordered state.
+
+### Reading a Zip file
+
+```ruby
+Zip::File.open('foo.zip') do |zip_file|
+  # Handle entries one by one
+  zip_file.each do |entry|
+    # Extract to file/directory/symlink
+    puts "Extracting #{entry.name}"
+    entry.extract(dest_file)
+
+    # Read into memory
+    content = entry.get_input_stream.read
+  end
+
+  # Find specific entry
+  entry = zip_file.glob('*.csv').first
+  puts entry.get_input_stream.read
+end
+```
+
+### Password Protection (Experimental)
+
+RubyZip supports reading/writing zip files with traditional zip encryption (a.k.a. "ZipCrypto"). AES encryption is not yet supported. It can be used with buffer streams, e.g.:
+
+```ruby
+Zip::OutputStream.write_buffer(::StringIO.new(''), Zip::TraditionalEncrypter.new('password')) do |out|
+  out.put_next_entry("my_file.txt")
+  out.write my_data
+end.string
+```
+
+This is an experimental feature and the interface for encryption may change in future versions.
+
+## Known issues
+
+### Modify docx file with rubyzip
+
+Use `write_buffer` instead `open`. Thanks to @jondruse
+
+```ruby
+buffer = Zip::OutputStream.write_buffer do |out|
+  @zip_file.entries.each do |e|
+    unless [DOCUMENT_FILE_PATH, RELS_FILE_PATH].include?(e.name)
+      out.put_next_entry(e.name)
+      out.write e.get_input_stream.read
+     end
+  end
+
+  out.put_next_entry(DOCUMENT_FILE_PATH)
+  out.write xml_doc.to_xml(:indent => 0).gsub("\n","")
+
+  out.put_next_entry(RELS_FILE_PATH)
+  out.write rels.to_xml(:indent => 0).gsub("\n","")
+end
+
+File.open(new_path, "w") {|f| f.write(buffer.string) }
+```
+
+## Configuration
+
+By default, rubyzip will not overwrite files if they already exist inside of the extracted path.  To change this behavior, you may specify a configuration option like so:
+
+```ruby
+Zip.on_exists_proc = true
+```
+
+If you're using rubyzip with rails, consider placing this snippet of code in an initializer file such as `config/initializers/rubyzip.rb`
+
+Additionally, if you want to configure rubyzip to overwrite existing files while creating a .zip file, you can do so with the following:
+
+```ruby
+Zip.continue_on_exists_proc = true
+```
+
+If you want to store non english names and want to open properly file on Windows(pre 7) you need to set next option:
+
+```ruby
+Zip.unicode_names = true
+```
+
+In some zip date of files stored in incorrect format. You can hide warning about it by using:
+
+```ruby
+Zip.warn_invalid_date = false
+```
+
+You can set the default compression level like so:
+
+```ruby
+Zip.default_compression = Zlib::DEFAULT_COMPRESSION
+```
+It defaults to `Zlib::DEFAULT_COMPRESSION`. Possible values are `Zlib::BEST_COMPRESSION`, `Zlib::DEFAULT_COMPRESSION` and `Zlib::NO_COMPRESSION`
+
+All settings in same time
+
+```ruby
+  Zip.setup do |c|
+    c.on_exists_proc = true
+    c.continue_on_exists_proc = true
+    c.unicode_names = true
+    c.default_compression = Zlib::BEST_COMPRESSION
+  end
+```
+
+By default Zip64 support is disabled for writing. To enable it do next:
+
+```ruby
+Zip.write_zip64_support = true
+```
+
+_NOTE_: If you will enable Zip64 writing then you will need zip extractor with Zip64 support to extract archive.
+
+## Developing
+
+To run tests you need run next commands:
+
+```
+bundle install
+rake
+```
+
+## Website and Project Home
+
+http://github.com/rubyzip/rubyzip
+
+http://rdoc.info/github/rubyzip/rubyzip/master/frames
+
+## Authors
+
+Alexander Simonov ( alex at simonov.me)
+
+Alan Harper ( alan at aussiegeek.net)
+
+Thomas Sondergaard (thomas at sondergaard.cc)
+
+Technorama Ltd. (oss-ruby-zip at technorama.net)
+
+extra-field support contributed by Tatsuki Sugiura (sugi at nemui.org)
+
+## License
+
+rubyzip is distributed under the same license as ruby. See
+http://www.ruby-lang.org/en/LICENSE.txt

data/lib/hotplate/gems/rubyzip-1.1.7/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib'
+  test.libs << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+#Rake::TestTask.new(:zip64_full_test) do |test|
+#  test.libs << File.join(File.dirname(__FILE__), 'lib')
+#  test.libs << File.join(File.dirname(__FILE__), 'test')
+#  test.pattern = File.join(File.dirname(__FILE__), 'test/zip64_full_test.rb')
+#  test.verbose = true
+#end
+

data/lib/hotplate/gems/rubyzip-1.1.7/TODO

@@ -0,0 +1,15 @@
+
+* ZipInputStream: Support zip-files with trailing data descriptors
+* Adjust rdoc stylesheet to advertise inherited methods if possible
+* Suggestion: Add ZipFile/ZipInputStream example that demonstrates extracting all entries.
+* Suggestion: ZipFile#extract destination should default to "."
+* Suggestion: ZipEntry should have extract(), get_input_stream() methods etc
+* (is buffering used anywhere with write?)
+* Inflater.sysread should pass the buffer to produce_input.
+* Implement ZipFsDir.glob
+* ZipFile.checkIntegrity method
+* non-MSDOS permission attributes
+** See mail from Ned Konz to ruby-talk subj. "Re: SV: [ANN] Archive 0.2"
+* Packager version, required unpacker version in zip headers
+** See mail from Ned Konz to ruby-talk subj. "Re: SV: [ANN] Archive 0.2"
+* implement storing attributes and ownership information