zillabyte-cli 0.0.9

data/lib/zillabyte/cli/help.rb

@@ -0,0 +1,137 @@
+require "zillabyte/cli/base"
+
+# list commands and display help
+#
+class Zillabyte::Command::Help < Zillabyte::Command::Base
+
+  PRIMARY_NAMESPACES = %w( relations query flows logs )
+  
+
+  def index(*direct_args)
+    if command = args.shift || direct_args.shift
+      help_for_command(command)
+    else
+      help_for_root
+    end
+  end
+
+  alias_command "-h", "help"
+  alias_command "--help", "help"
+
+private
+
+  def commands_for_namespace(name)
+    Zillabyte::Command.commands.values.select do |command|
+      command[:namespace] == name && command[:command] != name
+    end
+  end
+
+  def namespaces
+    namespaces = Zillabyte::Command.namespaces
+    namespaces
+  end
+
+  def commands
+    Zillabyte::Command.commands
+  end
+
+  def legacy_help_for_command(command)
+    Zillabyte::Command::Help.groups.each do |group|
+      group.each do |cmd, description|
+        return description if cmd.split(" ").first == command
+      end
+    end
+    nil
+  end
+
+  def skip_namespace?(ns)
+    return true if ns[:description] =~ /DEPRECATED:/
+    return true if ns[:description] =~ /HIDDEN:/
+    false
+  end
+
+  def skip_command?(command)
+    return true if command[:help] =~ /DEPRECATED:/
+    return true if command[:help] =~ /^ HIDDEN:/
+    false
+  end
+
+  def primary_namespaces
+    PRIMARY_NAMESPACES.map { |name| namespaces[name] }.compact
+  end
+
+  def additional_namespaces
+    (namespaces.values - primary_namespaces)
+  end
+
+  def summary_for_namespaces(namespaces)
+    size = longest(namespaces.map { |n| n[:name] })
+    namespaces.sort_by {|namespace| namespace[:name]}.each do |namespace|
+      next if skip_namespace?(namespace)
+      name = namespace[:name]
+      puts "  %-#{size}s  # %s" % [ name, namespace[:description] ]
+    end
+  end
+
+  def help_for_root
+    puts "Usage: zillabyte COMMAND [command-specific-options]"
+    puts
+    puts "Primary help topics, type \"zillabyte help TOPIC\" for more details:"
+    puts
+    summary_for_namespaces(primary_namespaces)
+    puts
+    puts "Additional topics:"
+    puts
+    summary_for_namespaces(additional_namespaces)
+    puts
+    puts "For help getting started, visit http://www.developers.zillabyte.com."
+    puts
+  end
+
+  def help_for_namespace(name)
+    namespace_commands = commands_for_namespace(name)
+
+    unless namespace_commands.empty?
+      size = longest(namespace_commands.map { |c| c[:banner] })
+      namespace_commands.sort_by { |c| c[:banner].to_s }.each do |command|
+        next if skip_command?(command)
+        command[:summary] ||= legacy_help_for_command(command[:command])
+        puts "  %-#{size}s  # %s" % [ command[:banner], command[:summary] ]
+      end
+    end
+  end
+
+  def help_for_command(name)
+    if command_alias = Zillabyte::Command.command_aliases[name]
+      display("Alias: #{name} redirects to #{command_alias}")
+      name = command_alias
+    end
+    if command = commands[name]
+      puts "Usage: zillabyte #{command[:banner]}"
+
+      if command[:help].strip.length > 0
+        help = command[:help].split("\n").reject do |line|
+          line =~ /HIDDEN/
+        end
+        puts help[1..-1].join("\n")
+      else
+        puts
+        puts " " + legacy_help_for_command(name).to_s
+      end
+      puts
+    end
+
+    namespace_commands = commands_for_namespace(name).reject do |command|
+      command[:help] =~ /DEPRECATED/
+    end
+
+    if !namespace_commands.empty?
+      puts "Additional commands, type \"zillabyte help COMMAND\" for more details:"
+      puts
+      help_for_namespace(name)
+      puts
+    elsif command.nil?
+      error "#{name} is not a zillabyte command. See `zillabyte help`."
+    end
+  end
+end

