afterlife 1.0.0

data/lib/afterlife/deploy.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Afterlife
+  class Deploy
+    Error = Class.new StandardError
+
+    def self.call
+      new.deploy
+    end
+
+    def deploy
+      deployment_output.tap do
+        Exec.run(after_deploy_command) if after_deploy_command
+      end
+    rescue Exec::Error => e
+      raise Error, e
+    end
+
+  private
+
+    def deployment_output
+      case deployment_type
+      when 'cdn'
+        CdnDeployment.run
+      end
+    end
+
+    def deployment_type
+      repo.conf.dig(:deploy, :type).tap do |result|
+        fail Error, 'deploy.type must be defined if you want to deploy with Afterlife' unless result
+      end
+    end
+
+    def after_deploy_command
+      return if Afterlife.cli.options['skip-after-hooks']
+
+      repo.conf.dig(:deploy, :after)
+    end
+
+    def repo
+      Afterlife.current_repo
+    end
+  end
+end

data/lib/afterlife/environment.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Afterlife
+  class Environment
+    attr_reader :repo, :env
+
+    def self.from(repo)
+      env = new(repo).tap(&:call).env
+      yield env if block_given?
+      env
+    end
+
+    def initialize(repo)
+      @repo = repo
+      @env = {}
+    end
+
+    def call
+      from_flat_envs
+      from_branch_envs
+      from_stage_envs
+    end
+
+    def env_hash_by_branch
+      @env_hash_by_branch ||= env_hash&.dig(:by_branch, repo.current_branch.to_sym)
+    end
+
+    def env_hash_by_stage
+      @env_hash_by_stage ||= env_hash&.dig(:by_stage, Afterlife.current_stage.name.to_sym)
+    end
+
+    def env_hash
+      @env_hash ||= repo.conf.dig(:deploy, :env)
+    end
+
+  private
+
+    def from_flat_envs
+      return unless env_hash.is_a?(Hash)
+
+      env_hash.each do |key, value|
+        next if key == :by_branch
+        next if key == :by_stage
+
+        @env[key.to_s] = value.to_s
+      end
+    end
+
+    def from_branch_envs
+      return unless env_hash_by_branch.is_a?(Hash)
+
+      env_hash_by_branch.each do |key, value|
+        @env[key.to_s] = value.to_s
+      end
+    end
+
+    def from_stage_envs
+      return unless env_hash_by_stage.is_a?(Hash)
+
+      env_hash_by_stage.each do |key, value|
+        @env[key.to_s] = value.to_s
+      end
+    end
+  end
+end

data/lib/afterlife/exec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# adds String#squish and others
+require 'active_support/core_ext/string'
+
+module Afterlife
+  class Exec
+    Error = Class.new StandardError
+
+    def self.run(arg)
+      new(arg).run
+    end
+
+    def self.parse(arg, env)
+      Array(arg).map do |command|
+        format(command, env.symbolize_keys)
+      end
+    end
+
+    attr_reader :commands
+
+    def initialize(arg)
+      @commands = Array(arg)
+    end
+
+    def run
+      parsed_commands.each do |command|
+        Afterlife.cli.log_info(command) if Afterlife.cli.options['verbose']
+        system(repo.env, command.squish, exception: true) unless Afterlife.cli.options['dry-run']
+      end
+    rescue RuntimeError => e
+      raise Error, e
+    end
+
+    def parsed_commands
+      Exec.parse(commands, repo.env)
+    end
+
+    def repo
+      Afterlife.current_repo
+    end
+  end
+end

