hotdog 0.1.18 → 0.2.0

data/lib/hotdog/commands.rb

@@ -27,7 +27,7 @@ module Hotdog
         raise(NotImplementedError)
       end
 
-      def execute(query, *args)
+      def execute(query, args=[])
         update_db
         q = query.strip
         if 0 < args.length
@@ -67,73 +67,94 @@ module Hotdog
         s.index('*') or s.index('?') or s.index('[') or s.index(']')
       end
 
-      def host?(host_id)
-        host_id = execute("SELECT id FROM hosts WHERE name = %s LIMIT 1", s)
-        not host_id.nil?
-      end
-
-      def get_hosts(hosts, tags=nil)
+      def get_hosts(host_ids, tags=nil)
         tags ||= @options[:tags]
         update_db
-        if 0 < tags.length
-          result = hosts.map { |host_id|
-            tags.map { |tag|
-              tag_name, tag_value = tag.split(":", 2)
-              case tag_name
-              when "host"
-                select_name_from_hosts_by_id(@db, host_id)
-              else
-                if glob?(tag_name)
-                  select_tag_values_from_hosts_tags_by_host_id_and_tag_name_glob(@db, host_id, tag_name)
-                else
-                  select_tag_values_from_hosts_tags_by_host_id_and_tag_name(@db, host_id, tag_name)
-                end
-              end
-            }
-          }
-          fields = tags
+        if host_ids.empty?
+          [[], []]
         else