data/lib/zillabyte/cli/helpers/data_schema_builder.rb

@@ -0,0 +1,3 @@
+class Zillabyte::Helpers::DataSchemaBuilder
+  
+end

data/lib/zillabyte/cli/host.rb

@@ -0,0 +1,21 @@
+# require "zillabyte/cli/base"
+# 
+# # manage the host that zillabyte connects
+# #
+# class Zillabyte::Command::Host < Zillabyte::Command::Base
+# 
+#   # host
+#   # 
+#   #
+#   def index
+#     self.list
+#   end
+# 
+#   # host:list
+#   # 
+#   # list the currently connected host
+#   # 
+#   def list
+#     puts ENV["ZILLABYTE_API_HOST"] || "api.zillabyte.com"
+#   end
+# end

data/lib/zillabyte/cli/logs.rb

@@ -0,0 +1,118 @@
+require "zillabyte/cli/base"
+require "pty"
+require 'colorize'
+
+# manage custom logs
+#
+class Zillabyte::Command::Logs < Zillabyte::Command::Base
+
+
+
+  
+  
+  # logs:show FLOW_ID [OPERATION]
+  #
+  # shows the logs
+  # 
+  # -t, --tail  # continuously watches for new results
+  # -v, --verbose LEVEL  # sets the verbosity (error, info, debug) (default: info)
+  #
+  def show
+
+    flow_id = options[:flow] || shift_argument
+    operation_id = options[:operation] || shift_argument || '_ALL_'
+    tail = options[:tail]
+    priority = options[:verbose] || 'debug'
+    carry_settings = {
+      :priority => priority
+    }
+    api_options = {}
+    
+    error "no id given" if flow_id.nil?
+    
+    begin
+      
+      res = self.api.logs.get(flow_id, operation_id, api_options)
+
+      carry_settings = show_log_output(res, carry_settings)
+      api_options[:since] = carry_settings[:since]
+      
+      if (tail)
+        sleep(5) # HACK
+      end
+    end while(tail)
+
+  end  
+  alias_command "log", "logs:show"
+  alias_command "logs", "logs:show"
+
+
+
+
+
+
+
+  private
+  
+  def show_log_output(lines, settings = {})
+    
+    @colors ||= [:green, :yellow, :magenta, :cyan, :light_black, :light_green, :light_yellow, :light_blue, :light_magenta, :light_cyan]
+
+    max_category_size = 0
+    all_lines = []
+    
+    lines.each_pair do |operation, lines|
+      settings[operation] ||= {}      
+      settings[operation][:color] ||= @colors.shift
+      lines.each do |line_h|
+        
+        line = line_h['line']
+        priority = line_h['priority']
+        date = line_h['date']
+        
+        all_lines << {
+          :line => line,
+          :category => operation,
+          :priority => priority,
+          :color => settings[operation][:color],
+          :date => date
+        }
+        max_category_size = [max_category_size, operation.size].max
+        
+        if settings[:since]
+          settings[:since] = [date, settings[:since]].max
+        else
+          settings[:since] = date
+        end
+        
+      end
+      
+    end
+    
+    all_lines.sort! do |a,b|
+      a[:date] <=> b[:date]
+    end
+    
+    requested_priority = settings[:priority]
+
+    all_lines.each do |h|
+      color = h[:color]
+      
+      case h[:priority]
+      when 'error'
+        color = :red if h[:priority] == 'error'
+      when 'info'
+        next if ['error'].member?(requested_priority)
+      when 'system'
+      when 'debug'
+        next if ['info', 'error'].member?(requested_priority)
+      end
+      
+      display "#{h[:category].rjust(max_category_size)} #{h[:priority].rjust(6)} - #{h[:line]}".colorize(color)
+    end
+    
+    settings
+  end
+  
+
+end

data/lib/zillabyte/cli/query.rb

