etna 0.1.15 → 0.1.21

data/lib/etna/controller.rb

@@ -12,6 +12,7 @@ module Etna
       @logger = @request.env['etna.logger']
       @user = @request.env['etna.user']
       @request_id = @request.env['etna.request_id']
+      @hmac = @request.env['etna.hmac']
     end
 
     def log(line)
@@ -23,11 +24,14 @@ module Etna
 
       return send(@action) if @action
 
+
       [501, {}, ['This controller is not implemented.']]
     rescue Etna::Error => e
+      Rollbar.error(e)
       @logger.error(request_msg("Exiting with #{e.status}, #{e.message}"))
       return failure(e.status, error: e.message)
     rescue Exception => e
+      Rollbar.error(e)
       @logger.error(request_msg('Caught unspecified error'))
       @logger.error(request_msg(e.message))
       e.backtrace.each do |trace|

data/lib/etna/csvs.rb

@@ -0,0 +1,159 @@
+module Etna
+  class CsvImporter
+    def initialize(
+        strip: true,
+        filter_empties: true,
+        &row_formatter
+    )
+      # Removes any columns from a row that are empty strings.  Allows for some simpler 'empty' processing.  This occurs
+      # post stripping as well.
+      @filter_empties = filter_empties
+      @row_formatter = row_formatter
+    end
+
+    COLUMN_AS_BOOLEAN = -> (s) { ['true', 't', 'y', 'yes'].include?(s&.downcase) }
+
+    def each_csv_row(filename: nil, input_io: nil, &block)
+      if input_io.nil?
+        unless filename.nil?
+          File.open(filename, 'r') do |io|
+            return each_csv_row(input_io: io, &block)
+          end
+        end
+      end
+
+      lineno = 1
+      CSV.parse(input_io, headers: true, header_converters: :symbol) do |row|
+        lineno += 1
+        row = row.to_hash
+        row.keys.each { |k| row[k].strip! if row[k] =~ /^\s+$/ } if @strip
+        row.select! { |k, v| !v.empty? } if @filter_empties
+        @row_formatter.call(row) unless @row_formatter.nil?
+        yield row, lineno if block_given?
+      end
+    end
+
+    def replace_row_column(row, column, &block)
+      if !row[column].nil? || block.arity == 0
+        row[column] = yield row[column]
+      end
+    end
+
+    class ImportError < StandardError
+      attr_accessor :lineno
+
+      def initialize(msg, lineno = nil)
+        @lineno = lineno
+        super(msg)
+      end
+
+      def message
+        "line #{lineno}: #{super}"
+      end
+    end
+
+    class NestedRowProcessor
+      attr_reader :row, :lineno, :context, :errors
+
+      def initialize(row, lineno, context)
+        @row = row
+        @lineno = lineno
+        @context = context
+        @errors = []
+
+        # If a parent context changes, all child contexts are invalidated.  But since parent contexts are changed
+        # before the relationship of child contexts are declared, we have to track that so that when a child context
+        # dependency is declared we can clear it based on wether parents have changed.
+        @changed = {}
+      end
+
+      def process(column, *parents, &block)
+        if parents.any? { |p| @changed.include?(p) }
+          @changed[column] = true
+          @context[column] = nil
+        end
+
+        return self if (next_val = row[column]).nil?
+        @changed[column] = true
+
+        parent_values = parents.map do |p|
+          if @context[p].nil?
+            raise ImportError.new("Found a #{column} value, but no previous #{p} had been given!", @lineno)
+          end
+
+          @context[p]
+        end
+
+        begin
+          next_val = yield next_val, *parent_values, self if block_given?
+        rescue ImportError => e
+          e.lineno = @lineno
+          raise e
+        end
+
+        @context[column] = next_val
+        self
+      end
+    end
+  end
+
+  class CsvExporter
+    # column_headers should be an array of symbols, mapping the column heading names and ordering to export
+    # column_serializer is an optional block that takes column (string), column_value (string) and should
+    #   return a string representation of column_value to write to the csv.  By default, when nil, the exporter
+    #   will attempt to convert the value to a string via to_s or simply write an empty string for nil.
+
+    attr_reader :column_headers
+    def initialize(column_headers, &column_serializer)
+      @column_headers = column_headers
+      @column_serializer = column_serializer
+    end
+
+    def header_row
+      @column_headers.map(&:to_s)
+    end
+
+    def map_column_value(column, column_value)
+      @column_serializer&.call(column, column_value) || column_value&.to_s || ''
+    end
+
+    def row_from_columns(columns)
+      @column_headers.map { |c| self.map_column_value(c, columns[c] || '') }
+    end
+
+    def with_row_writeable(filename: nil, output_io: nil, &block)
+      if output_io.nil? && !filename.nil?
+        File.open(filename, 'w') do |io|
+          return with_row_writeable(output_io: io, &block)
+        end
+      end
+
+      writeable = self.class::RowWriteable.new(self, CSV.new(output_io))
+      yield writeable
+      writeable.ensure_headers
+      nil
+    end
+
+    class RowWriteable
+      def initialize(exporter, csv)
+        @exporter = exporter
+        @csv = csv
+        @written_headers = false
+      end
+
+      def <<(columns)
+        self.ensure_headers
+        @csv << @exporter.row_from_columns(columns)
+      end
+
+      def write(**columns)
+        self.<<(columns)
+      end
+
+      def ensure_headers
+        @csv << @exporter.header_row unless @written_headers
+        @written_headers = true
+      end
+    end
+  end
+end

