firespring_dev_commands 2.2.6 → 2.5.0.pre.alpha.1

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/dns/resource.rb

@@ -1,83 +0,0 @@
-module Dev
-  class Dns
-    class Resource
-      attr_reader :domain
-
-      def initialize(domain)
-        @domain = domain
-      end
-
-      # Returns whether or not the given value is a valid IPv4 or IPv6 address
-      def self.ip?(value)
-        ipv4?(value) || ipv6?(value)
-      end
-
-      # Returns whether or not the given value is a valid IPv4 address
-      def self.ipv4?(value)
-        value.match?(Resolv::IPv4::Regex)
-      end
-
-      # Returns whether or not the given value is a valid IPv6 address
-      def self.ipv6?(value)
-        value.match?(Resolv::IPv6::Regex)
-      end
-
-      # Recursively determine the correct nameservers for the given domain.
-      # If nameservers are not found, strip subdomains off until we've reached the TLD
-      def recursive_nameserver_lookup(name = domain)
-        records = lookup(name, type: Resolv::DNS::Resource::IN::NS)
-
-        # Strip the subdomain and try again if we didn't find any nameservers (this can happen with wildcards)
-        return recursive_nameserver_lookup(name.split('.', 2).last) if records.empty?
-
-        # Look up the IPs for the nameservers
-        records
-      end
-
-      # Recursively attempt to find an A record for the given domain.
-      # If one isn't found, also check for CNAMEs continually until we have either found an IP or run out of things to check
-      def recursive_a_lookup(name = domain)
-        # Try looking up an A record first. If we find one, we are done.
-        records = lookup(name, type: Resolv::DNS::Resource::IN::A)
-        return records unless records.empty?
-
-        # Try looking up a CNAME record
-        records = lookup(name, type: Resolv::DNS::Resource::IN::CNAME)
-
-        # If we didn't find an A record _or_ a CNAME, just return empty
-        return records if records.empty?
-
-        # If we found more than one CNAME that is a DNS error
-        raise "Found more than one CNAME entry for #{name}. This is not allowed by DNS" if records.length > 1
-
-        recursive_a_lookup(records.first)
-      end
-
-      # Lookup the given name using the record type provided.
-      def lookup(name = domain, type: Resolv::DNS::Resource::IN::A)
-        # Validate the type
-        raise 'lookup type must be a Resolv::DNS::Resource' unless type.ancestors.include?(Resolv::DNS::Resource)
-
-        # If we were given a tld, return empty
-        return [] unless name.include?('.')
-
-        # Look up NS records for the given host
-        records = Resolv::DNS.new.getresources(name, type)
-
-        # Return the record names
-        records.map do |record|
-          if record.respond_to?(:address)
-            record.address.to_s
-          elsif record.respond_to?(:name)
-            record.name.to_s
-          else
-            ''
-          end
-        end
-      rescue
-        sleep(1)
-        retry
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/docker/desktop.rb

@@ -1,61 +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
-          context = Dev::Common.new.run_command(
-            "docker context inspect --format '{{.Endpoints.docker.Host}}'",
-            capture: true
-          ).to_s.strip
-          raise 'context is empty' unless context
-
-          # If a user based socket has been defined, default to that
-          ::Docker.url = context
-        end
-      end
-    end
-  end
-end

data/lib/firespring_dev_commands/eol/node.rb

@@ -1,42 +0,0 @@
-module Dev
-  class EndOfLife
-    # Class which checks for eol packges referenced by the node package manager
-    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
-
-      # Default to NPM products
-      def default_products
-        npm_products
-      end
-
-      # 1.) Parse the npm lock file
-      # 2.) Do some package name and version manipulation
-      # 3.) Return the product if it looks like something that the EOL library tracks
-      def npm_products
-        eol = Dev::EndOfLife.new
-        major_version_only_products = %w(ckeditor 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,50 +0,0 @@
-module Dev
-  class EndOfLife
-    # Class which checks for eol packges referenced by the php package manager
-    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
-
-      # Default to Composer products
-      def default_products
-        composer_products
-      end
-
-      # 1.) Parse the composer lock file
-      # 2.) Do some package name and version manipulation
-      # 3.) Return the product if it looks like something that the EOL library tracks
-      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,42 +0,0 @@
-module Dev
-  class EndOfLife
-    # Class which checks for eol packges referenced by the ruby package manager
-    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
-
-      # Default to Rubygems products
-      def default_products
-        rubygems_products
-      end
-
-      # 1.) Parse the rubygems lock file
-      # 2.) Do some package name and version manipulation
-      # 3.) Return the product if it looks like something that the EOL library tracks
-      def rubygems_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