terraform_landscape 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3adeba30b54a83c182ee6956d97f42e16fe1bb14
+  data.tar.gz: ab302a4d55105e6a0a3bc70e31c497e64dc3b489
+SHA512:
+  metadata.gz: 065d407040083b704ddef29a67080db8b618f557ed498c9623ff26ced98ddbee28538fad417253370155d904974e06abea1a5d1741acaee63e1d6b15f7ceed44
+  data.tar.gz: 7602f283d8a02775dc4e07c5b93fd6c5763cc4e1d5f939fae3d1c042f47d0e3c387f48a2d3e472c9cb1d7610595f46829953f60bb7a356a9fbbfaaa28f2d4e72

data/bin/landscape

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'terraform_landscape'
+
+output = TerraformLandscape::Output.new(STDOUT)
+cli = TerraformLandscape::CLI.new(output)
+exit cli.run(ARGV)

data/grammar/terraform_plan.treetop

@@ -0,0 +1,67 @@
+# Defines grammar for parsing `terraform plan` output.
+
+grammar TerraformPlan
+  rule plan
+    [\s]* list:resource_list "\n"* {
+      def to_ast
+        list.to_ast
+      end
+    }
+  end
+
+  rule resource_list
+    item:resource "\n\n" list:resource_list {
+      def to_ast
+        [item.to_ast] + list.to_ast
+      end
+    }
+    /
+    item:resource "\n" {
+      def to_ast
+        [item.to_ast]
+      end
+    }
+  end
+
+  rule resource
+    header:resource_header "\n" attrs:attribute_list {
+      def to_ast
+        header.to_ast.merge(attributes: attrs.to_ast)
+      end
+    }
+  end
+
+  rule resource_header
+    change:('~' / '-' / '+') _ type:[a-zA-Z0-9_-]+ '.' name:[a-zA-Z0-9_-]+ {
+      def to_ast
+        { change: change.text_value.to_sym, resource_type: type.text_value, resource_name: name.text_value }
+      end
+    }
+  end
+
+  rule attribute_list
+    _ item:attribute "\n" attrs:attribute_list {
+      def to_ast
+        item.to_ast.merge(attrs.to_ast)
+      end
+    }
+    /
+    _ item:attribute {
+      def to_ast
+        item.to_ast
+      end
+    }
+  end
+
+  rule attribute
+    attribute_name:[^\s:]* ':' _? attribute_value:[^\n]+ {
+      def to_ast
+        { attribute_name.text_value => attribute_value.text_value }
+      end
+    }
+  end
+
+  rule _
+    [ ]+
+  end
+end

data/lib/terraform_landscape.rb

@@ -0,0 +1,7 @@
+require 'terraform_landscape/constants'
+require 'terraform_landscape/version'
+require 'terraform_landscape/output'
+require 'terraform_landscape/errors'
+require 'terraform_landscape/printer'
+require 'terraform_landscape/terraform_plan'
+require 'terraform_landscape/cli'

data/lib/terraform_landscape/arguments_parser.rb

@@ -0,0 +1,58 @@
+require 'optparse'
+
+module TerraformLandscape
+  # Handles option parsing for the command line application.
+  class ArgumentsParser
+    # Parses command line options into an options hash.
+    #
+    # @param args [Array<String>] arguments passed via the command line
+    #
+    # @return [Hash] parsed options
+    def parse(args)
+      @options = {}
+      @options[:command] = :pretty_print # Default command
+
+      OptionParser.new do |parser|
+        parser.banner = "Usage: landscape [options] [plan-output-file]"
+
+        add_info_options parser
+      end.parse!(args)
+
+      # Any remaining arguments are assumed to be the output file
+      @options[:plan_output_file] = args.first
+
+      @options
+    rescue OptionParser::InvalidOption => ex
+      raise InvalidCliOptionError,
+            "#{ex.message}\nRun `landscape --help` to " \
+            'see a list of available options.'
+    end
+
+    private
+
+    # Register informational flags.
+    def add_info_options(parser)
+      parser.on('--[no-]color', 'Force output to be colorized') do |color|
+        @options[:color] = color
+      end
+
+      parser.on('-d', '--debug', 'Enable debug mode for more verbose output') do
+        @options[:debug] = true
+      end
+
+      parser.on_tail('-h', '--help', 'Display help documentation') do
+        @options[:command] = :display_help
+        @options[:help_message] = parser.help
+      end
+
+      parser.on_tail('-v', '--version', 'Display version') do
+        @options[:command] = :display_version
+      end
+
+      parser.on_tail('-V', '--verbose-version', 'Display verbose version information') do
+        @options[:command] = :display_version
+        @options[:verbose_version] = true
+      end
+    end
+  end
+end