@@ -0,0 +1,172 @@
+require "zillabyte/cli/base"
+
+# executes queries
+#
+class Zillabyte::Command::Query < Zillabyte::Command::Base
+
+  # query:sxp EXPRESSION
+  #
+  # executes queries against the zillabyte corpus
+  #
+  # -o, --offset OFFSET  # skips to the offset (default: 0)
+  # -l, --limit LIMIT  # sets the result limit (default: 20)
+  # -t, --tail  # continuously watches for new results
+  #
+  #Examples:
+  #
+  # $ zillabyte query:sxp "(uses company 'web_css')" --limit 100
+  #
+  def sxp
+    
+    opts = {}
+    opts[:offset] = options[:offset] || 0
+    opts[:limit] = options[:limit] || 10
+    tail = options[:tail] || false
+    expression = options[:expression] || shift_argument 
+    opts[:since] = options[:since]
+    
+    if expression.nil?
+      error "no expression given"
+    end
+    
+    seen = {}
+    
+    begin
+    
+      validate_arguments!
+      res = api.query.sxp(expression, opts)
+    
+      filtered = []
+      headings = []
+      if res['rows'].first
+        headings = res['rows'].first.keys
+        rows = res['rows'].each do |obj|
+          new_row = headings.map do |heading|
+            obj[heading]
+          end
+          unless seen[new_row.to_s]
+            filtered << new_row
+            seen[new_row.to_s] = true
+          end
+        end
+      end
+    
+      if filtered.size > 0
+        
+        table = Terminal::Table.new :headings => headings, :rows => filtered
+        puts table.to_s
+      else
+        unless tail
+          display "no results"
+        end
+      end
+      
+      opts[:since] = DateTime.now
+          
+    end while (tail && sleep(5))
+
+  end
+  
+  alias_command "sxp", "query:sxp"
+
+
+
+
+  # query:sql EXPRESSION
+  #
+  # executes queries against the zillabyte corpus
+  #
+  # -o, --offset OFFSET  # skips to the offset (default: 0)
+  # -l, --limit LIMIT  # sets the result limit (default: 20)
+  # -t, --tail        # continuously watches for new results
+  # -s, --since SINCE # newer records since
+  # --no_truncation   # doesn't truncate long strings
+  #
+  #Examples:
+  #
+  # $ zillabyte query:sql "select * from company" --limit 100
+  #
+  def sql
+    
+    opts = {}
+    opts[:offset] = options[:offset] || 0
+    opts[:limit] = options[:limit] || 10
+    tail = options[:tail] || false
+    expression = options[:expression] || shift_argument 
+    opts[:since] = options[:since]
+    seen = {}
+    
+    if expression.nil?
+      error "no expression given"
+    end
+    
+    
+    begin
+    
+      validate_arguments!
+      res = api.query.sql(expression, opts)
+
+      headings = []
+      filtered = []
+      if res['rows'].first
+        headings = res['rows'].first.keys
+        rows = res['rows'].each do |obj|
+
+          # if obj['since']
+          #   opts[:since] = [obj['since'], opts[:since]].compact.max
+          # end
+          
+          new_row = headings.map do |heading|
+            if options[:no_truncation]
+              obj[heading]
+            else
+              if obj[heading].to_s.size > 30
+                obj[heading].to_s[0..30] + "..."
+              else
+                obj[heading]
+              end
+            end
+          end
+          
+          unless seen[new_row.to_s]
+            filtered << new_row
+            seen[new_row.to_s] = true
+          end
+        end
+      end
+    
+    
+      if filtered.size > 0
+        
+        table = Terminal::Table.new :headings => headings, :rows => filtered
+        puts table.to_s
+        opts[:since] = Time.now.utc
+        
+      else
+        unless tail
+          display "no results"
+        end
+      end
+      
+          
+    end while (tail && sleep(5))
+
+  end
+  
+  alias_command "sql", "query:sql"
+
+
+
+
+  # rules:init
+  #
+  # initializes an empty rule
+  #
+  def init
+    display "TODO: init new rule"
+  end
+  
+  
+
+
+end