data/lib/etna/directed_graph.rb

@@ -0,0 +1,56 @@
+class DirectedGraph
+  def initialize
+    @children = {}
+    @parents = {}
+  end
+
+  attr_reader :children
+  attr_reader :parents
+
+  def add_connection(parent, child)
+    children = @children[parent] ||= {}
+    child_children = @children[child] ||= {}
+
+    children[child] = child_children
+
+    parents = @parents[child] ||= {}
+    parent_parents = @parents[parent] ||= {}
+    parents[parent] = parent_parents
+  end
+
+  def descendants(parent)
+    seen = Set.new
+
+    seen.add(parent)
+    queue = @children[parent].keys.dup
+    parent_queue = @parents[parent].keys.dup
+
+    # Because this is not an acyclical graph, the definition of descendants needs to be stronger;
+    # here we believe that any path that would move through --any-- parent to this child would not be considered
+    # descendant, so we first find all those parents and mark them as 'seen' so that they are not traveled.
+    while next_parent = parent_queue.pop
+      next if seen.include?(next_parent)
+      seen.add(next_parent)
+      parent_queue.push(*@parents[next_parent].keys)
+    end
+
+    queue = queue.nil? ? [] : queue.dup
+    paths = {}
+
+    while child = queue.pop
+      next if seen.include? child
+      seen.add(child)
+      path = (paths[child] ||= [parent])
+
+      @children[child].keys.each do |child_child|
+        queue.push child_child
+
+        unless paths.include? child_child
+          paths[child_child] = path + [child]
+        end
+      end
+    end
+
+    paths
+  end
+end

data/lib/etna/environment_scoped.rb

@@ -0,0 +1,19 @@
+class EnvironmentScoped < Module
+  def initialize(&block)
+    environment_class = Class.new do
+      class_eval(&block)
+
+      attr_reader :environment
+      def initialize(environment)
+        @environment = environment
+      end
+    end
+
+    super() do
+      define_method :environment do |env|
+        env = env.to_sym
+        (@envs ||= {})[env] ||= environment_class.new(env)
+      end
+    end
+  end
+end

data/lib/etna/errors.rb

@@ -22,6 +22,12 @@ module Etna
     end
   end
 
+  class NotFound < Etna::Error
+    def initialize(msg = 'Resource not found', status = 404)
+      super
+    end
+  end
+
   class BadRequest < Etna::Error
     def initialize(msg = 'Client error', status = 422)
       super

data/lib/etna/generate_autocompletion_script.rb

