semverve 0.1.0

data/lib/semverve/generator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+require_relative "error"
+require_relative "formats"
+require_relative "semantic_version"
+
+module Semverve
+  ##
+  # Generates new Ruby version files from Semverve configuration.
+  class Generator
+    ##
+    # Default version used when +VERSION+ is not provided.
+    #
+    # @return [String]
+    DEFAULT_VERSION = "0.1.0"
+
+    ##
+    # Initializes a version-file generator.
+    #
+    # @param [Semverve::ResolvedConfiguration] configuration
+    # @param [#fetch] env
+    #
+    # @return [Semverve::Generator]
+    def initialize(configuration, env = ENV)
+      @configuration = configuration
+      @env = env
+    end
+
+    ##
+    # Generates the configured version file.
+    #
+    # @return [String]
+    def generate
+      version = SemanticVersion.parse(env.fetch("VERSION", DEFAULT_VERSION))
+      format = Formats.fetch(env.fetch("FORMAT", configuration.format))
+      path = configuration.absolute_version_file
+
+      if File.exist?(path) && !force?
+        raise Error, "Version file already exists at #{path}. Set FORCE=true to overwrite it."
+      end
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, format.generate(version, module_name: configuration.module_name))
+
+      path
+    end
+
+    private
+
+    ##
+    # Resolved configuration used for generation.
+    #
+    # @return [Semverve::ResolvedConfiguration]
+    attr_reader :configuration, :env
+
+    ##
+    # Whether generation should overwrite an existing version file.
+    #
+    # @return [Boolean]
+    def force?
+      env.fetch("FORCE", "false").match?(/\A(true|1|yes)\z/i)
+    end
+  end
+end

data/lib/semverve/presets.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "error"
+
+module Semverve
+  ##
+  # Framework-specific default configuration adapters.
+  module Presets
+    ##
+    # Returns defaults for a configured preset.
+    #
+    # @param [Symbol, String, nil] name
+    # @param [Semverve::Configuration] configuration
+    #
+    # @return [Hash]
+    def self.defaults_for(name, configuration)
+      return {} unless name
+
+      fetch(name).defaults(configuration)
+    end
+
+    ##
+    # Returns a preset adapter.
+    #
+    # @param [Symbol, String] name
+    #
+    # @return [#name, #defaults]
+    def self.fetch(name)
+      case name.to_sym
+      when :rails
+        Rails.new
+      else
+        raise Error, "Unknown preset #{name.inspect}. Use :rails."
+      end
+    end
+
+    ##
+    # Rails application defaults.
+    class Rails
+      ##
+      # Preset name.
+      #
+      # @return [Symbol]
+      def name
+        :rails
+      end
+
+      ##
+      # Rails-specific Semverve defaults.
+      #
+      # @param [Semverve::Configuration] _configuration
+      #
+      # @return [Hash]
+      def defaults(_configuration)
+        root = rails_root || Dir.pwd
+
+        {
+          format: :simple,
+          module_name: rails_module_name || project_module_name(root),
+          root: root,
+          version_file: File.join("config", "version.rb")
+        }
+      end
+
+      private
+
+      ##
+      # Rails.root when Rails is available.
+      #
+      # @return [String, nil]
+      def rails_root
+        return unless rails_defined?
+        return unless ::Rails.respond_to?(:root)
+        return unless ::Rails.root
+
+        ::Rails.root.to_s
+      end
+
+      ##
+      # Application module name inferred from Rails.application.
+      #
+      # @return [String, nil]
+      def rails_module_name
+        return unless rails_defined?
+        return unless ::Rails.respond_to?(:application)
+        return unless ::Rails.application
+
+        application_class = ::Rails.application.class
+        return application_class.module_parent_name if application_class.respond_to?(:module_parent_name)
+
+        class_name = application_class.name
+        return unless class_name&.include?("::")
+
+        class_name.split("::").first
+      end
+
+      ##
+      # Module name fallback based on the project directory.
+      #
+      # @param [String] root
+      #
+      # @return [String]
+      def project_module_name(root)
+        camelize(File.basename(File.expand_path(root)))
+      end
+
+      ##
+      # Whether Rails is loaded.
+      #
+      # @return [Boolean]
+      def rails_defined?
+        Object.const_defined?(:Rails)
+      end
+
+      ##
+      # Converts a project directory into a Ruby module name.
+      #
+      # @param [String] value
+      #
+      # @return [String]
+      def camelize(value)
+        value.split(/[_-]/).map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/semverve/project_metadata.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "error"
+
+module Semverve
+  ##
+  # Infers gem metadata from explicit configuration or project files.
+  class ProjectMetadata
+    ##
+    # Initializes project metadata inference.
+    #
+    # @param [Semverve::Configuration] configuration
+    #
+    # @return [Semverve::ProjectMetadata]
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    ##
+    # Gem name from explicit config, the version-file path, or the gemspec.
+    #
+    # @return [String]
+    def gem_name
+      explicit_gem_name || configured_version_file_gem_name || gemspec_name
+    end
+
+    ##
+    # Ruby module name from explicit config or the resolved gem name.
+    #
+    # @return [String]
+    def module_name
+      explicit_module_name || configured_module_name || camelize(gem_name)
+    end
+
+    ##
+    # Version-file path from explicit config or the resolved gem name.
+    #
+    # @return [String]
+    def version_file
+      configured_version_file || File.join("lib", gem_name, "version.rb")
+    end
+
+    private
+
+    ##
+    # Configuration used for metadata inference.
+    #
+    # @return [Semverve::Configuration]
+    attr_reader :configuration
+
+    ##
+    # Explicitly configured gem name.
+    #
+    # @return [String, nil]
+    def explicit_gem_name
+      configuration.gem_name
+    end
+
+    ##
+    # Configured gem name after applying presets.
+    #
+    # @return [String, nil]
+    def configured_gem_name
+      configuration.resolved_value(:gem_name)
+    end
+
+    ##
+    # Explicitly configured Ruby module name.
+    #
+    # @return [String, nil]
+    def explicit_module_name
+      configuration.module_name
+    end
+
+    ##
+    # Configured Ruby module name after applying presets.
+    #
+    # @return [String, nil]
+    def configured_module_name
+      configuration.resolved_value(:module_name)
+    end
+
+    ##
+    # Configured version-file path after applying presets.
+    #
+    # @return [String, nil]
+    def configured_version_file
+      configuration.resolved_value(:version_file)
+    end
+
+    ##
+    # Gem name inferred from the parent directory of the configured version file.
+    #
+    # @return [String, nil]
+    def configured_version_file_gem_name
+      return configured_gem_name if configured_gem_name
+      return unless configured_version_file
+
+      File.basename(File.dirname(configured_version_file))
+    end
+
+    ##
+    # Gem name extracted from the single gemspec in the project root.
+    #
+    # @return [String]
+    def gemspec_name
+      gemspec_file.then { |file| extract_name(file) }
+    end
+
+    ##
+    # Single gemspec file in the configured project root.
+    #
+    # @return [String]
+    def gemspec_file
+      files = Dir.glob(File.join(configuration.expanded_root, "*.gemspec"))
+
+      return files.first if files.one?
+
+      if files.empty?
+        raise Error, "Could not infer gem name because no .gemspec file was found. " \
+          "Set config.gem_name or config.version_file."
+      end
+
+      raise Error, "Could not infer gem name because multiple .gemspec files were found. " \
+        "Set config.gem_name or config.version_file."
+    end
+
+    ##
+    # Reads a gemspec and extracts its +spec.name+ assignment.
+    #
+    # @param [String] file
+    #
+    # @return [String]
+    def extract_name(file)
+      content = File.read(file)
+      match = content.match(/^\s*\w+\.name\s*=\s*["']([^"']+)["']/)
+
+      return match[1] if match
+
+      raise Error, "Could not infer gem name from #{file}. Set config.gem_name."
+    end
+
+    ##
+    # Converts a snake-case or kebab-case gem name into a Ruby module name.
+    #
+    # @param [String] value
+    #
+    # @return [String]
+    def camelize(value)
+      value.split(/[_-]/).map(&:capitalize).join
+    end
+  end
+end