data/lib/afterlife/release/change_version.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'git'
+
+module Afterlife
+  module Release
+    class ChangeVersion
+      RUBY_REGEXP = /VERSION\s*=\s*['"]#{Bump::Semver::VERSION_REGEX}['"]/.freeze
+      REGEXPS = {
+        ruby: RUBY_REGEXP,
+        gem: RUBY_REGEXP,
+        node: /"version":\s*"#{Bump::Semver::VERSION_REGEX}"/,
+      }.freeze
+
+      def self.call(new_version)
+        Afterlife.current_repo.version_files.map do |file_def|
+          instance = new(new_version, file_def)
+          instance.call
+          instance.file_path
+        end
+      end
+
+      attr_reader :file_path, :regexp, :new_version
+
+      def initialize(new_version, options)
+        @file_path = options[:real_path]
+        @regexp = REGEXPS[options[:type].to_sym]
+        @new_version = new_version
+      end
+
+      def call
+        fail "could not find a version for #{file_path}" unless current_version
+
+        File.write(
+          file_path,
+          content.sub(current_version, new_version),
+        )
+      end
+
+      def current_version
+        content[regexp]
+        Regexp.last_match(1)
+      end
+
+      def content
+        @content ||= File.read(file_path)
+      end
+    end
+  end
+end

data/lib/afterlife/release/cli.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Afterlife
+  module Release
+    class Cli < Thor
+      include BaseCli
+
+      class_option :name,
+                   type: :string,
+                   aliases: '-n',
+                   desc: 'The name of the branch, the default depends on the action'
+      class_option :yes,
+                   type: :boolean,
+                   desc: 'Skip confirmation'
+      class_option :force,
+                   desc: 'Skip validations'
+      class_option :quiet, type: :boolean, group: :runtime
+
+      desc 'create <part>', 'creates a release branch based on the part (major|minor|patch)'
+      option :from,
+             type: :string,
+             aliases: '-f',
+             default: CreateHelper::DEFAULT_BASE_BRANCH,
+             desc: 'Base branch'
+      def create(part)
+        fatal! "Part '#{part}' is not allowed" unless CreateHelper::PARTS.include?(part.to_sym)
+
+        CreateHelper.call(self, options.merge(part: part))
+      end
+
+      desc 'hotfix', 'create a hotfix branch'
+      def hotfix
+        args = options.merge(part: :patch, from: :master, prefix: :hotfix)
+        CreateHelper.call(self, args)
+      end
+
+      desc 'pre', 'create a prerelease tag'
+      option :push, type: :boolean, default: true
+      def pre
+        PreHelper.call(self, options)
+      end
+    end
+  end
+end

data/lib/afterlife/release/create_helper.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'git'
+
+module Afterlife
+  module Release
+    class CreateHelper < Helper
+      DEFAULT_BASE_BRANCH = 'develop'
+      PARTS = %i[major minor patch].freeze
+
+      attr_reader :part, :branch_name, :from
+
+      def initialize(cli, args)
+        super
+        @part = args[:part]
+        @branch_name = [
+          args.fetch(:prefix, 'release'),
+          args.fetch(:name, "v#{new_version}"),
+        ].join('/')
+        @from = args.fetch(:from, DEFAULT_BASE_BRANCH)
+      end
+
+      def call
+        confirm_creation unless cli.options[:yes]
+        make_assertions unless cli.options[:force]
+        create_branch
+        ChangeVersion.call(new_version)
+        commit
+      end
+
+    private
+
+      def make_assertions
+        check_git_status
+        check_local_and_remote_on_same_commit
+      end
+
+      def check_git_status
+        cli.say_status 'Checking that there are no uncommitted changes...', nil
+        return cli.say 'OK' if `git status --porcelain --untracked-files no | wc -l`.to_i.zero?
+
+        cli.fatal! 'Working directory has changes, aborting...'
+      end
+
+      def check_local_and_remote_on_same_commit
+        cli.say_status 'Checking that local and remote are on the same commit...', nil
+        local = `git rev-parse #{from}`.chomp
+        remote = `git ls-remote '#{git.remotes.first.name}' '#{from}' | cut -f 1`.chomp
+        return cli.say 'OK' if local == remote
+
+        cli.fatal! 'Local and remote are not on the same commit'
+      end
+
+      def confirm_creation
+        cli.sure? 'You are about to create the branch ' \
+                  "#{cli.set_color(branch_name, :bold)} " \
+                  "from #{cli.set_color(from, :bold)}"
+      end
+
+      def create_branch
+        git.checkout(branch_name, new_branch: true, start_point: from)
+      end
+
+      def already_exists?
+        git.branches.map(&:name).include?(branch_name)
+      end
+
+      def commit
+        version_files = ChangeVersion.call(new_version)
+        version_files.each { |path| git.add(path) }
+        git.commit("bump v#{new_version}", no_verify: true)
+      end
+
+      def new_version
+        @new_version ||= Bump::Semver.calculate_next(part)
+      end
+    end
+  end
+end

data/lib/afterlife/release/helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Afterlife
+  module Release
+    class Helper
+      def self.call(cli, args)
+        new(cli, args).call
+      rescue Git::GitExecuteError => e
+        cli.fatal! e.message.chomp.split(':').last.strip
+      rescue Interrupt
+        cli.log_interrupted
+      end
+
+      attr_reader :cli
+
+      def initialize(cli, args)
+        args.compact!
+        @cli = cli
+      end
+
+      def git
+        @git ||= Git.open('.')
+      end
+    end
+  end
+end

data/lib/afterlife/release/pre_helper.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Afterlife
+  module Release
+    class PreHelper < Helper
+      def call
+        confirm_creation
+        check_tag_does_not_exist
+        commit
+        create_tag
+        push_tag if cli.options[:push]
+      end
+
+      def confirm_creation
+        return if cli.options[:yes]
+
+        cli.sure? 'You are about to create ' \
+                  "#{cli.options[:push] ? '(and push) ' : ''}" \
+                  "the tag #{cli.set_color(tag, :bold)} " \
+                  'in the current commit'
+      end
+
+      def check_tag_does_not_exist
+        tags = `git tag --list "#{tag}"`.chomp
+        cli.fatal! "tag #{tag} already exist" unless tags.split.empty?
+
+        `git ls-remote --tags --exit-code '#{git.remotes.first.name}' #{tag} >/dev/null 2>&1`
+        cli.fatal! "tag #{tag} already exist on remote" if $CHILD_STATUS.success?
+      end
+
+      def create_tag
+        git.add_tag(tag)
+      end
+
+      def push_tag
+        cli.say_status 'Publishing', tag
+        git.push(git.remote('origin'), tag)
+      end
+
+      def commit
+        version_files = ChangeVersion.call(new_version)
+        version_files.each { |path| git.add(path) }
+        git.commit("bump #{tag}", no_verify: true)
+      end
+
+      def tag
+        "v#{new_version}"
+      end
+
+      def new_version
+        @new_version ||= Bump::Semver.calculate_next(:pre, cli.options[:name])
+      end
+    end
+  end
+end

data/lib/afterlife/release.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Afterlife
+  module Release
+  end
+end

data/lib/afterlife/repo.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash'
+
+module Afterlife
+  class Repo
+    DEFAULT_DIST = 'dist'
+    DEFAULT_BUILD_COMMAND = 'yarn build'
+    DEFAULT_INSTALL = 'yarn install'
+    VERSION_FILES = [
+      {
+        type: :ruby,
+        blob: './config/application.rb',
+      }, {
+        type: :ruby,
+        blob: './lib/*/version.rb',
+      }, {
+        type: :node,
+        blob: './package.json',
+      },
+    ].freeze
+
+    def self.all
+      @all ||= Afterlife.config.repos[:cdnize]&.flat_map do |path|
+        repo = Repo.new(path)
+        packages = repo.conf.dig(:cdn, :packages)
+        next repo unless packages
+
+        packages.map do |package|
+          Repo.new("#{path}/packages/#{package}")
+        end
+      end
+    end
+
+    def self.base_path
+      @base_path ||= Pathname(Afterlife.config.repos[:path])
+    end
+
+    attr_reader :full_path
+
+    def initialize(path)
+      @full_path = path.start_with?('/') ? Pathname(path) : Repo.base_path.join(path)
+    end
+
+    def dist_path
+      full_path.join(conf.dig(:cdn, :dist) || DEFAULT_DIST)
+    end
+
+    def env
+      @env ||= Environment.from(self)
+    end
+
+    def install_dependencies_command
+      return DEFAULT_INSTALL unless conf.key?(:install)
+
+      conf[:install]
+    end
+
+    def build_command
+      return DEFAULT_BUILD_COMMAND unless conf.key?(:build)
+
+      conf[:build]
+    end
+
+    def confirmation_message
+      conf.dig(:deploy, :confirmation_message)
+    end
+
+    def current_branch
+      @current_branch ||= `git rev-parse --abbrev-ref HEAD`.chomp
+    end
+
+    def current_revision
+      @current_revision ||= `git rev-parse HEAD`.chomp
+    end
+
+    def name
+      full_name.split('/').last.gsub('-', '_')
+    end
+
+    def full_name
+      package_json[:name]
+    end
+
+    # Files that define versions
+    def version_files
+      @version_files ||= conf.dig(:release, :version_files)
+      @version_files ||= VERSION_FILES.map do |arg|
+        val = arg.dup
+        val[:real_path] = Dir[val[:blob]].first
+        next unless val[:real_path]
+
+        val
+      end.compact
+    end
+
+    def version
+      # this migth not be the same as the package.json
+      # Bump::Semver.version
+      package_json[:version]
+    end
+
+    def package_json
+      @pkg_path ||= conf.dig(:cdn, :package_json) || full_path.join('package.json')
+      @package_json ||= JSON.parse(File.read(@pkg_path), symbolize_names: true)
+    end
+
+    def branch_conf
+      conf.dig(:deploy, :env, :by_branch, current_branch.to_sym)
+    end
+
+    def conf
+      @conf ||= Config.new(full_path).config
+    end
+
+    class Config
+      CONFIG_NAME = '.afterlife.yml'
+
+      attr_reader :full_path
+
+      def initialize(full_path)
+        @full_path = full_path
+      end
+
+      def config
+        return @config if defined?(@config)
+
+        if config_file.exist?
+          @config = base_config
+          @config = parent.deep_merge(base_config) if parent
+        end
+
+        @config ||= {}
+      end
+
+    private
+
+      def parent
+        return @parent if defined?(@parent)
+
+        inherit_from = base_config.delete(:inherit_from)
+        return @parent = nil unless inherit_from
+
+        @parent = Config.new(full_path.join(inherit_from)).config
+        @parent[:cdn]&.delete(:packages)
+        @parent
+      end
+
+      def base_config
+        @base_config ||= YAML.load_file(config_file).deep_symbolize_keys
+      end
+
+      def config_file
+        @config_file ||= full_path.join(CONFIG_NAME)
+      end
+    end
+  end
+end

data/lib/afterlife/stage.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Afterlife
+  Stage = Struct.new(
+    :name,
+    :bucket,
+    :region,
+    :cdn_url,
+    keyword_init: true,
+  )
+end

data/lib/afterlife/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Afterlife
+  VERSION = '1.0.0'
+end

data/lib/afterlife.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+require 'git'
+require 'pry'
+require 'yaml'
+require 'pathname'
+require 'active_support'
+require_relative 'afterlife/version'
+
+module Afterlife
+  LOCAL_PATH = '~/.afterlife'
+
+  class Error < StandardError; end
+
+  def self.root
+    @root
+  end
+
+  def self.root=(other)
+    @root = other
+  end
+
+  def self.local_path
+    @local_path ||= Pathname(File.expand_path(LOCAL_PATH))
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.current_repo
+    @current_repo ||= Repo.new(Dir.pwd)
+  end
+
+  def self.current_stage=(other)
+    @current_stage = other
+  end
+
+  def self.current_stage
+    @current_stage
+  end
+
+  def self.cli=(other)
+    @cli = other
+  end
+
+  def self.cli
+    @cli
+  end
+end
+
+loader = Zeitwerk::Loader.for_gem
+loader.tag = 'afterlife'
+loader.setup
+loader.eager_load