@@ -0,0 +1,131 @@
+require_relative 'command'
+
+# application.rb instantiates this for the project scoping.
+# This generates a file, project-name.completion, which is sourced
+# in build.sh to provide autocompletion in that environment.
+module Etna
+  class GenerateCompletionScript < Etna::Command
+    def generate_for_command(command)
+      completions = command.completions
+      completions.each do |c|
+        generate_start_match(c, false)
+        write "fi"
+        write "shift"
+      end
+
+      enable_flags(command.class)
+      write 'while [[ "$#" != "0" ]]; do'
+      generate_start_match([])
+      generate_flag_handling
+
+      write "else"
+      write "return"
+      write 'fi'
+      write 'done'
+      write "return"
+    end
+
+    def generate_flag_handling
+      write %Q(elif [[ -z "$(echo $all_flag_completion_names | xargs)" ]]; then)
+      write "return"
+      write %Q(elif [[ "$all_flag_completion_names" =~ $1\\  ]]; then)
+      write %Q(all_flag_completion_names="${all_flag_completion_names//$1\\ /}")
+      write 'a=$1'
+      write 'shift'
+      write %Q(if [[ "$string_flag_completion_names" =~ $a\\  ]]; then)
+      write 'if [[ "$#" == "1" ]];  then'
+      write %Q(a="${a//--/}")
+      write %Q(a="${a//-/_}")
+      write %Q(i="_completions_for_$a")
+      write %Q(all_completion_names="${!i}")
+      write 'COMPREPLY=($(compgen -W "$all_completion_names" -- "$1"))'
+      write 'return'
+      write 'fi'
+      write 'shift'
+      write 'fi'
+    end
+
+    def generate_start_match(completions, include_flags=true)
+      write 'if [[ "$#" == "1" ]];  then'
+      write %Q(all_completion_names="#{completions.join(' ')}")
+      write %Q(all_completion_names="$all_completion_names $all_flag_completion_names") if include_flags
+      write %Q(if [[ -z "$(echo $all_completion_names | xargs)" ]]; then)
+      write 'return'
+      write 'fi'
+      write 'COMPREPLY=($(compgen -W "$all_completion_names" -- "$1"))'
+      write 'return'
+    end
+
+    def enable_flags(flags_container)
+      boolean_flags = flags_container.boolean_flags
+      string_flags = flags_container.string_flags
+      flags = boolean_flags + string_flags
+      write %Q(all_flag_completion_names="$all_flag_completion_names #{flags.join(' ')} ")
+      write %Q(string_flag_completion_names="$string_flag_completion_names #{string_flags.join(' ')} ")
+
+      string_flags.each do |flag|
+        write %Q(declare _completions_for_#{flag_as_parameter(flag)}="#{completions_for(flag_as_parameter(flag)).join(' ')}")
+      end
+    end
+
+    def generate_for_scope(scope)
+      enable_flags(scope.class)
+      write 'while [[ "$#" != "0" ]]; do'
+      generate_start_match(scope.subcommands.keys)
+
+      scope.subcommands.each do |name, command|
+        write %Q(elif [[ "$1" == "#{name}" ]]; then)
+        write 'shift'
+        if command.class.included_modules.include?(CommandExecutor)
+          generate_for_scope(command)
+        else
+          generate_for_command(command)
+        end
+      end
+
+      generate_flag_handling
+
+      write "else"
+      write "return"
+      write "fi"
+      write 'done'
+    end
+
+    def program_name
+      $PROGRAM_NAME
+    end
+
+    def execute
+      name = File.basename(program_name)
+
+      write <<-EOF
+#!/usr/bin/env bash
+
+function _#{name}_completions() {
+  _#{name}_inner_completions "${COMP_WORDS[@]:1:COMP_CWORD}"
+}
+
+function _#{name}_inner_completions() {
+  local all_flag_completion_names=''
+  local string_flag_completion_names=''
+  local all_completion_names=''
+  local i=''
+  local a=''
+EOF
+      generate_for_scope(parent)
+      write <<-EOF
+}
+
+complete -o default -F _#{name}_completions #{name}
+EOF
+
+      File.open("#{name}.completion", 'w') { |f| f.write(@script) }
+    end
+
+    def write(string)
+      @script ||= ""
+      @script << string
+      @script << "\n"
+    end
+  end
+end

data/lib/etna/json_serializable_struct.rb

@@ -0,0 +1,37 @@
+module Etna
+  module JsonSerializableStruct
+    def self.included(cls)
+      cls.instance_eval do
+        def self.as_json(v)
+          if v.respond_to? :as_json
+            return v.as_json
+          end
+
+          if v.is_a? Hash
+            return v.map { |k, v| [k, as_json(v)] }.to_h
+          end
+
+          if v.class.include? Enumerable
+            return v.map { |v| as_json(v) }
+          end
+
+          v
+        end
+      end
+    end
+
+    def as_json(keep_nils: false)
+      inner_json = members.map do |k|
+        v = self.class.as_json(send(k))
+        [k, v]
+      end.to_h
+
+      return inner_json if keep_nils
+      inner_json.delete_if { |k, v| v.nil? }
+    end
+
+    def to_json
+      as_json.to_json
+    end
+  end
+end

data/lib/etna/logger.rb

@@ -1,10 +1,18 @@
 require 'logger'
+require 'rollbar'
 
 module Etna
   class Logger < ::Logger
-    def initialize(log_dev, age, size)
-      super
+    def initialize(log_dev, age, size=1048576)
+      # On windows, these posix devices exist, but are not mounted in *nix style paths.
+      # Swap the paths out with the actual IO handles instead.
+      if log_dev == '/dev/stdout'
+        log_dev = STDOUT
+      elsif log_dev == '/dev/stderr'
+        log_dev = STDERR
+      end
 
+      super
       self.formatter = proc do |severity, datetime, progname, msg|
         format(severity, datetime, progname, msg)
       end
@@ -14,11 +22,25 @@ module Etna
       "#{severity}:#{datetime.iso8601} #{msg}\n"
     end
 
+    def warn(msg, &block)
+      super
+    end
+
+    def error(msg, &block)
+      super
+    end
+
+    def fatal(msg, &block)
+      super
+    end
+
     def log_error(e)
       error(e.message)
       e.backtrace.each do |trace|
         error(trace)
       end
+
+      Rollbar.error(e)
     end
 
     def log_request(request)