data/lib/semverve/railtie.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../semverve"
+
+module Semverve
+  ##
+  # Rails integration for installing Semverve's Rake tasks.
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      Semverve.configuration.preset = :rails unless Semverve.configuration.preset
+
+      require_relative "task"
+      Semverve::Task.install
+    end
+  end
+end

data/lib/semverve/semantic_version.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "error"
+
+module Semverve
+  ##
+  # Value object for a MAJOR.MINOR.PATCH semantic version.
+  class SemanticVersion
+    include Comparable
+
+    ##
+    # Regular expression for Semverve's supported version format.
+    #
+    # @return [Regexp]
+    PATTERN = /\A(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)\z/
+
+    ##
+    # Major version number.
+    #
+    # @return [Integer]
+    attr_reader :major
+
+    ##
+    # Minor version number.
+    #
+    # @return [Integer]
+    attr_reader :minor
+
+    ##
+    # Patch version number.
+    #
+    # @return [Integer]
+    attr_reader :patch
+
+    ##
+    # Parses a value into a semantic version.
+    #
+    # @param [#to_s] value
+    #
+    # @return [Semverve::SemanticVersion]
+    def self.parse(value)
+      match = value.to_s.match(PATTERN)
+
+      unless match
+        raise Error, "Expected a semantic version in MAJOR.MINOR.PATCH format, got #{value.inspect}."
+      end
+
+      new(
+        major: match[:major].to_i,
+        minor: match[:minor].to_i,
+        patch: match[:patch].to_i
+      )
+    end
+
+    ##
+    # Initializes a semantic version.
+    #
+    # @param [Integer] major
+    # @param [Integer] minor
+    # @param [Integer] patch
+    #
+    # @return [Semverve::SemanticVersion]
+    def initialize(major:, minor:, patch:)
+      @major = major
+      @minor = minor
+      @patch = patch
+    end
+
+    ##
+    # Returns a new semantic version with the requested level incremented.
+    #
+    # @param [Symbol, String] level
+    #
+    # @return [Semverve::SemanticVersion]
+    def increment(level)
+      case level.to_sym
+      when :major
+        self.class.new(major: major + 1, minor: 0, patch: 0)
+      when :minor
+        self.class.new(major: major, minor: minor + 1, patch: 0)
+      when :patch
+        self.class.new(major: major, minor: minor, patch: patch + 1)
+      else
+        raise Error, "Unknown version increment level: #{level.inspect}."
+      end
+    end
+
+    ##
+    # Compares semantic versions by major, minor, then patch.
+    #
+    # @param [Semverve::SemanticVersion] other
+    #
+    # @return [Integer, nil]
+    def <=>(other)
+      return unless other.is_a?(self.class)
+
+      to_a <=> other.to_a
+    end
+
+    ##
+    # Version as +MAJOR.MINOR.PATCH+.
+    #
+    # @return [String]
+    def to_s
+      to_a.join(".")
+    end
+
+    ##
+    # Version as +[major, minor, patch]+.
+    #
+    # @return [Array<Integer>]
+    def to_a
+      [major, minor, patch]
+    end
+  end
+end