firespring_dev_commands 2.2.1.pre.alpha.1 → 2.5.0.pre.alpha.1

data/lib/firespring_dev_commands/bloom_growth/user.rb

@@ -1,43 +0,0 @@
-module Dev
-  class BloomGrowth
-    # Class containing user information
-    class User
-      attr_accessor :data, :id, :type, :name, :rocks, :direct_reports, :seats
-
-      def initialize(data)
-        @data = data
-        @id = data['Id']
-        @type = data['Type']
-        @name = data['Name'].to_s.strip
-        @rocks = nil
-        @direct_reports = nil
-        @seats = nil
-      end
-
-      def rocks
-        @rocks ||= [].tap do |ary|
-          Dev::BloomGrowth.new.get("/api/v1/rocks/user/#{id}") do |data|
-            ary << Rock.new(data)
-          end
-        end
-      end
-
-      def direct_reports
-        @direct_reports ||= [].tap do |ary|
-          Dev::BloomGrowth.new.get("/api/v1/users/#{id}/directreports") do |data|
-            ary << User.new(data)
-          end
-        end
-      end
-
-      def seats
-        @seats ||= [].tap do |ary|
-          Dev::BloomGrowth.new.get("/api/v1/users/#{id}/seats") do |data|
-            ary << Seat.new(data)
-            puts ary.last.inspect
-          end
-        end
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/bloom_growth.rb

@@ -1,132 +0,0 @@
-require 'net/http'
-
-module Dev
-  # Class for interacting with the Bloom Growth api
-  class BloomGrowth
-    # The config file to try to load credentials from
-    CONFIG_FILE = "#{Dir.home}/.env.bloom".freeze
-
-    # The text of the username variable key
-    BLOOM_USERNAME = 'BLOOM_USERNAME'.freeze
-
-    # The text of the password variable key
-    BLOOM_PASSWORD = 'BLOOM_PASSWORD'.freeze
-
-    # The text of the token variable key
-    BLOOM_TOKEN = 'BLOOM_TOKEN'.freeze
-
-    # The text of the url variable key
-    BLOOM_URL = 'BLOOM_URL'.freeze
-
-    # Config object for setting top level bloom growth config options
-    Config = Struct.new(:username, :password, :url, :http_debug) do
-      def initialize
-        Dotenv.load(CONFIG_FILE) if File.exist?(CONFIG_FILE)
-
-        self.username = ENV.fetch(BLOOM_USERNAME, nil)
-        self.password = ENV.fetch(BLOOM_PASSWORD, nil)
-        self.url = ENV.fetch(BLOOM_URL, 'https://app.bloomgrowth.com')
-        self.http_debug = false
-      end
-    end
-
-    class << self
-      # Instantiates a new top level config object if one hasn't already been created
-      # Yields that config object to any given block
-      # Returns the resulting config object
-      def config
-        @config ||= Config.new
-        yield(@config) if block_given?
-        @config
-      end
-
-      # Alias the config method to configure for a slightly clearer access syntax
-      alias_method :configure, :config
-    end
-
-    attr_accessor :username, :password, :url, :token, :client, :default_headers
-
-    # Initialize a new target process client using the given inputs
-    def initialize(username: self.class.config.username, password: self.class.config.password, url: self.class.config.url)
-      raise 'username is required' if username.to_s.strip.empty?
-      raise 'password is required' if password.to_s.strip.empty?
-      raise 'url is required' if url.to_s.strip.empty?
-
-      @username = username
-      @password = password
-      @url = url
-      uri = URI.parse(@url)
-      @client = Net::HTTP.new(uri.host, uri.port)
-      @client.use_ssl = true
-      @client.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      @client.set_debug_output(LOG) if self.class.config.http_debug
-      @default_headers = {
-        'authorization' => "Bearer #{token}",
-        'content-type' => 'application/json',
-        'accept' => 'application/json'
-      }
-    end
-
-    # Method for getting a bearer token for the bloom growth api. There are a couple of possible logic paths
-    #   - If a token has already been defined, use it
-    #   - If a token is found in the ENV, use it
-    #   - Otherwise, use the username and passowrd that has been configured to request a new token from bloom
-    def token
-      @token ||= ENV.fetch(BLOOM_TOKEN, nil)
-
-      unless @token
-        response = post(
-          '/Token',
-          {
-            grant_type: 'password',
-            userName: username,
-            password:
-          },
-          headers: {
-            'content-type' => 'application/json',
-            'accept' => 'application/json'
-          }
-        )
-        # TODO: Should we look at https://github.com/DannyBen/lightly for caching the token?
-        @token = ENV[BLOOM_TOKEN] = response['access_token']
-        LOG.info("Retrieved BloomGrowth token. Expires on #{Time.now + response['expires_in']}")
-      end
-
-      @token
-    end
-
-    # Return all user objects visible to the logged in user
-    def visible_users(&)
-      [].tap do |ary|
-        get('/api/v1/users/mineviewable') do |user_data|
-          ary << User.new(user_data)
-        end
-        ary.each(&)
-      end
-    end
-
-    # Perform a get request to the given path using the given query
-    # Call the given block (if present) with each piece of data
-    # Return all pieces of data
-    def get(path, query_string: nil, headers: default_headers, &)
-      url = path
-      url << "?#{URI.encode_www_form(query_string)}" unless query_string.to_s.strip.empty?
-
-      response = client.request_get(url, headers)
-      raise "Error querying #{url} [#{query_string}]: #{response.inspect}" unless response.response.is_a?(Net::HTTPSuccess)
-
-      JSON.parse(response.body).each(&)
-      nil
-    end
-
-    # Perform a post request to the given path using the gien data
-    # Return the parsed json body
-    def post(path, data, headers: default_headers)
-      data = data.to_json unless data.is_a?(String)
-      response = client.request_post(path, data, headers)
-      raise "Error querying #{url}/#{path}: #{response.inspect}" unless response.response.is_a?(Net::HTTPSuccess)
-
-      JSON.parse(response.body)
-    end
-  end
-end

