zillabyte-cli 0.0.9

data/lib/zillabyte/command.rb

@@ -0,0 +1,254 @@
+require 'zillabyte/helpers'
+require "optparse"
+
+module Zillabyte
+  module Command
+    class CommandFailed  < RuntimeError; end
+
+    extend Zillabyte::Helpers
+
+    def self.load
+      Dir[File.join(File.dirname(__FILE__), "cli", "*.rb")].each do |file|
+        require file
+      end
+      Dir[File.join(File.dirname(__FILE__), "cli", "helpers", "*.rb")].each do |file|
+        require file
+      end
+      unregister_commands_made_private_after_the_fact
+    end
+
+    def self.commands
+      @@commands ||= {}
+    end
+
+    def self.command_aliases
+      @@command_aliases ||= {}
+    end
+
+    def self.files
+      @@files ||= Hash.new {|hash,key| hash[key] = File.readlines(key).map {|line| line.strip}}
+    end
+
+    def self.namespaces
+      @@namespaces ||= {}
+    end
+
+    def self.register_command(command)
+      commands[command[:command]] = command
+    end
+
+    def self.unregister_commands_made_private_after_the_fact
+      commands.values \
+        .select { |c| c[:klass].private_method_defined? c[:method] } \
+        .each   { |c| commands.delete c[:command] }
+    end
+
+    def self.register_namespace(namespace)
+      namespaces[namespace[:name]] = namespace
+    end
+
+    def self.current_command
+      @current_command
+    end
+
+    def self.current_command=(new_current_command)
+      @current_command = new_current_command
+    end
+
+    def self.current_args
+      @current_args
+    end
+
+    def self.current_options
+      @current_options ||= {}
+    end
+
+    def self.global_options
+      @global_options ||= []
+    end
+
+    def self.invalid_arguments
+      @invalid_arguments
+    end
+
+    def self.shift_argument
+      # dup argument to get a non-frozen string
+      @invalid_arguments.shift.dup rescue nil
+    end
+
+    def self.validate_arguments!
+      unless invalid_arguments.empty?
+        arguments = invalid_arguments.map {|arg| "\"#{arg}\""}
+        if arguments.length == 1
+          message = "Invalid argument: #{arguments.first}"
+        elsif arguments.length > 1
+          message = "Invalid arguments: "
+          message << arguments[0...-1].join(", ")
+          message << " and "
+          message << arguments[-1]
+        end
+        $stderr.puts(format_with_bang(message))
+        run(current_command, ["--help"])
+        exit(1)
+      end
+    end
+
+    def self.warnings
+      @warnings ||= []
+    end
+
+    def self.display_warnings
+      unless warnings.empty?
+        $stderr.puts(warnings.map {|warning| " !    #{warning}"}.join("\n"))
+      end
+    end
+
+    def self.global_option(name, *args, &blk)
+      # args.sort.reverse gives -l, --long order
+      global_options << { :name => name.to_s, :args => args.sort.reverse, :proc => blk }
+    end
+
+
+    global_option :help,    "-h", "--help"
+  
+    
+
+    def self.prepare_run(cmd, args=[])
+      command = parse(cmd)
+
+      if args.include?('-h') || args.include?('--help')
+        args.unshift(cmd) unless cmd =~ /^-.*/
+        cmd = 'help'
+        command = parse(cmd)
+      end
+
+      if cmd == '--version' or cmd == '-version'
+        cmd = 'version'
+        command = parse(cmd)
+      end
+
+      @current_command = cmd
+      @anonymized_args, @normalized_args = [], []
+
+      opts = {}
+      invalid_options = []
+
+      parser = OptionParser.new do |parser|
+        # remove OptionParsers Officious['version'] to avoid conflicts
+        # see: https://github.com/ruby/ruby/blob/trunk/lib/optparse.rb#L814
+        parser.base.long.delete('version')
+        (global_options + (command && command[:options] || [])).each do |option|
+          parser.on(*option[:args]) do |value|
+            if option[:proc]
+              option[:proc].call(value)
+            end
+            opts[option[:name].gsub('-', '_').to_sym] = value
+            ARGV.join(' ') =~ /(#{option[:args].map {|arg| arg.split(' ', 2).first}.join('|')})/
+            @anonymized_args << "#{$1} _"
+            @normalized_args << "#{option[:args].last.split(' ', 2).first} _"
+          end
+        end
+      end
+
+      begin
+        parser.order!(args) do |nonopt|
+          invalid_options << nonopt
+          @anonymized_args << '!'
+          @normalized_args << '!'
+        end
+      rescue OptionParser::InvalidOption => ex
+        invalid_options << ex.args.first
+        @anonymized_args << '!'
+        @normalized_args << '!'
+        retry
+      end
+
+      args.concat(invalid_options)
+
+      @current_args = args
+      @current_options = opts
+      @invalid_arguments = invalid_options
+
+      @anonymous_command = [ARGV.first, *@anonymized_args].join(' ')
+      begin
+        usage_directory = "#{home_directory}/.zillabyte/usage"
+        FileUtils.mkdir_p(usage_directory)
+        usage_file = usage_directory << "/#{Zillabyte::CLI::VERSION}"
+        usage = if File.exists?(usage_file)
+          json_decode(File.read(usage_file))
+        else
+          {}
+        end
+        usage[@anonymous_command] ||= 0
+        usage[@anonymous_command] += 1
+        File.write(usage_file, json_encode(usage) + "\n")
+      rescue
+        # usage writing is not important, allow failures
+      end
+
+      if command
+        command_instance = command[:klass].new(args.dup, opts.dup)
+
+        if !@normalized_args.include?('--app _') && (implied_app = command_instance.app rescue nil)
+          @normalized_args << '--app _'
+        end
+        @normalized_command = [ARGV.first, @normalized_args.sort_by {|arg| arg.gsub('-', '')}].join(' ')
+
+        [ command_instance, command[:method] ]
+      else
+        error([
+          "`#{cmd}` is not a zillabyte command.",
+          "See `zillabyte help` for a list of available commands."
+        ].compact.join("\n"))
+      end
+    end
+
+    def self.run(cmd, arguments=[])
+      begin
+        object, method = prepare_run(cmd, arguments.dup)
+        object.send(method)
+      rescue Excon::Errors::SocketError => e
+        error "remote server error: #{e.message}"
+      rescue Errno::ECONNREFUSED => e
+        error "remote server error: #{e.message}"
+      end
+    end
+
+    def self.parse(cmd)
+      commands[cmd] || commands[command_aliases[cmd]]
+    end
+
+    def self.extract_error(body, options={})
+      default_error = block_given? ? yield : "Internal server error.\nRun `zillabyte status` to check for known platform issues."
+      parse_error_xml(body) || parse_error_json(body) || parse_error_plain(body) || default_error
+    end
+
+    def self.parse_error_xml(body)
+      xml_errors = REXML::Document.new(body).elements.to_a("//errors/error")
+      msg = xml_errors.map { |a| a.text }.join(" / ")
+      return msg unless msg.empty?
+    rescue Exception
+    end
+
+    def self.parse_error_json(body)
+      json = json_decode(body.to_s) rescue false
+      case json
+      when Array
+        json.first.join(' ') # message like [['base', 'message']]
+      when Hash
+        json['error']   # message like {'error' => 'message'}
+      else
+        nil
+      end
+    end
+
+    def self.parse_error_plain(body)
+      return unless body.respond_to?(:headers) && body.headers[:content_type].to_s.include?("text/plain")
+      body.to_s
+    end
+    
+    
+    
+    
+  end
+end

data/lib/zillabyte/common/progress.rb

@@ -0,0 +1,17 @@
+module Zillabyte::Common
+  class Progress
+    
+    def update(*args)
+      display(*args)
+    end
+    
+    def display(*args)
+      puts *args
+    end
+    
+    def error(*args)
+      puts "error: #{args.first}"
+    end
+      
+  end
+end

data/lib/zillabyte/common/tar.rb

@@ -0,0 +1,102 @@
+# https://gist.github.com/sinisterchipmunk/1335041
+
+require 'rubygems'
+require 'rubygems/package'
+require 'zlib'
+require 'fileutils'
+
+module Zillabyte::Common
+  class Tar 
+
+    # Creates a tar file in memory recursively
+    # from the given path.
+    # 
+    # Optional second argument (ignore_files) allows file
+    # exclusion.
+    #
+    # Returns a StringIO whose underlying String
+    # is the contents of the tar file.
+    def self.tar(path, ignore_files = [])
+      tarfile = StringIO.new("")
+      ignore_regexp = if ignore_files.empty?()
+        []
+      else
+        /^(#{ignore_files.map { |ignore_file|
+          Regexp::escape(ignore_file)
+        }.join("|")})(?:\/|$)/
+      end
+      Gem::Package::TarWriter.new(tarfile) do |tar|
+# If the path is a directory, then tar up the dir
+        if(File.directory?(path))
+          Dir[File.join(path, "**/*")].each do |file|
+            mode = File.stat(file).mode
+            relative_file = file.sub /^#{Regexp::escape path}\/?/, ''
+            is_directory = File.directory?(file)
+            # Skip ignored files.
+            next if relative_file =~ ignore_regexp
+            if File.directory?(file)
+              tar.mkdir relative_file, mode
+            else
+              tar.add_file relative_file, mode do |tf|
+                File.open(file, "rb") { |f| tf.write f.read }
+              end
+            end
+          end
+# If the path is just a single file, then just tar it up
+        elsif !(path =~ ignore_regexp)
+          mode = File.stat(path).mode
+          tar.add_file path, mode do |tf|
+            File.open(path, "rb") { |f| tf.write f.read }
+          end
+        end
+      end
+    
+      tarfile.rewind
+      tarfile
+    end
+  
+    # gzips the underlying string in the given StringIO,
+    # returning a new StringIO representing the 
+    # compressed file.
+    def self.gzip(tarfile)
+      gz = StringIO.new("")
+      z = Zlib::GzipWriter.new(gz)
+      z.write tarfile.string
+      z.close # this is necessary!
+    
+      # z was closed to write the gzip footer, so
+      # now we need a new StringIO
+      StringIO.new gz.string
+    end
+  
+    # un-gzips the given IO, returning the
+    # decompressed version as a StringIO
+    def self.ungzip(tarfile)
+      z = Zlib::GzipReader.new(tarfile)
+      unzipped = StringIO.new(z.read)
+      z.close
+      unzipped
+    end
+  
+    # untars the given IO into the specified
+    # directory
+    def self.untar(io, destination)
+      Gem::Package::TarReader.new io do |tar|
+        tar.each do |tarfile|
+          destination_file = File.join destination, tarfile.full_name
+        
+          if tarfile.directory?
+            FileUtils.mkdir_p destination_file
+          else
+            destination_directory = File.dirname(destination_file)
+            FileUtils.mkdir_p destination_directory unless File.directory?(destination_directory)
+            File.open destination_file, "wb" do |f|
+              f.print tarfile.read
+            end
+          end
+        end
+      end
+    end
+  end
+  
+end

