capistrano-node-dotenv 1.0.0

data/lib/capistrano/node/dotenv/parser.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module Node
+    module Dotenv
+      module Parser
+        def parse_dotenv(content, stage_name)
+          global_env = {}
+          stage_env  = {}
+          current_section = :stage
+          markers_found = false
+
+          content.each_line do |line|
+            new_section, is_marker = resolve_section_marker(line.strip, stage_name)
+            if is_marker
+              current_section = new_section
+              markers_found = true
+              next
+            end
+
+            collect_dotenv_pair(line.strip, global_env, stage_env, current_section, markers_found)
+          end
+
+          build_dotenv_result(global_env, stage_env, stage_name)
+        end
+
+        def resolve_section_marker(stripped, stage_name)
+          return [:global, true] if stripped.match?(/\A#\s*Begin\s+global\s+envs\b/i)
+          return [nil, true]     if stripped.match?(/\A#\s*End\s+global\s+envs\b/i)
+          return [nil, true]     if stripped.match?(/\A#\s*End\s+.+?\s+envs\b/i)
+
+          stage_begin = stripped.match(/\A#\s*Begin\s+(.+?)\s+envs\b/i)
+          if stage_begin
+            section = stage_begin[1].strip.casecmp(stage_name.to_s).zero? ? :stage : nil
+            return [section, true]
+          end
+
+          [nil, false]
+        end
+
+        def collect_dotenv_pair(stripped, global_env, stage_env, current_section, markers_found)
+          parsed_line = parse_dotenv_line(stripped)
+          return unless parsed_line
+
+          key, value = parsed_line
+          if markers_found
+            global_env[key] = value if current_section == :global
+            stage_env[key]  = value if current_section == :stage
+          else
+            stage_env[key] = value
+          end
+        end
+
+        def build_dotenv_result(global_env, stage_env, stage_name)
+          global_env.sort.to_h.merge(stage_name.to_s => stage_env.sort.to_h)
+        end
+
+        def parse_dotenv_line(line)
+          return nil if line.empty? || line.start_with?('#')
+
+          stripped = line.sub(/\Aexport\s+/, '')
+          key, raw_value = stripped.split('=', 2)
+          return nil if key.nil? || raw_value.nil?
+
+          parsed_key = key.strip
+          value = raw_value.strip
+
+          if value.start_with?('"') && value.end_with?('"')
+            value = value[1..-2]
+            value = value.gsub('\\n', "\n").gsub('\\"', '"').gsub('\\\\', '\\')
+          elsif value.start_with?("'") && value.end_with?("'")
+            value = value[1..-2]
+          else
+            value = value.sub(/\s+#.*\z/, '').strip
+          end
+
+          [parsed_key, value]
+        end
+
+        def generate_dotenv_content(global_env_hash, env_hash)
+          date = Time.now.strftime('%Y-%m-%d %H:%M:%S')
+          global_start = "# Begin global envs #{date}\n"
+          global_end = "# End global envs #{date}\n"
+          stage_start = "# Begin #{fetch(:dotenv_env) || fetch(:stage)} envs #{date}\n"
+          stage_end = "# End #{fetch(:dotenv_env) || fetch(:stage)} envs #{date}\n"
+
+          content = global_start
+          global_env_hash.each do |key, value|
+            content += "#{key}=#{value}\n"
+          end
+          content += global_end
+          content += stage_start
+          env_hash.each do |key, value|
+            content += "#{key}=#{value}\n"
+          end
+          content += stage_end
+          content
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/node/dotenv/paths.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Capistrano
+  module Node
+    module Dotenv
+      module Paths
+        def dotenv_local_path
+          Pathname.new fetch(:dotenv_local_path)
+        end
+
+        def dotenv_remote_path
+          shared_path.join fetch(:dotenv_remote_path)
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/node/dotenv/tasks/backup.rake

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+namespace :dotenv do
+  include Capistrano::Node::Dotenv::Paths
+  include Capistrano::Node::Dotenv::Helpers
+  desc 'Backup remote .env file'
+  task :backup do
+    on release_roles :all do
+      unless remote_file_exists?
+        puts 'No remote .env file to backup.'
+        next
+      end
+
+      begin
+        puts 'Creating backup of remote .env file...'
+        create_remote_backup
+        puts 'Backup created successfully.'
+
+        puts 'Cleaning up remote backups...'
+        cleanup_remote_backups
+        puts 'Remote backups cleaned up successfully.'
+      rescue StandardError => e
+        puts "Error during backup process: #{e.message}"
+      end
+    end
+  end
+end

data/lib/capistrano/node/dotenv/tasks/check.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :dotenv do
+  include Capistrano::Node::Dotenv::Paths
+  include Capistrano::Node::Dotenv::Helpers
+  desc 'dotenv `application.yml` file checks'
+  task :check do
+    invoke 'dotenv:check_dotenv_file_exists'
+    invoke 'dotenv:check_git_tracking'
+    invoke 'dotenv:check_config_present'
+  end
+end

data/lib/capistrano/node/dotenv/tasks/check_config_present.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :dotenv do
+  include Capistrano::Node::Dotenv::Paths
+  include Capistrano::Node::Dotenv::Helpers
+  task :check_config_present do
+    next unless local_dotenv(dotenv_env).empty?
+
+    check_config_present_error
+    exit 1
+  end
+end

data/lib/capistrano/node/dotenv/tasks/check_dotenv_file_exists.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :dotenv do
+  include Capistrano::Node::Dotenv::Paths
+  include Capistrano::Node::Dotenv::Helpers
+  task :check_dotenv_file_exists do
+    next if File.exist?(dotenv_local_path)
+
+    check_dotenv_file_exists_error
+    exit 1
+  end
+end

data/lib/capistrano/node/dotenv/tasks/check_git_tracking.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :dotenv do
+  include Capistrano::Node::Dotenv::Paths
+  include Capistrano::Node::Dotenv::Helpers
+  task :check_git_tracking do
+    next unless system("git ls-files #{fetch(:dotenv_local_path)} --error-unmatch >/dev/null 2>&1")
+
+    check_git_tracking_error
+    exit 1
+  end
+end

data/lib/capistrano/node/dotenv/tasks/create_local.rake

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+namespace :dotenv do
+  include Capistrano::Node::Dotenv::Paths
+  include Capistrano::Node::Dotenv::Helpers
+  include Capistrano::Node::Dotenv::Parser
+
+  task :create_local do
+    run_locally do
+      puts "found #{stages.count} stages"
+      yamls_combined = {}
+      empty_stages = {}
+      stages.each do |f|
+        stage = File.basename(f, '.rb')
+        puts "download #{stage} .env"
+        begin
+          res = capture "cap #{stage} dotenv:get_stage"
+          yamls_combined.merge!(parse_dotenv(res, stage))
+        rescue StandardError
+          yamls_combined.merge!(stage => { 'KEY' => 'VALUE' }) # add empty stage to combined yml to avoid losing data from other stages
+          empty_stages.merge!(stage => { "#{stage.upcase}_KEY" => 'VALUE' })
+          puts "could not get #{stage} .env"
+        end
+      end
+
+      if empty_stages.count == stages.count
+        puts "no .env files found for any stage. creating empty local env file with all stages: #{empty_stages.keys.join(', ')}"
+        yamls_combined.merge!({ 'GLOBAL' => 'VALUE' })
+        yamls_combined.merge!(empty_stages)
+        puts yamls_combined.sort.to_h.to_yaml
+      end
+      write_combined_yaml(yamls_combined.sort.to_h)
+    end
+  end
+  desc 'Initializes local env file (config/application.yml)'
+  task init: :create_local
+end

data/lib/capistrano/node/dotenv/tasks/dotenv_symlink.rake

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+namespace :dotenv do
+  include Capistrano::Node::Dotenv::Paths
+  include Capistrano::Node::Dotenv::Helpers
+  task :dotenv_symlink do
+    set :linked_files, fetch(:linked_files, []).push(fetch(:dotenv_remote_path))
+  end
+  after 'deploy:started', 'dotenv:dotenv_symlink'
+end

data/lib/capistrano/node/dotenv/tasks/get.rake

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+namespace :dotenv do
+  include Capistrano::Node::Dotenv::Paths
+  include Capistrano::Node::Dotenv::Helpers
+  desc 'Compares the remote .env file with the local one and allows to update the local file with remote values'
+  task :get do
+    if File.exist?(dotenv_local_path)
+      local_yml = local_dotenv(dotenv_env)
+      local_global_env, local_stage_env, local_rest = configs(local_yml, dotenv_env)
+      on release_roles :all do
+        unless remote_file_exists?
+          puts 'Remote .env file does not exist. Nothing to get.'
+          exit
+        end
+        remote = parse_dotenv(capture("cat #{dotenv_remote_path}"), dotenv_env)
+        remote_global_env, remote_stage_env, _remote_rest = configs(remote, dotenv_env)
+
+        differences_global = compare_hashes(remote_global_env, local_global_env || {})
+        differences_stage = compare_hashes(remote_stage_env, local_stage_env || {})
+        print_changes(differences_global,
+                      'Remote env file has extra/different global entries compared to local.')
+        if differences_stage
+          print_changes(differences_stage,
+                        "Remote env file has extra/different entries in #{dotenv_env} section compared to local.")
+        end
+        puts 'No Differences found between remote and local env file' unless differences_global || differences_stage
+
+        #   puts 'No Differences found between remote and local application.yml' unless differences_global || differences_stage
+
+        #   # ask to overwrite local yml if differences found
+        stage_overwrite_local = ask_to_overwrite("Overwrite local env file #{dotenv_env} section") if differences_stage
+        global_overwrite_local = ask_to_overwrite('Overwrite local env file globals') if differences_global
+        puts 'Nothing written to local env file' unless stage_overwrite_local || global_overwrite_local
+        exit unless stage_overwrite_local || global_overwrite_local
+        #   stage_overwrite = ask_to_overwrite("Overwrite local application.yml #{figaro_yml_env} section") if differences_stage
+        #   global_overwrite = ask_to_overwrite('Overwrite local application.yml globals') if differences_global
+        #   puts 'Nothing written to local application.yml' unless stage_overwrite || global_overwrite
+        #   exit unless stage_overwrite || global_overwrite
+        # compose new yml
+
+        composed_yml = {}
+        composed_yml.merge!(local_rest) # local yml is always included to avoid losing any data
+        composed_yml.merge!(local_global_env) unless global_overwrite_local
+        composed_yml.merge!(remote_global_env) if global_overwrite_local
+        composed_yml[dotenv_env.to_s] = stage_overwrite_local ? remote_stage_env : local_stage_env
+        puts composed_yml.to_yaml
+        #   # write to new file
+        write_combined_yaml(composed_yml.sort.to_h)
+      end
+    else
+      invoke 'dotenv:create_local'
+    end
+  end
+end

data/lib/capistrano/node/dotenv/tasks/get_stage.rake

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+namespace :dotenv do
+  include Capistrano::Node::Dotenv::Paths
+  include Capistrano::Node::Dotenv::Helpers
+
+  rake_roles = fetch(:rake_roles, :app)
+  task :get_stage do
+    on roles(rake_roles) do
+      raise 'The file does not exist.' unless remote_file_exists?
+
+      puts capture "cat #{dotenv_remote_path}"
+    end
+  end
+
+  desc 'shows the content of the remote .env file for the current stage'
+  task show: :get_stage
+end

data/lib/capistrano/node/dotenv/tasks/load.rake

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+namespace :load do
+  task :defaults do
+    set :dotenv_local_path, 'config/application.yml'
+    set :dotenv_remote_path, '.env'
+    set :dotenv_env, -> { fetch(:node_env) || fetch(:stage) }
+    set :dotenv_remote_backup, false
+  end
+end

data/lib/capistrano/node/dotenv/tasks/rollback.rake

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+namespace :dotenv do
+  include Capistrano::Node::Dotenv::Paths
+  include Capistrano::Node::Dotenv::Helpers
+  desc 'Rolls back the remote .env file to the previous version if a backup exists'
+  task :rollback do
+    on release_roles :all do
+      unless remote_backup_exists?
+        puts 'No backup of remote .env file to rollback.'
+        next
+      end
+
+      begin
+        puts 'Rolling back remote .env file...'
+        rollback_remote_backup
+        puts 'Rollback completed successfully.'
+      rescue StandardError => e
+        puts "Error during rollback process: #{e.message}"
+      end
+    end
+  end
+end

data/lib/capistrano/node/dotenv/tasks/setup.rake

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+namespace :dotenv do
+  include Capistrano::Node::Dotenv::Paths
+  include Capistrano::Node::Dotenv::Helpers
+  include Capistrano::Node::Dotenv::Parser
+  desc 'Uploads the local env file to the server and saves it in the shared folder. This task is used to set up the remote .env file for the first time or to update it with local values. It will overwrite the remote .env file if it already exists.'
+  task :setup do
+    content = local_dotenv(dotenv_env)
+
+    on release_roles :all do
+      global_yml, stage_yml, _other_stages_yml = configs(content, dotenv_env)
+      dotenv_string = generate_dotenv_content(global_yml, stage_yml)
+
+      execute :mkdir, '-pv', File.dirname(dotenv_remote_path)
+      upload! StringIO.new(dotenv_string), dotenv_remote_path
+    end
+  end
+end

data/lib/capistrano/node/dotenv/tasks/update.rake

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+namespace :dotenv do
+  include Capistrano::Node::Dotenv::Paths
+  include Capistrano::Node::Dotenv::Helpers
+  include Capistrano::Node::Dotenv::Parser
+  desc 'Compares the remote .env file with the local one and allows to update the remote file with local values'
+  task :update do
+    local = local_dotenv(dotenv_env)
+    local_global_env, local_stage_env, _local_rest = configs(local, dotenv_env)
+    on release_roles :all do
+      remote = parse_dotenv(capture("cat #{dotenv_remote_path}"), fetch(:dotenv_env))
+      remote_global_env, remote_stage_env, _remote_rest = configs(remote, dotenv_env)
+      # Compare hashes and handle nil results with empty hashes
+      differences_global = compare_hashes(local_global_env, remote_global_env)
+      differences_stage = compare_hashes(local_stage_env, remote_stage_env)
+
+      print_changes(differences_global, 'Local application.yml has extra/different global entries compared to remote.')
+      if differences_stage
+        print_changes(differences_stage, "Local application.yml has extra/different entries in #{dotenv_env} section compared to remote.")
+      end
+
+      puts 'No Differences found between remote and local application.yml' unless differences_global || differences_stage
+
+      stage_overwrite_remote = ask_to_overwrite("Overwrite remote #{dotenv_env} section") if differences_stage
+      global_overwrite_remote = ask_to_overwrite('Overwrite remote globals') if differences_global
+
+      puts 'Nothing written to remote application.yml' unless stage_overwrite_remote || global_overwrite_remote
+      exit unless stage_overwrite_remote || global_overwrite_remote
+      global_yaml = global_overwrite_remote ? local_global_env : remote_global_env
+      stage_yaml = stage_overwrite_remote ? local_stage_env : remote_stage_env
+      # write to new file
+      dotenv_string = generate_dotenv_content(global_yaml, stage_yaml)
+
+      invoke 'dotenv:backup'
+      # execute :mkdir, '-pv', File.dirname(dotenv_remote_path)
+      upload! StringIO.new(dotenv_string), dotenv_remote_path
+    end
+  end
+  # before 'dotenv:update', 'dotenv:backup'
+end

data/lib/capistrano/node/dotenv/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module Node
+    module Dotenv
+      VERSION = '1.0.0'
+    end
+  end
+end

data/lib/capistrano/node/dotenv.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Capistrano
+  module Node
+    module Dotenv
+      require 'capistrano/node/dotenv/paths'
+      require 'capistrano/node/dotenv/helpers'
+      require 'capistrano/node/dotenv/parser'
+
+      def self.path
+        Dir.pwd
+      end
+      task_files = Dir.glob("#{File.expand_path(__dir__)}/dotenv/tasks/**/*.rake")
+      task_files.each do |file|
+        load file
+      rescue StandardError => e
+        puts "Failed to load #{file}: #{e.message}"
+      end
+    end
+  end
+end

data/scripts/bump_version.rb

@@ -0,0 +1,172 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Version management script for Capistrano Node Dotenv Gem
+# Usage: ruby scripts/bump_version.rb [patch|minor|major]
+
+require 'fileutils'
+require_relative '../lib/capistrano/node/dotenv/version'
+
+class VersionBumper
+  VALID_TYPES = %w[patch minor major].freeze
+  VERSION_FILE = 'lib/capistrano/node/dotenv/version.rb'
+  CHANGELOG_FILE = 'CHANGELOG.md'
+
+  def initialize(bump_type)
+    @bump_type = bump_type.to_s.downcase
+    @current_version = Capistrano::Node::Dotenv::VERSION
+    validate_bump_type!
+  end
+
+  def bump!
+    puts "Current version: #{@current_version}"
+
+    new_version = calculate_new_version
+    puts "New version: #{new_version}"
+
+    # Update version file
+    update_version_file(new_version)
+
+    # Update changelog
+    update_changelog(new_version)
+
+    # Create git commit
+    create_git_commit(new_version) if git_available?
+
+    puts 'Version bumped successfully!'
+    puts ''
+    puts '📋 Next steps:'
+    puts '1. Review the changes (git diff)'
+    puts '2. Fill in CHANGELOG.md with actual changes'
+    puts '3. Commit and tag:'
+    puts "   git add #{VERSION_FILE} #{CHANGELOG_FILE}"
+    puts "   git commit -m 'Release version #{new_version}'"
+    puts "   git tag -a v#{new_version} -m 'Release version #{new_version}'"
+    puts '4. Push to GitHub:'
+    puts "   git push origin main && git push origin v#{new_version}"
+    puts '5. Create GitHub Release:'
+    puts "   gh release create v#{new_version} --title 'v#{new_version}' \\"
+    puts "     --notes-file <(sed -n '/## \\[#{new_version}\\]/,/## \\[/p' CHANGELOG.md | sed '$d')"
+    puts ''
+    puts '→ GitHub Actions will automatically publish to RubyGems.org! 🚀'
+  end
+
+  private
+
+  def validate_bump_type!
+    return if VALID_TYPES.include?(@bump_type)
+
+    puts "Error: Invalid bump type '#{@bump_type}'"
+    puts "Valid types: #{VALID_TYPES.join(', ')}"
+    exit 1
+  end
+
+  def calculate_new_version
+    parts = @current_version.split('.').map(&:to_i)
+
+    case @bump_type
+    when 'patch'
+      parts[2] += 1
+    when 'minor'
+      parts[1] += 1
+      parts[2] = 0
+    when 'major'
+      parts[0] += 1
+      parts[1] = 0
+      parts[2] = 0
+    end
+
+    parts.join('.')
+  end
+
+  def update_version_file(new_version)
+    puts "Updating #{VERSION_FILE}..."
+
+    content = File.read(VERSION_FILE)
+    updated_content = content.gsub(
+      /VERSION = ['"][^'"]*['"]/,
+      "VERSION = '#{new_version}'"
+    )
+
+    File.write(VERSION_FILE, updated_content)
+    puts '✓ Version file updated'
+  end
+
+  def update_changelog(new_version)
+    return unless File.exist?(CHANGELOG_FILE)
+
+    puts "Updating #{CHANGELOG_FILE}..."
+
+    # Read existing changelog
+    content = File.read(CHANGELOG_FILE)
+
+    # Find the [Unreleased] section and replace it
+    lines = content.lines
+
+    today = Time.now.strftime('%Y-%m-%d')
+
+    # Replace [Unreleased] header with new version
+    unreleased_index = lines.find_index { |line| line.start_with?('## [Unreleased]') }
+
+    if unreleased_index
+      # Create new version entry
+      new_entry = [
+        "## [Unreleased]\n",
+        "\n",
+        "## [#{new_version}] - #{today}\n"
+      ]
+
+      # Replace [Unreleased] line
+      lines[unreleased_index] = new_entry.join
+
+      # Update comparison links at the bottom
+      # Find and update the [Unreleased] link
+      unreleased_link_index = lines.rindex { |line| line.start_with?('[Unreleased]:') }
+      if unreleased_link_index
+        # Update [Unreleased] to compare from new version to HEAD
+        lines[unreleased_link_index] = "[Unreleased]: https://github.com/zauberware/capistrano-node-dotenv/compare/v#{new_version}...HEAD\n"
+        # Add new version link
+        lines.insert(unreleased_link_index + 1, "[#{new_version}]: https://github.com/zauberware/capistrano-node-dotenv/releases/tag/v#{new_version}\n")
+      end
+    end
+
+    # Write back to file
+    File.write(CHANGELOG_FILE, lines.join)
+    puts '✓ Changelog updated (please fill in the release notes under the new version)'
+  end
+
+  def git_available?
+    system('git --version > /dev/null 2>&1')
+  end
+
+  def create_git_commit(new_version)
+    puts 'Creating git commit...'
+
+    # Add modified files
+    system("git add #{VERSION_FILE}")
+    system("git add #{CHANGELOG_FILE}") if File.exist?(CHANGELOG_FILE)
+
+    # Create commit
+    commit_message = "Bump version to #{new_version}"
+    if system("git commit -m '#{commit_message}'")
+      puts "✓ Git commit created: #{commit_message}"
+    else
+      puts '⚠ Failed to create git commit (you may need to commit manually)'
+    end
+  end
+end
+
+# Main execution
+if ARGV.empty?
+  puts "Usage: #{$PROGRAM_NAME} [patch|minor|major]"
+  puts ''
+  puts 'Examples:'
+  puts "  #{$PROGRAM_NAME} patch   # 1.0.0 -> 1.0.1"
+  puts "  #{$PROGRAM_NAME} minor   # 1.0.0 -> 1.1.0"
+  puts "  #{$PROGRAM_NAME} major   # 1.0.0 -> 2.0.0"
+  exit 1
+end
+
+bump_type = ARGV[0]
+bumper = VersionBumper.new(bump_type)
+bumper.bump!