-          if @options[:listing]
-            # TODO: should respect `:primary_tag`
-            fields = []
-            hosts = execute("SELECT id, name FROM hosts WHERE id IN (%s)" % hosts.map { "?" }.join(", "), hosts)
-            result = hosts.map { |host_id, host_name|
-              tag_names = select_tag_names_from_hosts_tags_by_host_id(@db, host_id)
-              tag_names.each do |tag_name|
-                fields << tag_name unless fields.index(tag_name)
-              end
-              [host_name] + fields.map { |tag_name|
-                if glob?(tag_name)
-                  select_tag_values_from_hosts_tags_by_host_id_and_tag_name_glob(@db, host_id, tag_name)
+          if 0 < tags.length
+            fields = tags.map { |tag|
+              tag_name, tag_value = split_tag(tag)
+              tag_name
+            }
+            fields_without_host = fields.reject { |tag_name| tag_name == "host" }
+            if fields == fields_without_host
+              host_names = {}
+            else
+              host_names = Hash[execute("SELECT id, name FROM hosts WHERE id IN (%s)" % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.to_a }]
+            end
+            q1 = []
+            q1 << "SELECT tags.name, GROUP_CONCAT(tags.value, ',') FROM hosts_tags"
+            q1 <<   "INNER JOIN hosts ON hosts_tags.host_id = hosts.id"
+            q1 <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
+            q1 <<     "WHERE hosts_tags.host_id = ? AND tags.name IN (%s)"
+            q1 <<       "GROUP BY tags.name;"
+            result = host_ids.map { |host_id|
+              tag_values = Hash[execute(q1.join(" ") % fields_without_host.map { "?" }.join(", "), [host_id] + fields_without_host).map { |row| row.to_a }]
+              fields.map { |tag_name|
+                if tag_name == "host"
+                  host_names.fetch(host_id, "")
                 else
-                  select_tag_values_from_hosts_tags_by_host_id_and_tag_name(@db, host_id, tag_name)
+                  tag_values.fetch(tag_name, "")
                 end
               }
             }
-            fields = ["host"] + fields
+            [result, fields]
           else
-            if @options[:primary_tag]
-              fields = [@options[:primary_tag]]
-              tag_name, tag_value = @options[:primary_tag].split(":", 2)
-              case tag_name
-              when "host"
-                result = execute("SELECT name FROM hosts WHERE id IN (%s)" % hosts.map { "?" }.join(", "), hosts)
+            if @options[:listing]
+              q1 = []
+              q1 << "SELECT DISTINCT tags.name FROM hosts_tags"
+              q1 <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
+              q1 <<     "WHERE hosts_tags.host_id IN (%s);"
+              if @options[:primary_tag]
+                fields = [
+                  @options[:primary_tag],
+                  "host",
+                ] + execute(q1.join(" ") % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.first }.reject { |tag_name|
+                  tag_name == @options[:primary_tag]
+                }
               else
-                result = hosts.map { |host_id|
-                  if glob?(tag_name)
-                    [select_tag_values_from_hosts_tags_by_host_id_and_tag_name_glob(@db, host_id, tag_name)]
+                fields = [
+                  "host",
+                ] + execute(q1.join(" ") % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.first }
+              end
+              host_names = Hash[execute("SELECT id, name FROM hosts WHERE id IN (%s)" % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.to_a }]
+              q2 = []
+              q2 << "SELECT tags.name, GROUP_CONCAT(tags.value, ',') FROM hosts_tags"
+              q2 <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
+              q2 <<     "WHERE hosts_tags.host_id = ? AND tags.name IN (%s)"
+              q2 <<       "GROUP BY tags.name;"
+              fields_without_host = fields.reject { |tag_name| tag_name == "host" }
+              result = host_ids.map { |host_id|
+                tag_values = Hash[execute(q2.join(" ") % fields_without_host.map { "?" }.join(", "), [host_id] + fields_without_host).map { |row| row.to_a }]
+                fields.map { |tag_name|
+                  if tag_name == "host"
+                    host_names.fetch(host_id, "")
                   else
-                    [select_tag_values_from_hosts_tags_by_host_id_and_tag_name(@db, host_id, tag_name)]
+                    tag_values.fetch(tag_name, "")
                   end
                 }
-              end
+              }
+              [result, fields]
             else
-              fields = ["host"]
-              result = execute("SELECT name FROM hosts WHERE id IN (%s)" % hosts.map { "?" }.join(", "), hosts)
+              if @options[:primary_tag]
+                fields = [@options[:primary_tag]]
+                q1 = []
+                q1 << "SELECT tags.value FROM hosts_tags"
+                q1 <<   "INNER JOIN hosts ON hosts_tags.host_id = hosts.id"
+                q1 <<   "INNER JOIN tags ON hosts_tags.tag_id = tags.id"
+                q1 <<     "WHERE hosts_tags.host_id IN (%s) AND tags.name = ?;"
+                result = execute(q1.join(" ") % host_ids.map { "?" }.join(", "), host_ids + [@options[:primary_tag]]).map { |row| row.to_a }
+                [result, fields]
+              else
+                fields = ["host"]
+                result = execute("SELECT name FROM hosts WHERE id IN (%s)" % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.to_a }
+                [result, fields]
+              end
             end
           end
         end
-        [result, fields]
       end
 
       def close_db(db, options={})
@@ -172,44 +193,26 @@ module Hotdog
           create_table_hosts_tags(memory_db)
           create_index_hosts_tags(memory_db)
 
-          code, all_tags = @dog.all_tags()
-          logger.debug("dog.all_tags() #==> [%s, ...]" % [code.inspect])
-          if code.to_i / 100 != 2
-            raise("dog.all_tags() returns [%s, ...]" % [code.inspect])
-          end
+          all_tags = get_all_tags()
 
-          code, all_downtimes = @dog.get_all_downtimes()
-          logger.debug("dog.get_all_downtimes() #==> [%s, ...]" % [code.inspect])
-          if code.to_i / 100 != 2
-            raise("dog.get_all_downtimes() returns [%s, ...]" % [code.inspect])
+          known_tags = all_tags.keys.map { |tag| split_tag(tag) }.uniq
+          unless known_tags.empty?
+            prepare(memory_db, "INSERT OR IGNORE INTO tags (name, value) VALUES %s" % known_tags.map { "(?, ?)" }.join(", ")).execute(known_tags)
           end
 
-          now = Time.new.to_i
-          downs = all_downtimes.select { |downtime|
-            # active downtimes
-            downtime["active"] and ( downtime["start"].nil? or downtime["start"] < now ) and ( downtime["end"].nil? or now <= downtime["end"] )
-          }.map { |downtime|
-            # find host scopes
-            downtime["scope"].select { |scope| scope.start_with?("host:") }.map { |scope| scope.sub(/\Ahost:/, "") }
-          }.reduce(:+)
-          downs ||= []
-
-          # for case-insensitive match of hostname
-          downs = downs.map { |down| down.downcase }
-
-          if not downs.empty?
-            logger.info("ignore host(s) with scheduled downtimes: #{downs.inspect}")
+          known_hosts = all_tags.values.reduce(:+).uniq
+          unless known_hosts.empty?
+            prepare(memory_db, "INSERT OR IGNORE INTO hosts (name) VALUES %s" % known_hosts.map { "(?)" }.join(", ")).execute(known_hosts)
           end
 
-          all_tags["tags"].each do |tag, hosts|
-            tag_name, tag_value = tag.split(":", 2)
-            tag_value ||= ""
-            insert_or_ignore_into_tags(memory_db, tag_name, tag_value)
-            hosts.each do |host_name|
-              if not downs.include?(host_name.downcase)
-                insert_or_ignore_into_hosts(memory_db, host_name)
-                insert_or_replace_into_hosts_tags(memory_db, host_name, tag_name, tag_value)
-              end
+          all_tags.each do |tag, hosts|
+            q = []
+            q << "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id)"
+            q <<   "SELECT host.id, tag.id FROM"
+            q <<     "( SELECT id FROM hosts WHERE name IN (%s) ) AS host,"
+            q <<     "( SELECT id FROM tags WHERE name = ? AND value = ? LIMIT 1 ) AS tag;"
+            unless hosts.empty?
+              prepare(memory_db, q.join(" ") % hosts.map { "?" }.join(", ")).execute(hosts + split_tag(tag))
             end
           end
 
@@ -224,6 +227,36 @@ module Hotdog
         end
       end
 
+      def get_all_tags() #==> Hash<Tag,Array<Host>>
+        code, all_tags = @dog.all_tags()
+        logger.debug("dog.all_tags() #==> [%s, ...]" % [code.inspect])
+        if code.to_i / 100 != 2
+          raise("dog.all_tags() returns [%s, ...]" % [code.inspect])
+        end
+        code, all_downtimes = @dog.get_all_downtimes()
+        logger.debug("dog.get_all_downtimes() #==> [%s, ...]" % [code.inspect])
+        if code.to_i / 100 != 2
+          raise("dog.get_all_downtimes() returns [%s, ...]" % [code.inspect])
+        end
+        now = Time.new.to_i
+        downtimes = all_downtimes.select { |downtime|
+          # active downtimes
+          downtime["active"] and ( downtime["start"].nil? or downtime["start"] < now ) and ( downtime["end"].nil? or now <= downtime["end"] )
+        }.map { |downtime|
+          # find host scopes
+          downtime["scope"].select { |scope| scope.start_with?("host:") }.map { |scope| scope.sub(/\Ahost:/, "") }
+        }.reduce(:+) || []
+        if not downtimes.empty?
+          logger.info("ignore host(s) with scheduled downtimes: #{downtimes.inspect}")
+        end
+        Hash[all_tags["tags"].map { |tag, hosts| [tag, hosts.reject { |host| downtimes.include?(host) }] }]
+      end
+
+      def split_tag(tag)
+        tag_name, tag_value = tag.split(":", 2)
+        [tag_name, tag_value || ""]
+      end
+
       def copy_db(src, dst)
         # create index later for better insert performance
         dst.transaction do
@@ -231,15 +264,14 @@ module Hotdog
           create_table_tags(dst)
           create_table_hosts_tags(dst)
 
-          select_from_hosts(src).each do |host_id, host_name|
-            insert_into_hosts(dst, host_id, host_name)
-          end
-          select_from_tags(src).each do |tag_id, tag_name, tag_value|
-            insert_into_tags(dst, tag_id, tag_name, tag_value)
-          end
-          select_from_hosts_tags(src).each do |host_id, tag_id|
-            insert_into_hosts_tags(dst, host_id, tag_id)
-          end
+          hosts = prepare(src, "SELECT id, name FROM hosts").execute().to_a
+          prepare(dst, "INSERT INTO hosts (id, name) VALUES %s" % hosts.map { "(?, ?)" }.join(", ")).execute(hosts) unless hosts.empty?
+
+          tags = prepare(src, "SELECT id, name, value FROM tags").execute().to_a
+          prepare(dst, "INSERT INTO tags (id, name, value) VALUES %s" % tags.map { "(?, ?, ?)" }.join(", ")).execute(tags) unless tags.empty?
+
+          hosts_tags = prepare(src, "SELECT host_id, tag_id FROM hosts_tags").to_a
+          prepare(dst, "INSERT INTO hosts_tags (host_id, tag_id) VALUES %s" % hosts_tags.map { "(?, ?)" }.join(", ")).execute(hosts_tags) unless hosts_tags.empty?
 
           create_index_hosts(dst)
           create_index_tags(dst)
@@ -247,29 +279,14 @@ module Hotdog
         end
       end
 
-      def select_from_hosts(db)
-        logger.debug("select_from_hosts()")
-        prepare(db, "SELECT id, name FROM hosts").execute()
-      end
-
-      def select_from_tags(db)
-        logger.debug("select_from_tags()")
-        prepare(db, "SELECT id, name, value FROM tags").execute()
-      end
-
-      def select_from_hosts_tags(db)
-        logger.debug("select_from_hosts_tags()")
-        prepare(db, "SELECT host_id, tag_id FROM hosts_tags").execute()
-      end
-
       def create_table_hosts(db)
         logger.debug("create_table_hosts()")
-        db.execute(<<-EOS)
-          CREATE TABLE IF NOT EXISTS hosts (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name VARCHAR(255) NOT NULL
-          );
-        EOS
+        q = []
+        q << "CREATE TABLE IF NOT EXISTS hosts ("
+        q <<   "id INTEGER PRIMARY KEY AUTOINCREMENT,"
+        q <<   "name VARCHAR(255) NOT NULL COLLATE NOCASE"
+        q << ");"
+        db.execute(q.join(" "))
       end
 
       def create_index_hosts(db)
@@ -279,13 +296,13 @@ module Hotdog
 
       def create_table_tags(db)
         logger.debug("create_table_tags()")
-        db.execute(<<-EOS)
-          CREATE TABLE IF NOT EXISTS tags (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name VARCHAR(200) NOT NULL,
-            value VARCHAR(200) NOT NULL DEFAULT ""
-          );
-        EOS
+        q = []
+        q << "CREATE TABLE IF NOT EXISTS tags ("
+        q <<   "id INTEGER PRIMARY KEY AUTOINCREMENT,"
+        q <<   "name VARCHAR(200) NOT NULL COLLATE NOCASE,"
+        q <<   "value VARCHAR(200) NOT NULL COLLATE NOCASE"
+        q << ");"
+        db.execute(q.join(" "))
       end
 
       def create_index_tags(db)
@@ -295,85 +312,18 @@ module Hotdog
 
       def create_table_hosts_tags(db)
         logger.debug("create_table_hosts_tags()")
-        db.execute(<<-EOS)
-          CREATE TABLE IF NOT EXISTS hosts_tags (
-            host_id INTEGER NOT NULL,
-            tag_id INTEGER NOT NULL
-          );
-        EOS
+        q = []
+        q << "CREATE TABLE IF NOT EXISTS hosts_tags ("
+        q <<   "host_id INTEGER NOT NULL,"
+        q <<   "tag_id INTEGER NOT NULL"
+        q << ");"
+        db.execute(q.join(" "))
       end
 
       def create_index_hosts_tags(db)
         logger.debug("create_index_hosts_tags()")
         db.execute("CREATE UNIQUE INDEX IF NOT EXISTS hosts_tags_host_id_tag_id ON hosts_tags ( host_id, tag_id )")
       end
-
-      def insert_into_tags(db, tag_id, tag_name, tag_value)
-        logger.debug("insert_into_tags(%s, %s, %s)" % [tag_id.inspect, tag_name.inspect, tag_value.inspect])
-        prepare(db, "INSERT INTO tags (id, name, value) VALUES (?, ?, ?)").execute(tag_id, tag_name, tag_value)
-      end
-
-      def insert_or_ignore_into_tags(db, tag_name, tag_value)
-        logger.debug("insert_or_ignore_into_tags(%s, %s)" % [tag_name.inspect, tag_value.inspect])
-        prepare(db, "INSERT OR IGNORE INTO tags (name, value) VALUES (?, ?)").execute(tag_name, tag_value)
-      end
-
-      def insert_into_hosts(db, host_id, host_name)
-        logger.debug("insert_into_hosts(%s, %s)" % [host_id.inspect, host_name.inspect])
-        prepare(db, "INSERT INTO hosts (id, name) VALUES (?, ?)").execute(host_id, host_name)
-      end
-
-      def insert_or_ignore_into_hosts(db, host_name)
-        logger.debug("insert_or_ignore_into_hosts(%s)" % [host_name.inspect])
-        prepare(db, "INSERT OR IGNORE INTO hosts (name) VALUES (?)").execute(host_name)
-      end
-
-      def insert_into_hosts_tags(db, host_id, tag_id)
-        logger.debug("insert_into_hosts_tags(%s, %s)" % [host_id.inspect, tag_id.inspect])
-        prepare(db, "INSERT INTO hosts_tags (host_id, tag_id) VALUES (?, ?)").execute(host_id, tag_id)
-      end
-
-      def insert_or_replace_into_hosts_tags(db, host_name, tag_name, tag_value)
-        logger.debug("insert_or_replace_into_hosts_tags(%s, %s, %s)" % [host_name.inspect, tag_name.inspect, tag_value.inspect])
-        prepare(db, <<-EOS).execute(host_name, tag_name, tag_value)
-          INSERT OR REPLACE INTO hosts_tags (host_id, tag_id)
-            SELECT host.id, tag.id FROM
-              ( SELECT id FROM hosts WHERE LOWER(name) = LOWER(?) ) AS host,
-              ( SELECT id FROM tags WHERE LOWER(name) = LOWER(?) AND LOWER(value) = LOWER(?) ) AS tag;
-        EOS
-      end
-
-      def select_name_from_hosts_by_id(db, host_id)
-        logger.debug("select_name_from_hosts_by_id(%s)" % [host_id.inspect])
-        prepare(db, "SELECT name FROM hosts WHERE id = ? LIMIT 1").execute(host_id).map { |row| row.first }.first
-      end
-
-      def select_tag_values_from_hosts_tags_by_host_id_and_tag_name_glob(db, host_id, tag_name)
-        logger.debug("select_tag_values_from_hosts_tags_by_host_id_and_tag_name_glob(%s, %s)" % [host_id.inspect, tag_name.inspect])
-        prepare(db, <<-EOS).execute(host_id, tag_name).map { |row| row.first }.join(",")
-          SELECT tags.value FROM hosts_tags
-            INNER JOIN tags ON hosts_tags.tag_id = tags.id
-              WHERE hosts_tags.host_id = ? AND LOWER(tags.name) GLOB LOWER(?);
-        EOS
-      end
-
-      def select_tag_values_from_hosts_tags_by_host_id_and_tag_name(db, host_id, tag_name)
-        logger.debug("select_tag_values_from_hosts_tags_by_host_id_and_tag_name(%s, %s)" % [host_id.inspect, tag_name.inspect])
-        prepare(db, <<-EOS).execute(host_id, tag_name).map { |row| row.first }.join(",")
-          SELECT tags.value FROM hosts_tags
-            INNER JOIN tags ON hosts_tags.tag_id = tags.id
-              WHERE hosts_tags.host_id = ? AND LOWER(tags.name) = LOWER(?);
-        EOS
-      end
-
-      def select_tag_names_from_hosts_tags_by_host_id(db, host_id)
-        logger.debug("select_tag_names_from_hosts_tags_by_host_id(%s)" % [host_id.inspect])
-        prepare(db, <<-EOS).execute(host_id).map { |row| row.first }
-          SELECT DISTINCT tags.name FROM hosts_tags
-            INNER JOIN tags ON hosts_tags.tag_id = tags.id
-              WHERE hosts_tags.host_id = ?;
-        EOS
-      end
     end
   end
 end

data/lib/hotdog/formatters/ltsv.rb

@@ -4,10 +4,15 @@ module Hotdog
   module Formatters
     class Ltsv < BaseFormatter
       def format(result, options={})
-        fields = options.fetch(:fields, [])
-        result.map { |row|
-          fields.zip(row).map { |column| column.join(":") }.join("\t")
-        }.join("\n") + "\n"
+        if options[:fields]
+          result.map { |row|
+            options[:fields].zip(row).map { |column| column.join(":") }.join("\t")
+          }.join("\n") + "\n"
+        else
+          result.map { |row|
+            row.join("\t")
+          }.join("\n") + "\n"
+        end
       end
     end
   end

data/lib/hotdog/formatters/plain.rb

@@ -27,7 +27,7 @@ module Hotdog
             },
           ] + result.map { |row|
             row.zip(field_length).map { |field, length|
-              padding = length - ((field.nil?) ? 0 : field.length)
+              padding = length - ((field.nil?) ? 0 : field.to_s.length)
               field.to_s + (" " * padding)
             }
           }

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.1.18"
+  VERSION = "0.2.0"
 end

data/spec/core/application_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands"
+require "hotdog/commands/hosts"
+require "hotdog/commands/search"
+require "hotdog/commands/tags"
+
+describe "application" do
+  let(:app) {
+    Hotdog::Application.new
+  }
+
+  before(:each) do
+    ENV["DATADOG_API_KEY"] = "DATADOG_API_KEY"
+    ENV["DATADOG_APPLICATION_KEY"] = "DATADOG_APPLICATION_KEY"
+  end
+
+  it "generates proper class name from file name" do
+    expect(app.__send__(:const_name, "csv")).to eq("Csv")
+    expect(app.__send__(:const_name, "json")).to eq("Json")
+    expect(app.__send__(:const_name, "pssh")).to eq("Pssh")
+    expect(app.__send__(:const_name, "parallel-ssh")).to eq("ParallelSsh")
+  end
+
+  it "returns proper class by name" do
+    expect(app.__send__(:get_command, "hosts")).to be(Hotdog::Commands::Hosts)
+    expect(app.__send__(:get_command, "search")).to be(Hotdog::Commands::Search)
+    expect(app.__send__(:get_command, "tags")).to be(Hotdog::Commands::Tags)
+  end
+
+  it "raises error if the action is base-command" do
+    expect {
+      app.main(["base-command"])
+    }.to raise_error(NotImplementedError)
+  end
+end

data/spec/formatter/csv_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "hotdog/formatters"
+require "hotdog/formatters/csv"
+
+describe "csv" do
+  let(:fmt) {
+    Hotdog::Formatters::Csv.new
+  }
+
+  it "generates csv without headers" do
+    options = {
+      headers: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+foo,aaa,1
+bar,bbb,2
+baz,ccc,3
+    EOS
+  end
+
+  it "generates csv with headers" do
+    options = {
+      headers: true,
+      fields: ["key1", "key2", "val1"],
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+key1,key2,val1
+foo,aaa,1
+bar,bbb,2
+baz,ccc,3
+    EOS
+  end
+end

data/spec/formatter/json_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+require "hotdog/formatters"
+require "hotdog/formatters/json"
+
+describe "json" do
+  let(:fmt) {
+    Hotdog::Formatters::Json.new
+  }
+
+  it "generates json without headers" do
+    options = {
+      headers: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+[
+  [
+    "foo",
+    "aaa",
+    1
+  ],
+  [
+    "bar",
+    "bbb",
+    2
+  ],
+  [
+    "baz",
+    "ccc",
+    3
+  ]
+]
+    EOS
+  end
+
+  it "generates json with headers" do
+    options = {
+      headers: true,
+      fields: ["key1", "key2", "val1"],
+      prettyprint: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+[
+  [
+    "key1",
+    "key2",
+    "val1"
+  ],
+  [
+    "foo",
+    "aaa",
+    1
+  ],
+  [
+    "bar",
+    "bbb",
+    2
+  ],
+  [
+    "baz",
+    "ccc",
+    3
+  ]
+]
+    EOS
+  end
+end

data/spec/formatter/ltsv_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+require "hotdog/formatters"
+require "hotdog/formatters/ltsv"
+
+describe "ltsv" do
+  let(:fmt) {
+    Hotdog::Formatters::Ltsv.new
+  }
+
+  it "generates ltsv without headers" do
+    options = {
+      headers: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+foo\taaa\t1
+bar\tbbb\t2
+baz\tccc\t3
+    EOS
+  end
+
+  it "generates ltsv with headers" do
+    options = {
+      headers: true,
+      fields: ["key1", "key2", "val1"],
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+key1:foo\tkey2:aaa\tval1:1
+key1:bar\tkey2:bbb\tval1:2
+key1:baz\tkey2:ccc\tval1:3
+    EOS
+  end
+end