data/lib/zillabyte/common.rb

@@ -0,0 +1,13 @@
+
+module Zillabyte::Common
+  def self.load
+    Dir[File.join(File.dirname(__FILE__), "common", "*.rb")].sort.each do |file|
+      require file
+    end  
+  end
+end
+
+
+# Load all helpers...
+Zillabyte::Common.load()
+

data/lib/zillabyte/helpers.rb

@@ -0,0 +1,49 @@
+# require "vendor/zillabyte/okjson"
+
+module Zillabyte
+  module Helpers
+    extend self
+    
+    def display(msg="", new_line=true)
+      if new_line
+        puts(msg)
+      else
+        print(msg)
+        $stdout.flush
+      end
+    end
+    
+    
+    def error(message)
+      $stderr.puts(format_with_bang(message))
+      exit(1)
+    end
+    
+    def format_with_bang(message)
+      return '' if message.to_s.strip == ""
+      " !    " + message.split("\n").join("\n !    ")
+    end
+
+    def longest(items)
+      items.map { |i| i.to_s.length }.sort.last
+    end
+    
+    def read_multiline
+      $stdin.gets
+    end
+    
+    def ask
+      $stdin.gets.to_s.strip
+    end
+    
+    def with_tty(&block)
+      return unless $stdin.isatty
+      begin
+        yield
+      rescue
+        # fails on windows
+      end
+    end
+
+  end
+end