data/lib/terraform_landscape/cli.rb

@@ -0,0 +1,51 @@
+require 'commander'
+
+module TerraformLandscape
+  # Command line application interface.
+  class CLI
+    include Commander::Methods
+
+    def initialize(output)
+      @output = output
+    end
+
+    # Parses the given command line arguments and executes appropriate logic
+    # based on those arguments.
+    #
+    # @param args [Array<String>] command line arguments
+    #
+    # @return [Integer] exit status code
+    def run(args)
+      program :name, 'Terraform Landscape'
+      program :version, VERSION
+      program :description, 'Pretty-print your Terraform plan output'
+
+      define_commands
+
+      run!
+      0 # OK
+    end
+
+    private
+
+    def define_commands
+      command :print do |c|
+        c.action do
+          print
+        end
+      end
+
+      global_option '--no-color', 'Do not output any color' do
+        String.disable_colorization = true
+        @output.color_enabled = false
+      end
+
+      default_command :print
+    end
+
+    def print
+      printer = Printer.new(@output)
+      printer.process_stream(STDIN)
+    end
+  end
+end

data/lib/terraform_landscape/constants.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Global application constants.
+module TerraformLandscape
+  HOME = File.expand_path(File.join(File.dirname(__FILE__), '..', '..')).freeze
+
+  REPO_URL = 'https://github.com/coinbase/terraform_landscape'.freeze
+  BUG_REPORT_URL = "#{REPO_URL}/issues".freeze
+end

data/lib/terraform_landscape/errors.rb

@@ -0,0 +1,33 @@
+# Collection of errors that can be raised by the framework.
+module TerraformLandscape
+  # Abstract error. Separates LintTrappings errors from other kinds of
+  # errors in the exception hierarchy.
+  #
+  # @abstract
+  class Error < StandardError
+    # Returns the status code that should be output if this error goes
+    # unhandled.
+    #
+    # Ideally these should resemble exit codes from the sysexits documentation
+    # where it makes sense.
+    def self.exit_status(*args)
+      if args.any?
+        @exit_status = args.first
+      elsif @exit_status
+        @exit_status
+      else
+        ancestors.each do |ancestor|
+          return 70 if ancestor == TerraformLandscape::Error # No exit status defined
+          return ancestor.exit_status if ancestor.exit_status
+        end
+      end
+    end
+
+    def exit_status
+      self.class.exit_status
+    end
+  end
+
+  # Raised when there was a problem parsing a document.
+  class ParseError < Error; end
+end

data/lib/terraform_landscape/output.rb

@@ -0,0 +1,118 @@
+module TerraformLandscape
+  # Encapsulates all communication to an output source.
+  class Output
+    # Whether colored output via ANSI escape sequences is enabled.
+    # @return [true,false]
+    attr_accessor :color_enabled
+
+    # Creates a logger which outputs nothing.
+    # @return [TerraformLandscape::Output]
+    def self.silent
+      new(File.open(File::NULL, 'w'))
+    end
+
+    # Creates a new {SlimLint::Logger} instance.
+    #
+    # @param out [IO] the output destination.
+    def initialize(out)
+      @out = out
+      @color_enabled = tty?
+    end
+
+    # Print the specified output.
+    #
+    # @param output [String] the output to send
+    # @param newline [true,false] whether to append a newline
+    def puts(output, newline = true)
+      @out.print(output)
+      @out.print("\n") if newline
+    end
+
+    # Print the specified output without a newline.
+    #
+    # @param output [String] the output to send
+    def print(output)
+      puts(output, false)
+    end
+
+    # Print the specified output in bold face.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def bold(*args)
+      color('1', *args)
+    end
+
+    # Print the specified output in a color indicative of error.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def error(*args)
+      color(31, *args)
+    end
+
+    # Print the specified output in a bold face and color indicative of error.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def bold_error(*args)
+      color('1;31', *args)
+    end
+
+    # Print the specified output in a color indicative of success.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def success(*args)
+      color(32, *args)
+    end
+
+    # Print the specified output in a color indicative of a warning.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def warning(*args)
+      color(33, *args)
+    end
+
+    # Print the specified output in a color indicating something worthy of
+    # notice.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def notice(*args)
+      color(35, *args)
+    end
+
+    # Print the specified output in a color indicating information.
+    # If output destination is not a TTY, behaves the same as {#log}.
+    #
+    # @param args [Array<String>]
+    def info(*args)
+      color(36, *args)
+    end
+
+    # Print a blank line.
+    def newline
+      puts('')
+    end
+
+    # Whether this logger is outputting to a TTY.
+    #
+    # @return [true,false]
+    def tty?
+      @out.respond_to?(:tty?) && @out.tty?
+    end
+
+    private
+
+    # Print output in the specified color.
+    #
+    # @param code [Integer,String] ANSI color code
+    # @param output [String] output to print
+    # @param newline [Boolean] whether to append a newline
+    def color(code, output, newline = true)
+      puts(color_enabled ? "\033[#{code}m#{output}\033[0m" : output, newline)
+    end
+  end
+end