data/lib/firespring_dev_commands/certificate.rb

@@ -1,59 +0,0 @@
-module Dev
-  # Class contains methods for requesting a certificate from route53.
-  # You must have a hosted zone defined for the desired domain
-  class Certificate
-    attr_accessor :domains, :email
-
-    def initialize(domains, email)
-      @domains = Array(domains)
-      @email = email
-      raise 'No certificate domains specified' if domains.empty?
-    end
-
-    # Request the certificate using the route53 docker image
-    # Certificate is stored in /etc/letsencrypt
-    def request
-      puts
-      puts 'Getting SSL Certs For:'
-      puts domains.join("\n")
-      puts
-      puts 'This process can take up to 10 minutes'
-      puts
-      puts Time.now
-
-      # TODO: Really should use the docker api for this
-      cmd = %w(docker run -it --rm --name certbot)
-      cmd << '-e' << 'AWS_ACCESS_KEY_ID'
-      cmd << '-e' << 'AWS_SECRET_ACCESS_KEY'
-      cmd << '-e' << 'AWS_SESSION_TOKEN'
-      cmd << '-v' << '/etc/letsencrypt:/etc/letsencrypt'
-      cmd << 'certbot/dns-route53:latest'
-      cmd << 'certonly'
-      cmd << '-n'
-      cmd << '--agree-tos'
-      cmd << '--dns-route53'
-      cmd << '-d' << domains.join(',')
-      cmd << '--email' << email
-      cmd << '--server' << 'https://acme-v02.api.letsencrypt.org/directory'
-      puts cmd.join(' ')
-      Dev::Common.new.run_command(cmd)
-    end
-
-    # Saves the latest version of the certificate into the given dest_dir
-    def save(dest_dir)
-      raise "directory #{dest_dir} must be an existing directory" unless File.directory?(dest_dir)
-
-      domain = domains.first.sub(/^\*\./, '') # Need to strip off the '*.' if this is a wildcard cert
-      directories = Dir.glob("/etc/letsencrypt/live/#{domain}*/")
-      no_suffix = directories.delete("/etc/letsencrypt/live/#{domain}/")
-      biggest_suffix = directories.max
-      source_dir = biggest_suffix || no_suffix
-      raise "unable to determine certificate directory for #{domain}" unless source_dir
-
-      FileUtils.cp("#{source_dir}privkey.pem", dest_dir, verbose: true)
-      FileUtils.cp("#{source_dir}cert.pem", dest_dir, verbose: true)
-      FileUtils.cp("#{source_dir}chain.pem", dest_dir, verbose: true)
-      FileUtils.cp("#{source_dir}fullchain.pem", dest_dir, verbose: true)
-    end
-  end
-end

data/lib/firespring_dev_commands/coverage/base.rb