data/lib/zillabyte/queries.rb

@@ -0,0 +1,39 @@
+module Zillabyte::Queries
+  
+  
+  
+  def self.array_to_sxp_expression(exp)
+    s = []
+    s << "("
+    s << exp[0]
+    exp[1].each do |ss|
+      s << " "
+      s << ss
+    end
+    s << ")"
+    s = s.join("")
+  end
+  
+  
+  def self.convert_clause_to_sxp(match)
+    return nil if match.nil? or match.size == 0
+    queue = match.clone
+    s = array_to_sxp_expression(queue.shift)
+    while queue.size > 0
+      next_exp = array_to_sxp_expression(queue.shift)
+      s = "(and #{s} #{next_exp})"
+    end
+    s
+  end
+  
+  # def self.load
+  #   Dir[File.join(File.dirname(__FILE__), "functions", "*.rb")].each do |file|
+  #     require file
+  #   end  
+  # end
+end
+
+
+# Load all helpers...
+# Zillabyte::Functions.load()
+

data/lib/zillabyte-cli/version.rb

@@ -0,0 +1,5 @@
+module Zillabyte
+  module CLI
+    VERSION = "0.0.9"
+  end
+end

data/lib/zillabyte-cli.rb

@@ -0,0 +1,5 @@
+require "zillabyte-cli/version"
+require "zillabyte/api"
+require "zillabyte/cli"
+require "zillabyte/common"
+require "zillabyte/queries"