data/lib/terraform_landscape/printer.rb

@@ -0,0 +1,56 @@
+require 'stringio'
+
+module TerraformLandscape
+  class Printer
+    def initialize(output)
+      @output = output
+    end
+
+    def process_stream(io)
+      buffer = StringIO.new
+      begin
+        block_size = 1024
+
+        done = false
+        until done
+          readable_fds, = IO.select([io])
+          next unless readable_fds
+
+          readable_fds.each do |f|
+            begin
+              buffer << f.read_nonblock(block_size)
+            rescue IO::WaitReadable # rubocop:disable Lint/HandleExceptions
+              # Ignore; we'll call IO.select again
+            rescue EOFError
+              done = true
+            end
+          end
+        end
+      ensure
+        io.close
+      end
+
+      plan_output = buffer.string
+      scrubbed_output = plan_output.gsub(/\e\[\d+m/, '')
+
+      # Remove preface
+      if (match = scrubbed_output.match(/^Path:[^\n]+/))
+        scrubbed_output = scrubbed_output[match.end(0)..-1]
+      else
+        raise ParseError, 'Output does not contain proper preface'
+      end
+
+      # Remove postface
+      if (match = scrubbed_output.match(/^Plan:[^\n]+/))
+        plan_summary = scrubbed_output[match.begin(0)..match.end(0)]
+        scrubbed_output = scrubbed_output[0...match.begin(0)]
+      else
+        raise ParseError, 'Output does not container proper postface'
+      end
+
+      plan = TerraformPlan.from_output(scrubbed_output)
+      plan.display(@output)
+      @output.puts plan_summary
+    end
+  end
+end

data/lib/terraform_landscape/terraform_plan.rb

@@ -0,0 +1,188 @@
+require 'colorize'
+require 'diffy'
+require 'json'
+require 'treetop'
+
+########################################################################
+# Represents the parsed output of `terraform plan`.
+#
+# This allows us to easily inspect the plan and present a more readable
+# explanation of the plan to the user.
+########################################################################
+class TerraformLandscape::TerraformPlan
+  GRAMMAR_FILE = File.expand_path(File.join(File.dirname(__FILE__),
+                                            '..', '..', 'grammar',
+                                            'terraform_plan.treetop'))
+
+  CHANGE_SYMBOL_TO_COLOR = {
+    :~ => :yellow,
+    :- => :red,
+    :+ => :green
+  }.freeze
+
+  DEFAULT_DIFF_CONTEXT_LINES = 5
+
+  class ParseError < StandardError; end
+
+  class << self
+    def from_output(string)
+      return new([]) if string.strip.empty?
+      tree = parser.parse(string)
+      raise ParseError, parser.failure_reason unless tree
+      new(tree.to_ast)
+    end
+
+    private
+
+    def parser
+      @parser ||=
+        begin
+          Treetop.load(GRAMMAR_FILE)
+          TerraformPlanParser.new
+        end
+    end
+  end
+
+  # Create a plan from an abstract syntax tree (AST).
+  def initialize(plan_ast, options = {})
+    @ast = plan_ast
+    @diff_context_lines = options.fetch(:diff_context_lines, DEFAULT_DIFF_CONTEXT_LINES)
+  end
+
+  def display(output)
+    @out = output
+    @ast.each do |resource|
+      display_resource(resource)
+      @out.newline
+    end
+  end
+
+  private
+
+  def display_resource(resource)
+    change_color = CHANGE_SYMBOL_TO_COLOR[resource[:change]]
+
+    @out.puts "#{resource[:change]} #{resource[:resource_type]}." \
+              "#{resource[:resource_name]}".colorize(change_color)
+
+    # Determine longest attribute name so we align all values at same indentation
+    attribute_value_indent_amount = attribute_indent_amount_for_resource(resource)
+
+    resource[:attributes].each do |attribute_name, attribute_value|
+      display_attribute(resource,
+                        change_color,
+                        attribute_name,
+                        attribute_value,
+                        attribute_value_indent_amount)
+    end
+  end
+
+  def attribute_indent_amount_for_resource(resource)
+    longest_name_length = resource[:attributes].keys.reduce(0) do |longest, name|
+      name.length > longest ? name.length : longest
+    end
+    longest_name_length + 8
+  end
+
+  def json?(value)
+    ['{', '['].include?(value.to_s[0]) &&
+      (JSON.parse(value) rescue nil) # rubocop:disable Style/RescueModifier
+  end
+
+  def to_pretty_json(value)
+    JSON.pretty_generate(JSON.parse(value),
+                         {
+                           indent: '  ',
+                           space: ' ',
+                           object_nl: "\n",
+                           array_nl: "\n"
+                         })
+  end
+
+  def display_diff(old, new, indent)
+    @out.print Diffy::Diff.new(old, new, { context: @diff_context_lines })
+      .to_s(String.disable_colorization ? :text : :color)
+      .gsub("\n", "\n" + indent)
+      .strip
+  end
+
+  def display_attribute(
+    resource,
+    change_color,
+    attribute_name,
+    attribute_value,
+    attribute_value_indent_amount
+  )
+    attribute_value_indent = ' ' * attribute_value_indent_amount
+
+    if resource[:change] == :~
+      display_modified_attribute(change_color,
+                                 attribute_name,
+                                 attribute_value,
+                                 attribute_value_indent,
+                                 attribute_value_indent_amount)
+    else
+      display_added_or_removed_attribute(change_color,
+                                         attribute_name,
+                                         attribute_value,
+                                         attribute_value_indent,
+                                         attribute_value_indent_amount)
+    end
+  end
+
+  def display_modified_attribute( # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    change_color,
+    attribute_name,
+    attribute_value,
+    attribute_value_indent,
+    attribute_value_indent_amount
+  )
+    # Since the attribute line is always of the form
+    # "old value" => "new value", we can add curly braces and parse with
+    # `eval` to obtain a hash with a single key/value.
+    old, new = eval("{#{attribute_value}}").to_a.first # rubocop:disable Lint/Eval
+
+    return if old == new # Don't show unchanged attributes
+
+    @out.print "    #{attribute_name}:".ljust(attribute_value_indent_amount, ' ')
+      .colorize(change_color)
+
+    if json?(new)
+      # Value looks like JSON, so prettify it to make it more readable
+      fancy_old = "#{to_pretty_json(old)}\n"
+      fancy_new = "#{to_pretty_json(new)}\n"
+      display_diff(fancy_old, fancy_new, attribute_value_indent)
+    elsif old.include?("\n") || new.include?("\n")
+      # Multiline content, so display nicer diff
+      display_diff("#{old}\n", "#{new}\n", attribute_value_indent)
+    else
+      # Typical values, so just show before/after
+      @out.print '"' + old.colorize(:red) + '"'
+      @out.print ' => '.colorize(:light_black)
+      @out.print '"' + new.colorize(:green) + '"'
+    end
+
+    @out.newline
+  end
+
+  def display_added_or_removed_attribute(
+    change_color,
+    attribute_name,
+    attribute_value,
+    attribute_value_indent,
+    attribute_value_indent_amount
+  )
+    @out.print "    #{attribute_name}:".ljust(attribute_value_indent_amount, ' ')
+      .colorize(change_color)
+
+    evaluated_string = eval(attribute_value) # rubocop:disable Lint/Eval
+    if json?(evaluated_string)
+      @out.print to_pretty_json(evaluated_string).gsub("\n", "\n" + attribute_value_indent)
+        .colorize(change_color)
+    else
+      @out.print "\"#{evaluated_string.colorize(change_color)}\""
+    end
+
+    @out.newline
+  end
+end

data/lib/terraform_landscape/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Defines the gem version.
+module TerraformLandscape
+  VERSION = '0.0.1'.freeze
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: terraform_landscape
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Coinbase
+- Shane da Silva
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+- !ruby/object:Gem::Dependency
+  name: diffy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: Improve output of Terraform plans with color and indentation
+email:
+- shane@coinbase.com
+executables:
+- landscape
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/landscape
+- grammar/terraform_plan.treetop
+- lib/terraform_landscape.rb
+- lib/terraform_landscape/arguments_parser.rb
+- lib/terraform_landscape/cli.rb
+- lib/terraform_landscape/constants.rb
+- lib/terraform_landscape/errors.rb
+- lib/terraform_landscape/output.rb
+- lib/terraform_landscape/printer.rb
+- lib/terraform_landscape/terraform_plan.rb
+- lib/terraform_landscape/version.rb
+homepage: https://github.com/coinbase/terraform_landscape
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: Pretty-print Terraform plan output
+test_files: []