@@ -1,16 +0,0 @@
-module Dev
-  module Coverage
-    # Class which defines the methods which must be implemented to function as a coverage class
-    class Base
-      # Raises not implemented
-      def php_options
-        raise 'not implemented'
-      end
-
-      # Raises not implemented
-      def check(*)
-        raise 'not implemented'
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/coverage/cobertura.rb

@@ -1,86 +0,0 @@
-module Dev
-  # Module containing different classes for interfacing with coverage files
-  module Coverage
-    # Class for checking code coverage using cobertura
-    class Cobertura < Base
-      attr_reader :local_filename, :container_filename, :filename, :threshold, :exclude
-
-      def initialize(filename: File.join('coverage', 'cobertura.xml'), threshold: nil, container_path: nil, local_path: nil, exclude: nil)
-        super()
-
-        @filename = filename
-        @local_filename = File.join(local_path || '.', @filename)
-        @container_filename = File.join(container_path || '.', @filename)
-        @threshold = threshold
-        @exclude = (exclude || []).map do |it|
-          next it if it.is_a?(Regex)
-
-          Regex.new(it)
-        end
-      end
-
-      # Remove any previous versions of the local file that will be output
-      # return the phpunit options needed to regenerate the cobertura xml file
-      def php_options
-        # Remove any previous coverage info
-        FileUtils.rm_f(local_filename, verbose: true)
-
-        # Return the needed php commands to generate the cobertura report
-        %W(--coverage-cobertura #{container_filename})
-      end
-
-      # Parse the cobertura file and check the lines missed against the desired threshold
-      def check(application: nil)
-        # If an application has been specified and the file does not exist locally, attempt to copy it back from the docker container
-        if application && !File.exist?(local_filename)
-          container = Dev::Docker::Compose.new.container_by_name(application)
-          Dev::Docker.new.copy_from_container(container, container_filename, local_filename, required: true)
-        end
-
-        report = Ox.load(File.read(local_filename))
-        total_missed = report.coverage.locate('packages/package').sum { |package| parse_package_missed(package) }
-        puts "Lines missing coverage was #{total_missed}"
-        puts "Configured threshold was #{threshold}" if threshold
-        raise 'Code coverage not met' if threshold && total_missed > threshold
-      end
-
-      # Go through the package and add up all of the lines that were missed
-      # Ignore if the file was in the exlude list
-      private def parse_package_missed(package)
-        filename =  package.attributes[:name]
-        return if exclude.any? { |it| it.match(filename) }
-
-        missed = 0
-        lines_processed = Set.new
-        package.locate('classes/class/lines/line').each do |line|
-          # Don't count lines multiple times
-          line_number = line.attributes[:number]
-          next if lines_processed.include?(line_number)
-
-          lines_processed << line_number
-          missed += 1 unless line.attributes[:hits].to_i.positive?
-        end
-        total = lines_processed.length
-
-        sanity_check_coverage_against_cobertura_values(package, missed, total)
-        missed
-      end
-
-      # Calculate the coverage percent based off the numbers we got and compare to the
-      # value cobertura reported. This is meant as a sanity check that we are reading the data correctly
-      # TODO: This should be removed after the above logic has been vetted
-      private def sanity_check_coverage_against_cobertura_values(package, missed, total)
-        line_rate = package.attributes[:'line-rate']
-        cobertura_reported_coverage = line_rate.to_f
-        cobertura_reported_precision = line_rate.split('.').last.length
-
-        file_coverage = 0.0
-        file_coverage = ((total - missed).to_f / total).round(cobertura_reported_precision) if total.positive?
-        return if file_coverage == cobertura_reported_coverage
-
-        filename = package.attributes[:name]
-        puts "WARNINNG: #{filename} coverage (#{file_coverage}) differed from what cobertura reported (#{cobertura_reported_coverage})"
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/coverage/none.rb

@@ -1,21 +0,0 @@
-module Dev
-  # Module with a variety of coverage methods for different languages
-  module Coverage
-    # Class which provides methods to effectvely skip coverage
-    class None < Base
-      def initialize(*)
-        super()
-      end
-
-      # Returns the php options for generating code coverage file
-      def php_options
-        []
-      end
-
-      # Checks the code coverage against the defined threshold
-      def check(*)
-        puts 'Coverage not configured'
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/docker/desktop.rb

@@ -1,59 +0,0 @@
-module Dev
-  class Docker
-    # Class for configuring docker desktop
-    # This is mostly around configuring the docker URL correctly
-    class Desktop
-      # A snippet of a docker compose file which forwards a socket to a local port so that we can read it in the docker library
-      WIN_TCP_COMPOSE_CONTENT = "
----
-version: '3.8'
-services:
-  windows_tcp:
-    image: alpine/socat
-    network_mode: bridge
-    ports:
-      - 127.0.0.1:23750:2375
-    volumes:
-      - /var/run/docker.sock:/var/run/docker.sock
-    command: tcp-listen:2375,reuseaddr,fork unix-connect:/var/run/docker.sock
-    restart: always".freeze
-
-      # Set up the local ports/sockets correctly based off of the os type
-      def configure
-        if Dev::Os.new.windows?
-          # Start up a small proxy container if running Docker Desktop on windows
-          # This is needed because the docker api library cannot connect to the windows socket
-          unless Dev::Port.new('127.0.0.1', 23_750).open?
-            LOG.info('Starting local proxy port for docker')
-
-            # Write the compose data to a tmp file
-            tmp_compose_file = Tempfile.new('windows_tcp')
-            tmp_compose_file.write(WIN_TCP_COMPOSE_CONTENT)
-            tmp_compose_file.close
-
-            # Start up the container
-            Dev::Docker::Compose.new(
-              compose_files: tmp_compose_file.path,
-              options: ['--detach'],
-              project_name: 'proxy'
-            ).up
-
-            # Wait 1 second before we continue
-            sleep 1
-          end
-
-          # Configure the docker url to use 23750 on windows
-          ::Docker.url = 'tcp://127.0.0.1:23750'
-
-        else
-          # If a user based socket has been defined, default to that
-          ::Docker.url = if File.exist?("/#{Dir.home}/.docker/run/docker.sock")
-                           "unix://#{Dir.home}/.docker/run/docker.sock"
-                         elsif File.exist?("/#{Dir.home}/.docker/desktop/docker.sock")
-                           "unix://#{Dir.home}/.docker/desktop/docker.sock"
-                         end
-        end
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/eol/node.rb

@@ -1,37 +0,0 @@
-module Dev
-  class EndOfLife
-    class Node
-      attr_reader :node, :lockfile
-
-      def initialize(node = Dev::Node.new)
-        @node = node
-        @lockfile = File.join(node.local_path, "#{node.package_file.reverse.split('.')[-1].reverse}-lock.json")
-      end
-
-      def default_products
-        npm_products
-      end
-
-      def npm_products
-        eol = Dev::EndOfLife.new
-        major_version_only_products = %w(ckeditor vue jquery)
-
-        [].tap do |ary|
-          packages = JSON.parse(File.read(lockfile))&.fetch('packages', [])
-          packages.each do |key, info|
-            name = key.split('node_modules/').last
-            product = name
-
-            # Make sure what we found is supported by the EOL library
-            next unless eol.product?(product)
-
-            version = info['version'].reverse.split('.')[-2..].join('.').reverse.tr('v', '')
-            version = version.split('.').first if major_version_only_products.include?(product)
-            version.chop! if version.end_with?('.00')
-            ary << Dev::EndOfLife::ProductVersion.new(product, version, name)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/eol/php.rb

@@ -1,45 +0,0 @@
-module Dev
-  class EndOfLife
-    class Php
-      attr_reader :php, :lockfile
-
-      def initialize(php = Dev::Php.new)
-        @php = php
-        @lockfile = File.join(php.local_path, "#{php.package_file.reverse.split('.')[-1].reverse}.lock")
-      end
-
-      def default_products
-        composer_products
-      end
-
-      def composer_products
-        eol = Dev::EndOfLife.new
-        major_version_only_products = ['laravel']
-        laravel_products = ['laravel/framework']
-        symfony_products = ['symfony/http-client', 'symfony/mailer', 'symfony/mailchimp-mailer']
-
-        [].tap do |ary|
-          packages = JSON.parse(File.read(lockfile))&.fetch('packages', [])
-          packages&.each do |package|
-            name = package['name']
-            product = if laravel_products.include?(name)
-                        'laravel'
-                      elsif symfony_products.include?(name)
-                        'symfony'
-                      else
-                        name
-                      end
-
-            # Make sure what we found is supported by the EOL library
-            next unless eol.product?(product)
-
-            version = package['version'].reverse.split('.')[-2..].join('.').reverse.tr('v', '')
-            version = version.split('.').first if major_version_only_products.include?(product)
-            version.chop! if version.end_with?('.00')
-            ary << Dev::EndOfLife::ProductVersion.new(product, version, name)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/eol/ruby.rb

@@ -1,37 +0,0 @@
-module Dev
-  class EndOfLife
-    class Ruby
-      attr_reader :ruby, :lockfile
-
-      def initialize(ruby = Dev::Ruby.new)
-        @ruby = ruby
-        @lockfile = File.join(ruby.local_path, "#{ruby.package_file.reverse.split('.')[-1].reverse}.lock")
-      end
-
-      def default_products
-        composer_products
-      end
-
-      def composer_products
-        eol = Dev::EndOfLife.new
-        major_version_only_products = []
-
-        [].tap do |ary|
-          packages = Bundler::LockfileParser.new(Bundler.read_file(lockfile)).specs
-          packages.each do |package|
-            name = package.name
-            product = name
-
-            # Make sure what we found is supported by the EOL library
-            next unless eol.product?(product)
-
-            version = package.version.to_s.reverse.split('.')[-2..].join('.').reverse.tr('v', '')
-            version = version.split('.').first if major_version_only_products.include?(product)
-            version.chop! if version.end_with?('.00')
-            ary << Dev::EndOfLife::ProductVersion.new(product, version, name)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/jira/parent.rb

@@ -1,19 +0,0 @@
-module Dev
-  class Jira
-    # Contains information on the Jira parent issue
-    class Parent
-      attr_accessor :data, :id, :title
-
-      def initialize(data)
-        @data = data.parent
-        @id = data.parent['key']
-        @title = data.parent['fields']['summary']
-      end
-
-      # Converts the jira parent object to a string representation
-      def to_s
-        "[#{id}] #{title}"
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/os.rb

@@ -1,35 +0,0 @@
-module Dev
-  # Class containing methods for determining operating system information
-  class Os
-    attr_accessor :os
-
-    def initialize
-      @os = ::RbConfig::CONFIG['host_os']
-    end
-
-    # Returns true if the host_os contains windowsy text
-    def windows?
-      os.match?(/(mingw|mswin|windows)/i)
-    end
-
-    # Returns true if the host_os contains darwinsy text
-    def darwin?
-      os.match?(/(darwin|mac os)/i)
-    end
-
-    # Returns true if the host_os contains macsy text
-    def mac?
-      darwin?
-    end
-
-    # Returns true if the host_os contains nixy text
-    def nix?
-      os.match?(/(linux|bsd|aix|solaris)/i)
-    end
-
-    # Returns true if the host_os contains cygwiny text
-    def cygwin?
-      os.match?(/(cygwin)/i)
-    end
-  end
-end

data/lib/firespring_dev_commands/port.rb

@@ -1,24 +0,0 @@
-module Dev
-  # Class containing methods for actions to be taken on ports
-  class Port
-    attr_accessor :ip_address, :port
-
-    def initialize(ip_address, port)
-      @ip_address = ip_address
-      @port = port
-    end
-
-    # Returns true if the port is open
-    # Returns false otherwise
-    def open?(timeout = 1)
-      Timeout.timeout(timeout) do
-        TCPSocket.new(ip_address, port).close
-        return true
-      end
-
-      false
-    rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
-      false
-    end
-  end
-end

data/lib/firespring_dev_commands/target_process/time.rb

@@ -1,32 +0,0 @@
-module Dev
-  class TargetProcess
-    # The class to query time information from Target Process
-    class Time
-      # The resource type for the api endpoint
-      RESOURCE_TYPE = 'Time'.freeze
-
-      # The api path for time requests
-      PATH = '/Time'.freeze
-
-      attr_accessor :data, :id, :type, :description, :hours, :date, :story, :user
-
-      def initialize(data)
-        @data = data
-        @id = data['Id']
-        @type = data['ResourceType']
-        @description = data['Description']
-        @hours = data['Spent']
-        @date = parse_time(data['Date'])
-        @story = UserStory.new(data['Assignable']) if data['Assignable']
-        @user = User.new(data['User']) if data['User']
-      end
-
-      # Parse the dot net time representation into something that ruby can use
-      def parse_time(string)
-        return nil unless string && !string.empty?
-
-        ::Time.at(string.slice(6, 10).to_i)
-      end
-    end
-  end
-end