data/zillabyte-cli.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zillabyte-cli/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "zillabyte-cli"
+  spec.version       = Zillabyte::CLI::VERSION
+  spec.authors       = ["zillabyte"]
+  spec.email         = ["gem@zillabyte.com"]
+  spec.description   = %q{The Official Zillabyte CLI Gem}
+  spec.summary       = %q{The Official Zillabyte CLI Gem}
+  spec.homepage      = "http://www.zillabyte.com"
+  spec.license       = "MIT"
+
+  if File.directory?(".git")
+    spec.files         = Dir.glob("{bin,lib}/**/*") +  %w(LICENSE README.md zillabyte_emails.csv zillaconf.json Gemfile zillabyte-cli.gemspec)
+    spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+    spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  
+  spec.add_dependency "netrc",       "~> 0.7.7"
+  spec.add_dependency "rest-client", "~> 1.6.1"
+  
+  spec.add_dependency "excon"
+  spec.add_dependency "terminal-table"
+  spec.add_dependency "activesupport", "~> 3.2.11"
+  
+  spec.add_dependency "colorize"
+  spec.add_dependency "chronic"
+  spec.add_dependency "ascii_charts"
+  spec.add_dependency "indentation"
+  
+  spec.add_dependency "bundler"
+
+  spec.add_dependency "mkfifo"
+  
+end

data/zillabyte_emails.csv

@@ -0,0 +1 @@
+bob@zillabyte.com

data/zillaconf.json

@@ -0,0 +1,3 @@
+{
+  "name": "foo"
+}