Class: GemHadar

Inherits:
Object
  • Object
show all
Extended by:
DSLKit::DSLAccessor
Includes:
Config, PromptTemplate, Utils, Warn, Rake::DSL, RbConfig, Term::ANSIColor, Tins::SecureWrite
Defined in:
lib/gem_hadar.rb,
lib/gem_hadar.rb,
lib/gem_hadar/simplecov.rb,
lib/gem_hadar/version.rb,
lib/gem_hadar/warn.rb

Overview

A brief description of the GemHadar class.

The GemHadar class serves as the primary configuration and task management framework for Ruby gem projects. It provides a DSL for defining gem metadata, dependencies, and Rake tasks, while also offering integration with various tools such as GitHub, SimpleCov, YARD, and Ollama for automating common development workflows.

Examples:

Configuring a gem using the GemHadar DSL

GemHadar do
  name        'my_gem'
  version     '1.0.0'
  author      'John Doe'
  email       'john@example.com'
  homepage    'https://github.com/example/my_gem'
  summary     'A brief description'
  description 'A longer description of the gem'
  test_dir    'spec'
end

Creating a Rake task for building and packaging the gem

GemHadar do
  name 'my_gem'
  # ... other configuration ...
  build_task
end

Setting up version bumping with AI assistance

GemHadar do
  name 'my_gem'
  # ... other configuration ...
  version_bump_task
end

Defined Under Namespace

Modules: GitHub, PromptTemplate, SimpleCov, Utils, Warn Classes: RvmConfig, Setup, TemplateCompiler

Constant Summary collapse

VERSION =

GemHadar version

'2.8.0'
VERSION_ARRAY =

:nodoc:

VERSION.split('.').map(&:to_i)
VERSION_MAJOR =

:nodoc:

VERSION_ARRAY[0]
VERSION_MINOR =

:nodoc:

VERSION_ARRAY[1]
VERSION_BUILD =

:nodoc:

VERSION_ARRAY[2]

Instance Method Summary collapse

Methods included from Warn

#fail, #warn

Methods included from PromptTemplate

#default_git_release_prompt, #default_git_release_system_prompt, #default_version_bump_prompt, #default_version_bump_system_prompt

Methods included from Utils

#xdg_config_filename, #xdg_config_home

Constructor Details

#initialize(&block) ⇒ GemHadar

The initialize method sets up the GemHadar instance by initializing dependency arrays and evaluating a configuration block.

Parameters:

  • block (Proc) —

    optional configuration block to set gem properties and settings



88
89
90
91
92
 
# File 'lib/gem_hadar.rb', line 88

def initialize(&block)
  @dependencies = []
  @development_dependencies = []
  block and instance_eval(&block)
end

Instance Method Details

#ask?(prompt, pattern, default: nil) ⇒ MatchData?

The ask? method prompts the user with a message and reads their input It returns a MatchData object if the input matches the provided pattern.

Parameters:

  • prompt (String) —

    the message to display to the user

  • pattern (Regexp) —

    the regular expression to match against the input

Returns:

  • (MatchData, nil) —

    the result of the pattern match or nil if no match



1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
 
# File 'lib/gem_hadar.rb', line 1937

def ask?(prompt, pattern, default: nil)
  if prompt.include?('%{default}')
    if default.present?
      prompt = prompt % { default: ", default is #{default.inspect}" }
    else
      prompt = prompt % { default: '' }
    end
  end
  STDOUT.print prompt
  answer = STDIN.gets.chomp
  default.present? && answer.blank? and answer = default
  if answer =~ pattern
    $~
  end
end

#assert_valid_link(name, orig_url) ⇒ String

The assert_valid_link method verifies that the provided URL is valid by checking if it returns an HTTP OK status after following redirects, unless project is still ‘developing`.

following redirects

Parameters:

  • name (String) —

    the name associated with the link being validated

  • orig_url (String) —

    the URL to validate

Returns:

  • (String) —

    the original URL if validation succeeds

Raises:

  • (ArgumentError) —

    if the final response is not an HTTP OK status after



1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
 
# File 'lib/gem_hadar.rb', line 1850

def assert_valid_link(name, orig_url)
  developing and return orig_url
  url = orig_url
  begin
    response = Net::HTTP.get_response(URI.parse(url))
    url = response['location']
  end while response.is_a?(Net::HTTPRedirection)
  response.is_a?(Net::HTTPOK) or
    fail "#{orig_url.inspect} for #{name} has to be a valid link"
  orig_url
end

#bindir ⇒ String?

The bindir attribute accessor for configuring the gem’s binary directory.

This method sets up a DSL accessor for the bindir attribute, which specifies the directory where executable scripts (binaries) are installed when the gem is packaged and installed. It provides a way to define the location of the bin directory that will contain the gem’s executable files.

Returns:

  • (String, nil) —

    the path to the binary directory or nil if not set



318
 
# File 'lib/gem_hadar.rb', line 318

dsl_accessor :bindir

#build_task ⇒ Object

The build_task method defines a Rake task that orchestrates the complete build process for packaging the gem.

This method sets up a :build task that depends on the tasks specified in the build_task_dependencies accessor. It provides a convenient way to execute all necessary steps for building packages for a release with a single command.



694
695
696
697
 
# File 'lib/gem_hadar.rb', line 694

def build_task
  desc 'Build task (builds all packages for a release)'
  task :build => build_task_dependencies
end

#build_task_dependencies ⇒ Array<Symbol, String>

The build_task_dependencies method manages the list of dependencies for the build task.

This method sets up a DSL accessor for the build_task_dependencies attribute, which specifies the sequence of Rake tasks that must be executed when running the build task. These dependencies typically include cleaning previous builds, generating the gem specification, packaging the gem, and creating a version tag.

Returns:

  • (Array<Symbol, String>) —

    an array of task names that are required as dependencies for the build task execution



685
 
# File 'lib/gem_hadar.rb', line 685

dsl_accessor :build_task_dependencies, [ :clobber, :gemspec, :package, :'version:tag' ]

#clean(*args) ⇒ FileList?

The clean method manages the CLEAN file list for Rake tasks.

When called without arguments, it returns the current CLEAN file list. When called with arguments, it adds the specified files to the CLEAN list.

Parameters:

  • args (Array<String>) —

    optional list of files to add to the CLEAN list

Returns:

  • (FileList, nil) —

    the CLEAN file list when no arguments provided, nil otherwise



723
724
725
726
727
728
729
 
# File 'lib/gem_hadar.rb', line 723

def clean(*args)
  if args.empty?
    CLEAN
  else
    CLEAN.include(*args)
  end
end

#clobber(*args) ⇒ FileList?

The clobber method manages the CLOBBER file list for Rake tasks.

When called without arguments, it returns the current CLOBBER file list. When called with arguments, it adds the specified files to the CLOBBER list.

Parameters:

  • args (Array<String>) —

    optional list of files to add to the CLOBBER list

Returns:

  • (FileList, nil) —

    the CLOBBER file list when no arguments provided, nil otherwise



740
741
742
743
744
745
746
 
# File 'lib/gem_hadar.rb', line 740

def clobber(*args)
  if args.empty?
    CLOBBER
  else
    CLOBBER.include(*args)
  end
end

#compile_task ⇒ Object

The compile_task method sets up a Rake task to compile project extensions.

This method creates a :compile task that iterates through the configured extensions and compiles them using the system’s make command.



1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
 
# File 'lib/gem_hadar.rb', line 1450

def compile_task
  for file in extensions
    dir = File.dirname(file)
    clean File.join(dir, 'Makefile'), File.join(dir, '*.{bundle,o,so}')
  end
  desc "Compile extensions: #{extensions * ', '}"
  task :compile do
    for file in extensions
      dir, file = File.split(file)
      cd dir do
        ruby file
        sh make
      end
    end
  end
end

#config_task ⇒ Object

The config_task method creates a Rake task that displays the current GemHadar configuration.

This method sets up a :gem_hadar:config task under the Rake namespace that outputs detailed information about the gem’s configuration, including environment variables, API keys, Ollama settings, XDG configuration directory, general gem properties, build and development parameters, Git remotes, and AI prompt defaults.



1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
 
# File 'lib/gem_hadar.rb', line 1582

def config_task
  namespace :gem_hadar do
    desc "Display current gem_hadar configuration"
    task :config do
      puts "=== GemHadar Configuration ==="

      # RubyGems
      if ENV['GEM_HOST_API_KEY'].present?
        puts "RubyGems API Key: *** (set)"
      else
        puts "RubyGems API Key: Not set"
      end

      # GitHub
      if ENV['GITHUB_API_TOKEN'].present?
        puts "GitHub API Token: *** (set)"
      else
        puts "GitHub API Token: Not set"
      end

      # Ollama
      puts "Ollama Model: #{ollama_model} (default is #{ollama_model_default})"

      if url = ollama_client&.full?(:base_url)&.to_s
        puts "Ollama Base URL: #{url.inspect}"
      else
        puts "Ollama Base URL: Not set"
      end

      if ENV['OLLAMA_MODEL_OPTIONS']
        puts "Ollama Model Options: #{ENV['OLLAMA_MODEL_OPTIONS']}"
      else
        puts "Ollama Model Options: Not set (using defaults)"
      end

      # XDG config home
      puts "XDG config home: #{xdg_config_home.to_s.inspect}"

      # General
      puts "Gem Name: #{name}"
      puts "Version: #{version}"

      # Build/Development
      puts "MAKE: #{ENV['MAKE'] || 'Not set (will use gmake or make)'}"
      puts "EDITOR: #{ENV['EDITOR'] || 'Not set (will use vi)'}"

      # Git
      puts "Git Remote(s): #{ENV['GIT_REMOTE'] || 'origin'}"

      # Other
      puts "Force Operations: #{ENV['FORCE'] || '0'}"
      puts "Version Override: #{ENV['VERSION'] || 'Not set'}"
      puts "GitHub Release Enabled: #{ENV['GITHUB_RELEASE_ENABLED'] || 'Not set'}"

      puts "\n=== AI Prompt Configuration (Default Values) ==="
      arrow = ?⤵
      puts bold{"version_bump_system_prompt.txt"} + "#{arrow}\n" + italic{default_version_bump_system_prompt}
      puts bold{"version_bump_prompt.txt"} + "#{arrow}\n#{default_version_bump_prompt}"
      puts bold{"release_system_prompt.txt"} + "#{arrow}\n" + italic{default_git_release_system_prompt}
      puts bold{"release_prompt.txt"} + "#{arrow}\n" + italic{default_git_release_prompt}

      puts "=== End Configuration ==="
    end
  end
end

#create_all_tasks ⇒ GemHadar

The create_all_tasks method sets up and registers all the Rake tasks for the gem project.

Returns:

  • (GemHadar) —

    the instance of GemHadar



1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
 
# File 'lib/gem_hadar.rb', line 1652

def create_all_tasks
  default_task
  config_task
  build_task
  rvm_task
  version_task
  version_show_task
  version_diff_task
  gem_hadar_update_task
  gemspec_task
  gems_install_task
  if test_dir
    test_task
    rcov_task
  end
  spec_task
  package_task
  yard_task
  install_library_task
  version_bump_task
  version_tag_task
  push_task
  release_task
  github_workflows_task
  write_ignore_file
  write_gemfile
  if extensions.full?
    compile_task
    task :prepare_install => :compile
  else
    task :prepare_install
  end
  self
end

#create_git_release_body ⇒ String

The create_git_release_body method generates a changelog for a GitHub release by analyzing the git diff between the previous version and the current HEAD.

It retrieves the log differences, fetches or uses default system and prompt templates, and utilizes an AI model to produce a formatted changelog entry.

Returns:

  • (String) —

    the generated changelog content for the release body



1342
1343
1344
1345
1346
1347
 
# File 'lib/gem_hadar.rb', line 1342

def create_git_release_body
  log_diff = version_log_diff(to_version: version)
  system   = xdg_config('release_system_prompt.txt', default_git_release_system_prompt)
  prompt   = xdg_config('release_prompt.txt', default_git_release_prompt) % { name:, version:, log_diff: }
  ollama_generate(system:, prompt:)
end

#default_task ⇒ Object

The default_task method defines the default Rake task for the gem project.

This method sets up a Rake task named :default that depends on the tasks specified in the default_task_dependencies accessor. It provides a convenient way to run the most common or essential tasks for the project with a single command.



669
670
671
672
 
# File 'lib/gem_hadar.rb', line 669

def default_task
  desc 'Default task'
  task :default => default_task_dependencies
end

#default_task_dependencies ⇒ Array<Symbol, String>

The default_task_dependencies method manages the list of dependencies for the default Rake task.

This method sets up a DSL accessor for the default_task_dependencies attribute, which specifies the sequence of Rake tasks that must be executed when running the default task. These dependencies typically include generating the gem specification and running tests to ensure a consistent starting point for development workflows.

Returns:

  • (Array<Symbol, String>) —

    an array of task names that are required as dependencies for the default task execution



661
 
# File 'lib/gem_hadar.rb', line 661

dsl_accessor :default_task_dependencies, [ :gemspec, :test ]

#dependency(*args) ⇒ Object

The dependency method adds a new runtime dependency to the gem.

Parameters:

  • args (Array) —

    the arguments defining the dependency



793
794
795
 
# File 'lib/gem_hadar.rb', line 793

def dependency(*args)
  @dependencies << args
end

#description ⇒ String

The description attribute accessor for configuring the gem’s description.

This method sets up a DSL accessor for the description attribute, which specifies the detailed explanation of what the gem does. It includes a validation step that raises an ArgumentError if the description has not been set, ensuring that the gem configuration contains this required information.

Returns:

  • (String) —

    the description of the gem

Raises:

  • (ArgumentError) —

    if the description attribute has not been set



241
 
# File 'lib/gem_hadar.rb', line 241

dsl_accessor :description do has_to_be_set :description end

#determine_version_range ⇒ Array(String, String)

Determine the start and end versions for diff comparison.

If the VERSION env var is set, it will be used as the starting version tag. Otherwise, it defaults to the current commit’s version or the latest tag.

Returns:

  • (Array(String, String)) —

    A fixed-size array containing:

    • The start version (e.g., ‘1.2.3’) from which changes are compared.

    • The end version (e.g., ‘1.2.4’ or ‘HEAD’) up to which changes are compared.



1800
1801
1802
1803
1804
1805
1806
 
# File 'lib/gem_hadar.rb', line 1800

def determine_version_range
  version_tags = versions.map { version_tag(_1) } + %w[ HEAD ]
  found_version_tag = version_tags.index(version_tag(version))
  found_version_tag.nil? and fail "cannot find version tag #{version_tag(version)}"
  start_version, end_version = version_tags[found_version_tag, 2]
  return start_version, end_version
end

#developing ⇒ Boolean

The developing attribute accessor for configuring development mode.

This method sets up a DSL accessor for the developing attribute, which controls whether the gem is in development mode. When set to true, certain behaviors such as skipping gem pushes are enabled as well as asserting the validity of the homepage link.

Returns:

  • (Boolean) —

    the current value of the developing flag



112
 
# File 'lib/gem_hadar.rb', line 112

dsl_accessor :developing, false

#development_dependency(*args) ⇒ Object

The development_dependency method adds a new development-time dependency to the gem.

Parameters:

  • args (Array) —

    the arguments defining the development dependency



801
802
803
 
# File 'lib/gem_hadar.rb', line 801

def development_dependency(*args)
  @development_dependencies << args
end

#doc_code_files ⇒ FileList

The doc_code_files method manages the list of code files to be included in documentation generation.

This method sets up a DSL accessor for the doc_code_files attribute, which specifies the Ruby source files that should be processed when generating YARD documentation. It defaults to using the files attribute and provides a way to customize which code files are included in the documentation build process.

Returns:

  • (FileList) —

    a list of file paths to be included in YARD documentation generation

See Also:



413
414
415
 
# File 'lib/gem_hadar.rb', line 413

dsl_accessor :doc_code_files do
  files
end

#doc_files ⇒ FileList

The doc_files attribute accessor for configuring additional documentation files.

This method sets up a DSL accessor for the doc_files attribute, which specifies additional files to be included in the YARD documentation generation process. It defaults to an empty FileList and provides a way to define extra documentation files that should be processed alongside the standard library source files.

documentation

Returns:

  • (FileList) —

    a list of file paths to be included in YARD



428
429
430
 
# File 'lib/gem_hadar.rb', line 428

dsl_accessor :doc_files do
  FileList[File.join('lib/**/*.rb')] + FileList[File.join('ext/**/*.c')]
end

#edit_temp_file(content) ⇒ String?

The edit_temp_file method creates a temporary file with the provided content, opens it in an editor for user modification, and returns the updated content.

This method first determines the editor to use from the EDITOR environment variable or defaults to vi. If the editor cannot be found, it issues a warning and returns nil. It then creates a temporary file, writes the initial content to it, and opens the file in the editor. After the user saves and closes the editor, it reads the modified content from the temporary file. The temporary file is automatically cleaned up after use.

file

nil if the editor could not be found or failed

Parameters:

  • content (String) —

    the initial content to write to the temporary

Returns:

  • (String, nil) —

    the content of the temporary file after editing, or



1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
 
# File 'lib/gem_hadar.rb', line 1703

def edit_temp_file(content)
  editor = ENV.fetch('EDITOR', `which vi`.chomp)
  unless File.exist?(editor)
    warn "Can't find EDITOR. => Returning."
    return
  end
  temp_file = Tempfile.new(%w[ changelog .md ])
  temp_file.write(content)
  temp_file.close

  unless system("#{editor} #{temp_file.path}")
    warn "#{editor} returned #{$?.exitstatus} => Returning."
    return
  end

  File.read(temp_file.path)
ensure
  temp_file&.close&.unlink
end

#email ⇒ String

The email attribute accessor for configuring the gem’s author email.

This method sets up a DSL accessor for the email attribute, which specifies the contact email address for the gem’s author. It includes a validation step that raises an ArgumentError if the email has not been set, ensuring that the gem configuration contains this required information.

Returns:

  • (String) —

    the author’s email address

Raises:

  • (ArgumentError) —

    if the email attribute has not been set



194
195
196
 
# File 'lib/gem_hadar.rb', line 194

dsl_accessor :email do
  has_to_be_set :email
end

#executables ⇒ Set<String>

The executables attribute accessor for configuring the gem’s executable files.

This method sets up a DSL accessor for the executables attribute, which specifies the list of executable scripts that should be installed as part of the gem. It provides a way to define one or more executable file names that will be made available in the gem’s bin directory when the gem is installed.

the gem

Returns:

  • (Set<String>) —

    a set of executable file names to be included with



331
 
# File 'lib/gem_hadar.rb', line 331

dsl_accessor :executables do Set[] end

#extensions ⇒ FileList

The extensions attribute accessor for configuring project extensions.

This method sets up a DSL accessor for the extensions attribute, which specifies the list of extension configuration files (typically extconf.rb) that should be compiled when building the gem. It defaults to finding all extconf.rb files within the ext directory and its subdirectories, making it easy to include native extensions in the gem package.

Returns:

  • (FileList) —

    a list of file paths to extension configuration files to be compiled during the build process



455
 
# File 'lib/gem_hadar.rb', line 455

dsl_accessor :extensions do FileList['ext/**/extconf.rb'] end

#files ⇒ Array<String>

The files attribute accessor for configuring the list of files included in the gem package.

This method sets up a DSL accessor for the files attribute, which specifies the complete set of files that should be included when building the gem package. It defaults to retrieving the file list from Git using ‘git ls-files` and provides a way to override this behavior through the configuration block.

Returns:

  • (Array<String>) —

    an array of file paths to be included in the gem package



481
482
483
 
# File 'lib/gem_hadar.rb', line 481

dsl_accessor :files do
  FileList[`git ls-files`.split("\n")]
end

#gem_files ⇒ Array<String>

The gem_files method returns an array of files that are included in the gem package.

It calculates this by subtracting the files listed in package_ignore_files from the list of all files.

Returns:

  • (Array<String>) —

    the list of files to include in the gem package



1960
1961
1962
 
# File 'lib/gem_hadar.rb', line 1960

def gem_files
  (files.to_a - package_ignore_files.to_a)
end

#gem_hadar_update_task ⇒ Object

The gem_hadar_update_task method defines a Rake task that updates the gem_hadar dependency version in the gemspec file.

This method creates a :gem_hadar:update task under the Rake namespace that prompts the user to specify a new gem_hadar version. It then reads the existing gemspec file, modifies the version constraint for the gem_hadar dependency, and writes the updated content back to the file. If the specified version is already present in the gemspec, it skips the update and notifies the user.



957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
 
# File 'lib/gem_hadar.rb', line 957

def gem_hadar_update_task
  namespace :gem_hadar do
    desc 'Update gem_hadar to a different version'
    task :update do
      answer = ask?("Which gem_hadar version? ", /^((?:\d+.){2}(?:\d+))$/)
      unless answer
        warn "Invalid version specification!"
        exit 1
      end
      gem_hadar_version = answer[0]
      filename = "#{name}.gemspec"
      old_data = File.read(filename)
      new_data = old_data.gsub(
        /(add_(?:development_)?dependency\(%q<gem_hadar>, \["~> )([\d.]+)("\])/
      ) { "#$1#{gem_hadar_version}#$3" }
      if old_data == new_data
        warn "#{filename.inspect} already depends on gem_hadar "\
          "#{gem_hadar_version} => Do nothing."
      else
        warn "Upgrading #{filename.inspect} to #{gem_hadar_version}."
        secure_write(filename) do |spec|
          spec.write new_data
        end
      end
    end
  end
end

#gem_push_task ⇒ Object

The gem_push_task method defines a Rake task for pushing the generated gem file to RubyGems.

This method sets up a :gem:push task under the Rake namespace that handles the process of uploading the gem package to RubyGems. It checks if the project is in developing mode and skips the push operation if so. Otherwise, it verifies the existence of the gem file, prompts the user for confirmation before pushing, and uses the gem push command with an optional API key from the environment. If the gem file does not exist or the user declines to push, appropriate messages are displayed and the task exits accordingly.



1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
 
# File 'lib/gem_hadar.rb', line 1288

def gem_push_task
  namespace :gem do
    path = "pkg/#{name_version}.gem"
    desc "Push gem file #{File.basename(path)} to rubygems"
    if developing
      task :push => :build do
        puts "Skipping push to rubygems while developing mode is enabled."
      end
    else
      task :push => :build do
        if File.exist?(path)
          if ask?("Do you really want to push #{path.inspect} to rubygems? "\
              "(yes/NO) ", /\Ayes\z/i)
            then
            key = ENV['GEM_HOST_API_KEY'].full? { |k| "--key #{k} " }
            sh "gem push #{key}#{path}"
          else
            exit 1
          end
        else
          warn "Cannot push gem to rubygems: #{path.inspect} doesn't exist."
          exit 1
        end
      end
    end
  end
end

#gems_install_task(&block) ⇒ Object

The gems_install_task method defines a Rake task for installing all gem dependencies specified in the Gemfile.

This method sets up a :gems:install task that executes a block to install gems. If no block is provided, it defaults to running ‘bundle install’.

Parameters:

  • block (Proc) —

    optional block containing the installation command



812
813
814
815
816
817
818
 
# File 'lib/gem_hadar.rb', line 812

def gems_install_task(&block)
  block ||= proc {  sh 'bundle install' }
  desc 'Install all gems from the Gemfile'
  namespace :gems do
    task :install => :gemspec , &block
  end
end

#gemspec ⇒ Gem::Specification

The gemspec method creates and returns a new Gem::Specification object that defines the metadata and dependencies for the gem package.

Returns:

  • (Gem::Specification) —

    a fully configured Gem specification object



1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
 
# File 'lib/gem_hadar.rb', line 1866

def gemspec
  Gem::Specification.new do |s|
    s.name        = name
    s.version     = ::Gem::Version.new(version)
    s.author      = author
    s.email       = email
    s.homepage    = assert_valid_link(:homepage, homepage)
    s.summary     = summary
    s.description = description

    gem_files.full? { |f| s.files = Array(f) }
    test_files.full? { |t| s.test_files = Array(t) }
    extensions.full? { |e| s.extensions = Array(e) }
    bindir.full? { |b| s.bindir = b }
    executables.full? { |e| s.executables = Array(e) }
    licenses.full? { |l| s.licenses = Array(licenses) }
    post_install_message.full? { |m| s.post_install_message = m }

    required_ruby_version.full? { |v| s.required_ruby_version = v }
    s.add_development_dependency('gem_hadar', "~> #{VERSION[/\A\d+\.\d+/, 0]}")
    for d in @development_dependencies
      s.add_development_dependency(*d)
    end
    for d in @dependencies
      if s.respond_to?(:add_runtime_dependency)
        s.add_runtime_dependency(*d)
      else
        s.add_dependency(*d)
      end
    end

    require_paths.full? { |r| s.require_paths = Array(r) }

    if title
      s.rdoc_options << '--title' << title
    else
      s.rdoc_options << '--title' << "#{name.camelize} - #{summary}"
    end
    if readme
      if File.exist?(readme)
        s.rdoc_options << '--main' << readme
        s.extra_rdoc_files << readme
      else
        warn "Add a #{readme} file to document your gem!"
      end
    end
    doc_files.full? { |df| s.extra_rdoc_files.concat Array(df) }
  end
end

#gemspec_task ⇒ Object

The gemspec_task method defines a Rake task that generates and writes a gemspec file for the project.

This method creates a :gemspec task that depends on the :version task, ensuring the version is set before generating the gemspec. It constructs the filename based on the project name, displays a warning message indicating the file being written, and uses secure_write to create the gemspec file with content generated by the gemspec method.



993
994
995
996
997
998
999
1000
 
# File 'lib/gem_hadar.rb', line 993

def gemspec_task
  desc 'Create a gemspec file'
  task :gemspec => :version do
    filename = "#{name}.gemspec"
    warn "Writing to #{filename.inspect} for #{version}"
    secure_write(filename, gemspec.to_ruby)
  end
end

#git_remote ⇒ Object

The git_remote method retrieves the primary Git remote name configured for the project.

It first checks the GIT_REMOTE environment variable for a custom remote specification. If not set, it defaults to ‘origin’. When multiple remotes are specified in the environment variable, only the first one is returned.



1188
1189
1190
 
# File 'lib/gem_hadar.rb', line 1188

def git_remote
  ENV.fetch('GIT_REMOTE', 'origin').split(/\s+/).first
end

#git_remotes ⇒ Array<String>

The git_remotes method retrieves the list of remote repositories configured for the current Git project.

It first attempts to read the remotes from the ENV environment variable, splitting it by whitespace. If this is not available, it falls back to querying the local Git repository using ‘git remote`.

Returns:

  • (Array<String>) —

    an array of remote names



1924
1925
1926
1927
1928
 
# File 'lib/gem_hadar.rb', line 1924

def git_remotes
  remotes = ENV['GIT_REMOTE'].full?(:split, /\s+/)
  remotes or remotes = `git remote`.lines.map(&:chomp)
  remotes
end

#git_remotes_task ⇒ Object

The git_remotes_task method defines a Rake task that displays all Git remote repositories configured for the project.

This method sets up a :git_remotes task under the Rake namespace that retrieves and prints the list of Git remotes along with their URLs. It uses the git_remotes method to obtain the remote names and then fetches each remote’s URL using the ‘git remote get-url` command. The output is formatted to show each remote name followed by its corresponding URL on separate lines.



1325
1326
1327
1328
1329
1330
1331
1332
 
# File 'lib/gem_hadar.rb', line 1325

def git_remotes_task
  task :git_remotes do
    puts git_remotes.map { |r|
      url = `git remote get-url #{r.inspect}`.chomp
      "#{r} #{url}"
    }
  end
end

#github_release_task ⇒ Object

The github_release_task method defines a Rake task that creates a GitHub release for the current version.

This method sets up a :github:release task that prompts the user to confirm publishing a release message on GitHub. It retrieves the GitHub API token from the environment, derives the repository owner and name from the git remote URL, generates a changelog using AI, and creates the release via the GitHub API.



1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
 
# File 'lib/gem_hadar.rb', line 1357

def github_release_task
  namespace :github do
    unless github_api_token = ENV['GITHUB_API_TOKEN'].full?
      warn "GITHUB_API_TOKEN not set. => Skipping github release task."
      task :release
      return
    end
    desc "Create a new GitHub release for the current version with a AI-generated changelog"
    task :release do
      yes = ask?(
        "Do you want to publish a release message on github? (y/n%{default}) ",
        /\Ay/i, default: ENV['GITHUB_RELEASE_ENABLED']
      )
      unless yes
          warn "Skipping publication of a github release message."
          next
      end
      if %r(\A/*(?<owner>[^/]+)/(?<repo>[^/.]+)) =~ github_remote_url&.path
        rc = GitHub::ReleaseCreator.new(owner:, repo:, token: github_api_token)
        tag_name         = version_tag(version)
        target_commitish = `git show -s --format=%H #{tag_name.inspect}^{commit}`.chomp
        body             = edit_temp_file(create_git_release_body)
        if body.present?
          begin
            response = rc.perform(tag_name:, target_commitish:, body:)
            puts "Release created successfully! See #{response.html_url}"
          rescue => e
            warn e.message
          end
        else
          warn "Skipping creation of github release message."
        end
      else
        warn "Could not derive github remote url from git remotes. => Skipping github release task."
      end
    end
  end
end

#github_remote_url ⇒ URI?

The github_remote_url method retrieves and parses the GitHub remote URL from the local Git configuration.

It executes ‘git remote -v` to get all remote configurations, extracts the push URLs, processes them to construct valid URIs, and returns the first URI pointing to GitHub.com.

Returns:

  • (URI, nil) —

    The parsed GitHub remote URI or nil if not found.



2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
 
# File 'lib/gem_hadar.rb', line 2011

def github_remote_url
  if remotes = `git remote -v`
    remotes_urls = remotes.scan(/^(\S+)\s+(\S+)\s+\(push\)/)
    remotes_uris = remotes_urls.map do |name, url|
      if %r(\A(?<scheme>[^@]+)@(?<hostname>[A-Za-z0-9.]+):(?:\d*)(?<path>.*)) =~ url
        path = ?/ + path unless path.start_with? ?/
        url = 'ssh://%s@%s%s' % [ scheme, hostname, path ] # approximate correct URIs
      end
      URI.parse(url)
    end
    remotes_uris.find { |uri| uri.hostname == 'github.com' }
  end
end

#github_workflows ⇒ Hash

The github_workflows attribute accessor for configuring GitHub Actions workflows.

This method sets up a DSL accessor for the github_workflows attribute, which specifies the configuration for generating GitHub Actions workflow files from ERB templates. It provides a way to define which workflows to generate and the variables to use when rendering the templates.

Returns:

  • (Hash) —

    a hash mapping workflow names to their configuration variables



2035
2036
2037
 
# File 'lib/gem_hadar.rb', line 2035

dsl_accessor :github_workflows do
  {}
end

#github_workflows_task ⇒ Object

The github_workflows_task method sets up Rake tasks for generating GitHub Actions workflow files from ERB templates.

This method configures a hierarchical task structure under the :github namespace that:

  • Compiles configured workflow templates from ERB files into actual workflow YAML files

  • Creates a :workflows task that depends on all compiled template files

  • Sets up a :workflows:clean task to remove generated workflow files

  • Uses the github_workflows configuration to determine which workflows to generate

  • Applies template variables to customize the generated workflows



2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
 
# File 'lib/gem_hadar.rb', line 2061

def github_workflows_task
  namespace :github do
    templates = []
    src_dir = Pathname.new(__dir__).join('gem_hadar', 'github_workflows')
    dst_dir = Pathname.pwd.join('.github', 'workflows')
    github_workflows.each do |workflow, variables|
      @github_workflows_variables = variables
      src = src_dir.join(workflow + '.erb')
      puts "Compiling #{src.to_s.inspect} to #{dst_dir.to_s.inspect} now."
      unless src.exist?
        warn "Workflow template #{src.to_s.inspect} doesn't exist! => Skipping."
      end
      mkdir_p dst_dir
      dst = dst_dir.join(workflow)
      templates << (template(src, dst) {}).to_s
    end
    desc "Create all configured github workflow tasks"
    task :workflows => templates
    namespace :workflows do
      desc "Delete all created github workflows"
      task :clean do
        github_workflows.each_key do |workflow|
          rm_f dst_dir.join(workflow), verbose: true
        end
      end
    end
  end
end

#github_workflows_variables ⇒ Hash

The github_workflows_variables method retrieves the cached variables used for GitHub Actions workflow template compilation.

This method returns the stored hash of variables that were previously set during the configuration of GitHub workflows. If no variables have been set, it returns an empty hash as a default value.

Returns:

  • (Hash) —

    the hash of variables used for GitHub workflow template rendering or an empty hash if none are set



2048
2049
2050
 
# File 'lib/gem_hadar.rb', line 2048

def github_workflows_variables
  @github_workflows_variables || {}
end

#has_to_be_set(name) ⇒ Object

The has_to_be_set method raises an error if a required gem configuration attribute is not set.

Parameters:

  • name (String) —

    the name of the required attribute

Raises:

  • (ArgumentError) —

    if the specified attribute has not been set



100
101
102
 
# File 'lib/gem_hadar.rb', line 100

def has_to_be_set(name)
  fail "#{self.class}: #{name} has to be set for gem"
end

#homepage ⇒ String

The homepage attribute accessor for configuring the gem’s homepage URL.

This method sets up a DSL accessor for the homepage attribute, which specifies the URL of the gem’s official repository or project page. It includes a validation step that raises an ArgumentError if the homepage has not been set, ensuring that the gem configuration contains this required information. When the developing flag is false, it also validates that the provided URL returns an HTTP OK status after following redirects.

Returns:

  • (String) —

    the homepage URL of the gem

Raises:

  • (ArgumentError) —

    if the homepage attribute has not been set

  • (ArgumentError) —

    if the homepage URL is invalid and developing mode is disabled



211
212
213
 
# File 'lib/gem_hadar.rb', line 211

dsl_accessor :homepage do
  has_to_be_set :homepage
end

#ignore(*args) ⇒ Set<String>?

The ignore method manages the list of files to be ignored by the gem.

When called without arguments, it returns the current set of ignored files. When called with arguments, it adds the specified files to the ignore list.

Parameters:

  • args (Array<String>) —

    optional list of file patterns to add to the ignore list

Returns:

  • (Set<String>, nil) —

    the set of ignored files when no arguments provided, nil otherwise



757
758
759
760
761
762
763
 
# File 'lib/gem_hadar.rb', line 757

def ignore(*args)
  if args.empty?
    ignore_files
  else
    args.each { |a| ignore_files << a }
  end
end

#ignore_files ⇒ Set<String>

The ignore_files attribute accessor for configuring files to be ignored by the gem.

This method sets up a DSL accessor for the ignore_files attribute, which specifies a set of file patterns that should be excluded from various gem operations and processing tasks. It provides a way to define ignore rules that apply broadly across the gem’s functionality, including but not limited to build processes, documentation generation, and version control integration.

Returns:

  • (Set<String>) —

    a set of file patterns to be ignored by the gem’s operations



308
 
# File 'lib/gem_hadar.rb', line 308

dsl_accessor :ignore_files do Set[] end

#install_library(&block) ⇒ Object

The install_library method sets up a Rake task for installing the library or executable into site_ruby directories.

This method configures an :install task that depends on the :prepare_install task and executes the provided block. It stores the block in an instance variable to be called later when the task is executed.

Parameters:

  • block (Proc) —

    the block containing the installation logic



707
708
709
710
711
712
 
# File 'lib/gem_hadar.rb', line 707

def install_library(&block)
  @install_library_block = -> do
    desc 'Install executable/library into site_ruby directories'
    task :install => :prepare_install, &block
  end
end

#install_library_task ⇒ Object

The install_library_task method executes the installed library task block if it has been defined.



1018
1019
1020
 
# File 'lib/gem_hadar.rb', line 1018

def install_library_task
  @install_library_block.full?(:call)
end

#licenses ⇒ Set<String>

The licenses attribute accessor for configuring the gem’s license information.

This method sets up a DSL accessor for the licenses attribute, which specifies the license(s) under which the gem is distributed. It provides a way to define one or more licenses that apply to the gem, defaulting to an empty Set if none are explicitly configured.

Returns:

  • (Set<String>) —

    a set of license identifiers applied to the gem



342
 
# File 'lib/gem_hadar.rb', line 342

dsl_accessor :licenses do Set[] end

#make ⇒ String?

The make method retrieves the make command to be used for building extensions.

This method determines the appropriate make command to use when compiling project extensions. It first checks for the MAKE environment variable and returns its value if set. If the environment variable is not set, it attempts to detect a suitable make command by testing for the existence of ‘gmake’ and ‘make’ in the system PATH.

Returns:

  • (String, nil) —

    the make command name or nil if none found



467
468
469
 
# File 'lib/gem_hadar.rb', line 467

dsl_accessor :make do
  ENV['MAKE'] || %w[gmake make].find { |c| system(c, '-v') }
end

#master_prepare_task ⇒ Object

The master_prepare_task method defines a Rake task that sets up a remote Git repository for the project.

This method creates a :master:prepare task under the Rake namespace that guides the user through creating a new bare Git repository on a remote server via SSH. It prompts for the remote name, directory path, and SSH account details to configure the repository and establish a connection back to the local project.



1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
 
# File 'lib/gem_hadar.rb', line 1200

def master_prepare_task
  namespace :master do
    desc "Prepare a remote git repository for this project"
    task :prepare do
      puts "Create a new remote git repository for #{name.inspect}"
      remote_name = ask?('Name (default: origin) ? ', /^.+$/).
        full?(:[], 0) || 'origin'
      dir         = ask?("Directory (default: /git/#{name}.git)? ", /^.+$/).
        full?(:[], 0) || "/git/#{name}.git"
       = ask?('SSH account (format: login@host)? ', /^[^@]+@[^@]+/).
        full?(:[], 0) || exit(1)
      sh "ssh #{} 'git init --bare #{dir}'"
      sh "git remote add -m master #{remote_name} #{}:#{dir}"
    end
  end
end

#master_push_task ⇒ Object

The master_push_task method defines Rake tasks for pushing the master branch to configured Git remotes.

This method sets up a hierarchical task structure under the :master namespace:

  • It creates subtasks in the :master:push namespace for each configured Git remote, allowing individual pushes to specific remotes.

  • It also defines a top-level :master:push task that depends on all the individual remote push tasks, enabling a single command to push the master branch to all remotes.

The tasks utilize the git_remotes method to determine which remotes are configured and generate appropriate push commands for each one.



1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
 
# File 'lib/gem_hadar.rb', line 1261

def master_push_task
  namespace :master do
    git_remotes.each do |gr|
      namespace gr.to_sym do
        desc "Push master to git remote #{gr}"
        task :push do
          sh "git push #{gr} master"
        end
      end
    end

    desc "Push master #{version} to all git remotes: #{git_remotes * ' '}"
    task :push => git_remotes.map { |gr| :"master:#{gr}:push" }
  end
end

#module_type ⇒ Symbol

The module_type attribute accessor for configuring the type of Ruby construct to generate for version code.

This method sets up a DSL accessor for the module_type attribute, which determines whether the generated code structure for the version module should be a :module or :class. This controls the type of Ruby construct created when generating code skeletons and version files. The value can be set to either:

  • :module (default) - Generates module-based structure

  • :class - Generates class-based structure

This is used in the generated version.rb file to create either:

module MyGem
  # ... version constants
end

or

class MyGem
  # ... version constants
end

Returns:

  • (Symbol) —

    the type of Ruby construct to generate (:module or :class)



166
 
# File 'lib/gem_hadar.rb', line 166

dsl_accessor :module_type, :module

#name ⇒ String

The name attribute accessor for configuring the gem’s name.

This method sets up a DSL accessor for the name attribute, which specifies the identifier for the gem. It includes a validation step that raises an ArgumentError if the name has not been set, ensuring that the gem configuration contains a required name value.

Returns:

  • (String) —

    the name of the gem

Raises:

  • (ArgumentError) —

    if the name attribute has not been set



124
125
126
 
# File 'lib/gem_hadar.rb', line 124

dsl_accessor :name do
  has_to_be_set :name
end

#name_version ⇒ String

The name_version method computes and returns the combined gem name and version string.

This method constructs a version identifier by joining the gem’s name and current version with a hyphen separator. It is typically used to generate filenames or identifiers that incorporate both the gem name and its version number for packaging, tagging, or display purposes.

Returns:

  • (String) —

    the combined gem name and version in the format “name-version”



137
138
139
 
# File 'lib/gem_hadar.rb', line 137

dsl_accessor :name_version do
  [ name, version ] * '-'
end

#ollama_client ⇒ Ollama::Client?

The ollama_client method creates and returns an Ollama::Client instance configured with a base URL derived from environment variables.

It first checks for the OLLAMA_URL environment variable to determine the base URL. If that is not set, it falls back to using the OLLAMA_HOST environment variable, defaulting to ‘localhost:11434’ if that is also not set. The method then constructs the full base URL and initializes an Ollama::Client with appropriate timeouts for read and connect operations.

Returns:

  • (Ollama::Client, nil) —

    An initialized Ollama::Client instance if a valid base URL is present, otherwise nil.



1754
1755
1756
1757
1758
1759
1760
1761
1762
 
# File 'lib/gem_hadar.rb', line 1754

def ollama_client
  base_url = ENV['OLLAMA_URL']
  if base_url.blank?
    host = ENV.fetch('OLLAMA_HOST', 'localhost:11434')
    base_url = 'http://%s' % host
  end
  base_url.present? or return
  Ollama::Client.new(base_url:, read_timeout: 600, connect_timeout: 60)
end

#ollama_generate(system:, prompt:) ⇒ String?

Generates a response from an AI model using the Ollama::Client.

Parameters:

  • system (String) —

    The system prompt for the AI model.

  • prompt (String) —

    The user prompt to generate a response to.

Returns:

  • (String, nil) —

    The generated response or nil if generation fails.



1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
 
# File 'lib/gem_hadar.rb', line 1769

def ollama_generate(system:, prompt:)
  unless ollama = ollama_client
    warn "Ollama is not configured. => Returning."
    return
  end
  model    = ollama_model
  options  = ENV['OLLAMA_MODEL_OPTIONS'].full? { |o| JSON.parse(o) } || {}
  options |= { "temperature" => 0, "top_p" => 1, "min_p" => 0.1 }
  ollama.generate(model:, system:, prompt:, options:, stream: false, think: false).response
end

#ollama_model ⇒ String

The ollama_model method retrieves the name of the Ollama AI model to be used for generating responses.

It first checks the OLLAMA_MODEL environment variable for a custom model specification. If the environment variable is not set, it falls back to using the default model name, which is determined by the ollama_model_default dsl method.

Returns:

  • (String) —

    the name of the Ollama AI model to be used



1739
1740
1741
 
# File 'lib/gem_hadar.rb', line 1739

def ollama_model
  ENV.fetch('OLLAMA_MODEL', ollama_model_default)
end

#ollama_model_default ⇒ String

The ollama_model_default method returns the default name of the Ollama AI model to be used for generating responses when no custom model is specified.

Returns:

  • (String) —

    the default Ollama AI model name, which is ‘llama3.1’



1728
 
# File 'lib/gem_hadar.rb', line 1728

dsl_accessor :ollama_model_default, 'llama3.1'.freeze

#package_ignore(*args) ⇒ Set<String>?

The package_ignore method manages the list of files to be ignored during gem packaging.

When called without arguments, it returns the current set of package ignore files. When called with arguments, it adds the specified file patterns to the package ignore list.

Parameters:

  • args (Array<String>) —

    optional list of file patterns to add to the package ignore list

Returns:

  • (Set<String>, nil) —

    the set of package ignore files when no arguments provided, nil otherwise



776
777
778
779
780
781
782
783
784
785
786
787
788
 
# File 'lib/gem_hadar.rb', line 776

def package_ignore(*args)
  if args.empty?
    package_ignore_files
  else
    args.each do |arg|
      if File.directory?(arg)
        package_ignore_files.merge FileList['%s/**/*' % arg]
      else
        package_ignore_files << arg
      end
    end
  end
end

#package_ignore_files ⇒ Set<String>

The package_ignore_files attribute accessor for configuring files to be ignored during gem packaging.

This method sets up a DSL accessor for the package_ignore_files attribute, which specifies file patterns that should be excluded from the gem package when it is built. It defaults to an empty set and provides a way to define ignore rules specific to the packaging process, separate from general project ignore rules.

Returns:

  • (Set<String>) —

    a set of file patterns to be ignored during gem packaging



495
496
497
 
# File 'lib/gem_hadar.rb', line 495

dsl_accessor :package_ignore_files do
  Set[]
end

#package_task ⇒ Object

The package_task method sets up a Rake task for packaging the gem.

This method configures a task that creates a package directory, initializes a Gem::PackageTask with the current gem specification, and specifies that tar files should be created. It also includes the files to be packaged by adding gem_files to the package_files attribute of the Gem::PackageTask.



1008
1009
1010
1011
1012
1013
1014
 
# File 'lib/gem_hadar.rb', line 1008

def package_task
  clean 'pkg'
  Gem::PackageTask.new(gemspec) do |pkg|
    pkg.need_tar      = true
    pkg.package_files += gem_files
  end
end

#path_module ⇒ String

The path_module attribute accessor for configuring the Ruby module name.

This method sets up a DSL accessor for the path_module attribute, which determines the camelized version of the gem’s name to be used as the Ruby module or class name. It automatically converts the value of path_name into CamelCase format, ensuring consistency with Ruby naming conventions for module and class declarations.

Returns:

  • (String) —

    the camelized module name derived from path_name



520
 
# File 'lib/gem_hadar.rb', line 520

dsl_accessor :path_module do path_name.camelize end

#path_name ⇒ String

The path_name attribute accessor for configuring the gem’s path name.

This method sets up a DSL accessor for the path_name attribute, which determines the raw gem name value used for generating file paths and module names. It defaults to the value of the name attribute and is particularly useful for creating consistent directory structures and file naming conventions. This value is used internally by GemHadar to create the root directory for the gem and generate a version.rb file in that location.

Returns:

  • (String) —

    the path name derived from the gem’s name



509
 
# File 'lib/gem_hadar.rb', line 509

dsl_accessor :path_name do name end

#post_install_message ⇒ String?

The post_install_message attribute accessor for configuring a message to display after gem installation.

This method sets up a DSL accessor for the post_install_message attribute, which specifies a message to be displayed to users after the gem is installed. This can be useful for providing additional information, usage instructions, or important warnings to users of the gem.

Returns:

  • (String, nil) —

    the post-installation message or nil if not set



561
 
# File 'lib/gem_hadar.rb', line 561

dsl_accessor :post_install_message

#push_task ⇒ Object

The push_task method defines a Rake task that orchestrates the complete process of pushing changes and artifacts to remote repositories and package managers.

This method sets up multiple subtasks including preparing the master branch, pushing version tags, pushing to gem repositories, and creating GitHub releases. It also includes a check for uncommitted changes before proceeding with the push operations.



1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
 
# File 'lib/gem_hadar.rb', line 1416

def push_task
  master_prepare_task
  version_push_task
  master_push_task
  gem_push_task
  git_remotes_task
  github_release_task
  task :modified do
    changed_files = `git status --porcelain`.gsub(/^\s*\S\s+/, '').lines
    unless changed_files.empty?
      warn "There are still modified files:\n#{changed_files * ''}"
      exit 1
    end
  end
  desc "Push all changes for version #{version} into the internets."
  task :push => push_task_dependencies
end

#push_task_dependencies ⇒ Array<Symbol, String>

The push_task_dependencies method manages the list of dependencies for the push task.

This method sets up a DSL accessor for the push_task_dependencies attribute, which specifies the sequence of Rake tasks that must be executed when running the push task. These dependencies typically include checks for modified files, building the gem, pushing to remote repositories, and publishing to package managers like RubyGems and GitHub.

Returns:

  • (Array<Symbol, String>) —

    an array of task names that are required as dependencies for the push task execution



1406
 
# File 'lib/gem_hadar.rb', line 1406

dsl_accessor :push_task_dependencies, %i[ modified build master:push version:push gem:push github:release ]

#rcov_task ⇒ Object

The rcov_task method sets up a Rake task for executing code coverage tests using RCov.

This method configures a :rcov task that runs the project’s test suite with RCov to generate code coverage reports. It includes the test directory and required paths in the load path, specifies the test files to run, and enables verbose output. The task also conditionally depends on the :compile task if project extensions are present. If RCov is not available, it displays a warning message suggesting to install RCov.



1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
 
# File 'lib/gem_hadar.rb', line 1067

def rcov_task
  if defined?(::Rcov)
    rt = ::Rcov::RcovTask.new(:run_rcov) do |t|
      t.libs << test_dir
      t.libs.concat require_paths.to_a
      t.libs.uniq!
      t.test_files = test_files
      t.verbose    = true
      t.rcov_opts  = %W[-x '\\b#{test_dir}\/' -x '\\bgems\/']
    end
    desc 'Run the rcov code coverage tests'
    task :rcov => [ (:compile if extensions.full?), rt.name ].compact
    clobber 'coverage'
  else
    desc 'Run the rcov code coverage tests'
    task :rcov do
      warn "rcov doesn't work for some reason, have you tried 'gem install rcov'?"
    end
  end
end

#readme ⇒ String?

The readme attribute accessor for configuring the gem’s README file.

This method sets up a DSL accessor for the readme attribute, which specifies the path to the README file for the gem. It provides a way to define the location of the README file that will be used in documentation and packaging processes.

Returns:

  • (String, nil) —

    the path to the README file or nil if not set



285
 
# File 'lib/gem_hadar.rb', line 285

dsl_accessor :readme

#release_task ⇒ Object

The release_task method defines a Rake task that orchestrates the complete release process for the gem.

This method sets up a :release task that depends on the :push task, ensuring all necessary steps for publishing the gem are executed in sequence. It provides a convenient way to perform a full release workflow with a single command.



1441
1442
1443
1444
 
# File 'lib/gem_hadar.rb', line 1441

def release_task
  desc "Release the new version #{version} for the gem #{name}."
  task :release => :push
end

#require_path(path = nil) ⇒ String

The require_path method manages the gem’s require path configuration.

This method provides functionality to set or retrieve the directory paths from which the gem’s code can be loaded. When called with a path argument, it updates the require_paths attribute with that path and returns it. When called without arguments, it returns the first path from the current require_paths set.

path when retrieving

Parameters:

  • path (String, nil) (defaults to: nil) —

    the directory path to set as the require path; if nil, returns the current first require path

Returns:

  • (String) —

    the specified path when setting, or the first require



268
269
270
271
272
273
274
275
 
# File 'lib/gem_hadar.rb', line 268

def require_path(path = nil)
  if path
    self.require_paths = Set[path]
    path
  else
    require_paths.first
  end
end

#require_paths ⇒ Set<String>

The require_paths attribute accessor for configuring the gem’s require paths.

This method sets up a DSL accessor for the require_paths attribute, which specifies the directories from which the gem’s code can be loaded. It provides a way to define the locations of the library files that will be made available to users of the gem when it is required in Ruby programs.

path

Returns:

  • (Set<String>) —

    a set of directory paths to be included in the load



253
 
# File 'lib/gem_hadar.rb', line 253

dsl_accessor :require_paths do Set['lib'] end

#required_ruby_version ⇒ String?

The required_ruby_version attribute accessor for configuring the minimum Ruby version requirement.

This method sets up a DSL accessor for the required_ruby_version attribute, which specifies the minimum version of Ruby that the gem requires to run. It allows defining the Ruby version constraint that will be included in the gem specification.

Returns:

  • (String, nil) —

    the required Ruby version string or nil if not set



572
 
# File 'lib/gem_hadar.rb', line 572

dsl_accessor :required_ruby_version

#rvm(&block) ⇒ GemHadar::RvmConfig

The rvm method configures RVM (Ruby Version Manager) settings for the gem project.

This method initializes and returns an RvmConfig object that holds RVM-specific configuration such as the Ruby version to use and the gemset name. If a block is provided, it configures the RvmConfig object with the given settings. If no block is provided and no existing RvmConfig object exists, it creates a new one with default settings.

Parameters:

  • block (Proc) —

    optional block to configure RVM settings

Returns:



641
642
643
644
645
646
647
648
 
# File 'lib/gem_hadar.rb', line 641

def rvm(&block)
  if block
    @rvm = RvmConfig.new(&block)
  elsif !@rvm
    @rvm = RvmConfig.new { }
  end
  @rvm
end

#rvm_task ⇒ Object

The rvm_task method creates a .rvmrc file that configures RVM to use the specified Ruby version and gemset for the project.

This task generates a .rvmrc file in the project root directory with commands to:

  • Use the Ruby version specified by the rvm.use accessor

  • Create the gemset specified by the rvm.gemset accessor

  • Switch to using that gemset

The generated file is written using the secure_write method to ensure proper file permissions.



1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
 
# File 'lib/gem_hadar.rb', line 1478

def rvm_task
  desc 'Create .rvmrc file'
  task :rvm do
    secure_write('.rvmrc') do |output|
      output.write <<~EOT
        rvm use #{rvm.use}
        rvm gemset create #{rvm.gemset}
        rvm gemset use #{rvm.gemset}
      EOT
    end
  end
end

#spec_dir ⇒ String?

The spec_dir attribute accessor for configuring the RSpec specification directory.

This method sets up a DSL accessor for the spec_dir attribute, which specifies the directory where RSpec test files are located. It provides a way to customize the location of test specifications separate from the default ‘spec’ directory, allowing for more flexible project structures.

nil if not set

Returns:

  • (String, nil) —

    the path to the RSpec specification directory or



382
 
# File 'lib/gem_hadar.rb', line 382

dsl_accessor :spec_dir

#spec_pattern ⇒ String

The spec_pattern method configures the pattern used to locate RSpec test files.

This method sets up a DSL accessor for the spec_pattern attribute, which defines the file pattern used to discover RSpec test files in the project. It defaults to a standard pattern that looks for files ending in _spec.rb within the spec directory and its subdirectories, but can be customized through the configuration block.

Returns:

  • (String) —

    the file pattern used to locate RSpec test files



394
395
396
397
398
399
400
 
# File 'lib/gem_hadar.rb', line 394

dsl_accessor :spec_pattern do
  if spec_dir
    "#{spec_dir}{,/*/**}/*_spec.rb"
  else
    'spec{,/*/**}/*_spec.rb'
  end
end

#spec_task ⇒ Object

The spec_task method sets up a Rake task for executing RSpec tests.

This method configures a :spec task that runs the project’s RSpec test suite. It initializes an RSpec::Core::RakeTask with appropriate Ruby options, test pattern, and verbose output. The task also conditionally depends on the :compile task if project extensions are present.



1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
 
# File 'lib/gem_hadar.rb', line 1047

def spec_task
  defined? ::RSpec::Core::RakeTask or return
  st =  RSpec::Core::RakeTask.new(:run_specs) do |t|
    t.ruby_opts ||= ''
    t.ruby_opts << ' -I' << ([ spec_dir ] + require_paths.to_a).uniq * ':'
    t.pattern = spec_pattern
    t.verbose = true
  end
  task :spec => [ (:compile if extensions.full?), st.name ].compact
end

#summary ⇒ String

The summary attribute accessor for configuring the gem’s summary.

This method sets up a DSL accessor for the summary attribute, which specifies a brief description of what the gem does. It includes a validation step that raises an ArgumentError if the summary has not been set, ensuring that the gem configuration contains this required information.

Returns:

  • (String) —

    the summary of the gem

Raises:

  • (ArgumentError) —

    if the summary attribute has not been set



226
227
228
 
# File 'lib/gem_hadar.rb', line 226

dsl_accessor :summary do
  has_to_be_set :summary
end

#test_dir ⇒ String?

The test_dir attribute accessor for configuring the test directory.

This method sets up a DSL accessor for the test_dir attribute, which specifies the directory where test files are located. It provides a way to define the location of the test directory that will be used by various testing tasks and configurations within the gem project.

Returns:

  • (String, nil) —

    the path to the test directory or nil if not set



352
 
# File 'lib/gem_hadar.rb', line 352

dsl_accessor :test_dir

#test_files ⇒ FileList

The test_files attribute accessor for configuring the list of test files to be included in the gem package.

This method sets up a DSL accessor for the test_files attribute, which specifies the files that should be included when running tests for the gem. It provides a way to customize the test file discovery process, defaulting to finding all Ruby files ending in _spec.rb within the spec directory and its subdirectories.

Returns:

  • (FileList) —

    a list of file paths to be included in test execution



364
365
366
367
368
369
370
 
# File 'lib/gem_hadar.rb', line 364

dsl_accessor :test_files do
  if test_dir
    FileList[File.join(test_dir, '**/*.rb')]
  else
    FileList.new
  end
end

#test_task ⇒ Object

The test_task method sets up a Rake task for executing the project’s test suite.

This method configures a Rake task named :test that runs the test suite using Rake::TestTask. It includes the test directory and required paths in the load path, specifies the test files to run, and enables verbose output. The task also conditionally depends on the :compile task if project extensions are present.



1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
 
# File 'lib/gem_hadar.rb', line 1030

def test_task
  tt =  Rake::TestTask.new(:run_tests) do |t|
    t.libs << test_dir
    t.libs.concat require_paths.to_a
    t.test_files = test_files
    t.verbose    = true
  end
  desc 'Run the tests'
  task :test => [ (:compile if extensions.full?), tt.name ].compact
end

#title ⇒ String?

The title attribute accessor for configuring the gem’s documentation title.

This method sets up a DSL accessor for the title attribute, which specifies the title to be used in the generated YARD documentation. It provides a way to define a custom title that will be included in the documentation output, making it easier to identify and reference the gem’s documentation.

Returns:

  • (String, nil) —

    the documentation title or nil if not set



295
 
# File 'lib/gem_hadar.rb', line 295

dsl_accessor :title

#version ⇒ String

The version attribute accessor for configuring the gem’s version.

This method sets up a DSL accessor for the version attribute, which specifies the version number of the gem. It includes logic to determine the version from the VERSION file or an environment variable override, and will raise an ArgumentError if the version has not been set and cannot be determined.

Returns:

  • (String) —

    the version of the gem

Raises:

  • (ArgumentError) —

    if the version attribute has not been set and cannot be read from the VERSION file or ENV override



534
535
536
537
538
539
 
# File 'lib/gem_hadar.rb', line 534

dsl_accessor :version do
  v = ENV['VERSION'].full? and next v
  File.read('VERSION').chomp
rescue Errno::ENOENT
  has_to_be_set :version
end

#version_bump_task ⇒ Object

The version_bump_task method defines Rake tasks for incrementing the gem’s version number.

This method sets up a hierarchical task structure under the :version namespace:

  • It creates subtasks in the :version:bump namespace for explicitly bumping

major, minor, or build versions.

  • It also defines a :version:bump task that automatically suggests the

appropriate version bump type by analyzing recent changes using AI. The suggestion is based on the git log diff between the previous version and the current HEAD, and it prompts the user for confirmation before applying the bump.

The tasks utilize the version_log_diff method to gather change information, the ollama_generate method to get AI-powered suggestions, and the version_bump_to method to perform the actual version update.



1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
 
# File 'lib/gem_hadar.rb', line 1105

def version_bump_task
  namespace :version do
    namespace :bump do
      desc 'Bump major version'
      task :major do
        version_bump_to(:major)
      end

      desc 'Bump minor version'
      task :minor do
        version_bump_to(:minor)
      end

      desc 'Bump build version'
      task :build do
        version_bump_to(:build)
      end
    end

    desc 'Bump version with AI suggestion'
    task :bump do
      log_diff = version_log_diff(from_version: nil, to_version: 'HEAD')
      system   = xdg_config('version_bump_system_prompt.txt', default_version_bump_system_prompt)
      prompt   = xdg_config('version_bump_prompt.txt', default_version_bump_prompt) % { version:, log_diff: }
      response = ollama_generate(system:, prompt:)
      puts response
      default = nil
      if response =~ /(major|minor|build)\s*$/
        default = $1
      end
      response = ask?(
        'Bump a major, minor, or build version%{default}? ',
        /\A(major|minor|build)\z/,
        default:
      )
      if version_type = response&.[](1)
        version_bump_to(version_type)
      else
        exit 1
      end
    end
  end
end

#version_bump_to(type) ⇒ Object

Increases the specified part of the version number and writes it back to the VERSION file.

Parameters:

  • type (Symbol, String) —

    The part of the version to bump (:major, :minor, or :build)



1784
1785
1786
1787
1788
1789
1790
 
# File 'lib/gem_hadar.rb', line 1784

def version_bump_to(type)
  type    = type.to_sym
  version = File.read('VERSION').chomp.version
  version.bump(type)
  secure_write('VERSION') { |v| v.puts version }
  exit 0
end

#version_diff_task ⇒ Object

The version_diff_task method defines Rake tasks for listing and displaying git version differences.

This method sets up two subtasks under the :version namespace:

  • A :list task that fetches all git tags, ensures the operation succeeds,

and outputs the sorted list of versions.

  • A :diff task that calculates the version range, displays a colored diff

between the versions, and shows the changes.



930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
 
# File 'lib/gem_hadar.rb', line 930

def version_diff_task
  namespace :version do
    desc "List all versions in order"
    task :list do
      system 'git fetch --tags'
      $?.success? or exit $?.exitstatus
      puts versions
    end

    desc "Displaying the diff from env var VERSION to the next version or HEAD"
    task :diff do
      start_version, end_version = determine_version_range
      puts color(172) { "Showing diff from version %s to %s:" % [ start_version, end_version ] }
      puts `git diff --color=always #{start_version}..#{end_version}`
    end
  end
end

#version_epilogue ⇒ String?

The version_epilogue attribute accessor for configuring additional content to be appended to the version file.

This method sets up a DSL accessor for the version_epilogue attribute, which specifies extra content to be included at the end of the generated version file. This can be useful for adding custom comments, license information, or other supplementary data to the version module or class.

Returns:

  • (String, nil) —

    the epilogue content or nil if not set



550
 
# File 'lib/gem_hadar.rb', line 550

dsl_accessor :version_epilogue

#version_log_diff(to_version: 'HEAD', from_version: nil) ⇒ String

The version_log_diff method generates a git log output containing patch differences between two specified versions.

This method retrieves the commit history between a starting version and an ending version, including detailed changes (patch format) for each commit. It supports comparing against the current HEAD or specific version tags, and automatically determines the appropriate previous version when only a target version is provided.

Parameters:

  • to_version (String) (defaults to: 'HEAD') —

    the ending version tag or ‘HEAD’ to compare up to the latest commit

  • from_version (String, nil) (defaults to: nil) —

    the starting version tag; if nil, it defaults based on to_version

Returns:

  • (String) —

    the git log output in patch format showing changes between the two versions

Raises:

  • (RuntimeError) —

    if the specified version tags are not found in the repository



889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
 
# File 'lib/gem_hadar.rb', line 889

def version_log_diff(to_version: 'HEAD', from_version: nil)
  if to_version == 'HEAD'
    if from_version.blank?
      from_version = versions.last
    else
      unless versions.find { |v| v == from_version }
        fail "Could not find #{from_version.inspect}."
      end
    end
    `git log -p #{version_tag(from_version)}..HEAD`
  else
    unless versions.find { |v| v == to_version }
      fail "Could not find #{to_version.inspect}."
    end
    if from_version.blank?
      from_version = versions.each_cons(2).find do |previous_version, v|
        if v == to_version
          break previous_version
        end
      end
      unless from_version
        return `git log -p #{version_tag(to_version)}`
      end
    else
      unless versions.find { |v| v == from_version }
        fail "Could not find #{from_version.inspect}."
      end
    end
    `git log -p #{version_tag(from_version)}..#{version_tag(to_version)}`
  end
end

#version_push_task ⇒ Object

The version_push_task method defines Rake tasks for pushing version tags to Git remotes.

This method sets up a hierarchical task structure under the :version namespace:

  • It creates subtasks in the :version:push namespace for each configured Git remote, allowing individual pushes to specific remotes.

  • It also defines a top-level :version:push task that depends on all the individual remote push tasks, enabling a single command to push the version tag to all remotes.

The tasks utilize the git_remotes method to determine which remotes are configured and generate appropriate push commands for each one.



1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
 
# File 'lib/gem_hadar.rb', line 1231

def version_push_task
  namespace :version do
    git_remotes.each do |gr|
      namespace gr.to_sym do
        desc "Push version #{version} to git remote #{gr}"
        task :push do
          sh "git push #{gr} v#{version}"
        end
      end
    end

    desc "Push version #{version} to all git remotes: #{git_remotes * ' '}"
    task :push => git_remotes.map { |gr| :"version:#{gr}:push" }
  end
end

#version_show_task ⇒ Object

The version_show_task method defines a Rake task that displays the current version of the gem.

This method creates a :version:show task under the Rake namespace that reads the version from the generated version file in the lib directory and compares it with the version specified in the GemHadar configuration. It then outputs a message indicating whether the versions match or not.



856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
 
# File 'lib/gem_hadar.rb', line 856

def version_show_task
  namespace :version do
    desc "Displaying the current version"
    task :show do
      require path_name
      dir = File.join('lib', path_name)
      version_file = File.join(dir, 'version.rb')
      m = Module.new
      m.instance_eval File.read(version_file)
      version_rb   = m.const_get(
        [ path_module, 'VERSION' ] * '::'
      )
      equal        = version == version_rb ? '==' : '!='
      puts "version.rb=#{version_rb} #{equal} VERSION=#{version}"
    end
  end
end

#version_tag(version) ⇒ String

The version_tag method prepends a ‘v’ prefix to the given version string, unless it’s HEAD.

Parameters:

  • version (String) —

    the version string to modify

Returns:

  • (String) —

    the modified version string with a ‘v’ prefix



1986
1987
1988
1989
1990
1991
1992
 
# File 'lib/gem_hadar.rb', line 1986

def version_tag(version)
  if version != 'HEAD'
    version.dup.prepend ?v
  else
    version.dup
  end
end

#version_tag_task ⇒ Object

The version_tag_task method defines a Rake task that creates a Git tag for the current version.

This method sets up a :version:tag task under the Rake namespace that creates an annotated Git tag for the project’s current version. It checks if a tag with the same name already exists and handles the case where the tag exists but is different from the current commit. If the tag already exists and is different, it prompts the user to confirm whether to overwrite it forcefully.



1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
 
# File 'lib/gem_hadar.rb', line 1158

def version_tag_task
  namespace :version do
    desc "Tag this commit as version #{version}"
    task :tag do
      force = ENV['FORCE'].to_i == 1
      begin
        sh "git tag -a -m 'Version #{version}' #{'-f' if force} #{version_tag(version)}"
      rescue RuntimeError
        if `git diff v#{version}..HEAD`.empty?
          puts "Version #{version} is already tagged, but it's no different"
        else
          if ask?("Different version tag #{version} already exists. Overwrite with "\
              "force? (yes/NO) ", /\Ayes\z/i)
            force = true
            retry
          else
            exit 1
          end
        end
      end
    end
  end
end

#version_task ⇒ Object

The version_task method defines a Rake task that generates a version file for the gem.

This method creates a task named :version that writes version information to a Ruby file in the lib directory. The generated file contains constants for the version and its components, as well as an optional epilogue section. The task ensures the target directory exists and uses secure file writing to prevent permission issues.



828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
 
# File 'lib/gem_hadar.rb', line 828

def version_task
  desc m = "Writing version information for #{name}-#{version}"
  task :version do
    puts m
    mkdir_p dir = File.join('lib', path_name)
    secure_write(File.join(dir, 'version.rb')) do |v|
      v.puts <<~EOT
        #{module_type} #{path_module}
          # #{path_module} version
          VERSION         = '#{version}'
          VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
          VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
          VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
          VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
        end
      EOT
      version_epilogue.full? { |ve| v.puts ve }
    end
  end
end

#version_untag(version_tag) ⇒ String

The version_untag method removes the ‘v’ prefix from a version tag string.

Parameters:

  • version_tag (String) —

    the version tag string that may start with ‘v’

Returns:

  • (String) —

    the version string with the ‘v’ prefix removed



1999
2000
2001
 
# File 'lib/gem_hadar.rb', line 1999

def version_untag(version_tag)
  version.sub(/\Av/, '')
end

#versions ⇒ Array<String>

The versions method retrieves and processes the list of git tags that match semantic versioning patterns.

It executes ‘git tag` to get all available tags, filters them using a regular expression to identify valid version strings, removes any ’v’ prefix from each version string, trims whitespace, and sorts the resulting array based on semantic versioning order.

order according to semantic versioning rules.

Returns:

  • (Array<String>) —

    an array of version strings sorted in ascending



1974
1975
1976
1977
1978
1979
 
# File 'lib/gem_hadar.rb', line 1974

memoize method:
def versions
  `git tag`.lines.grep(/^v?\d+\.\d+\.\d+$/).map(&:chomp).map {
    _1.sub(/\Av/, '')
  }.sort_by(&:version)
end

#write_gemfile ⇒ Object

The write_gemfile method creates and writes the default Gemfile content if it doesn’t exist. If a custom Gemfile exists, it only displays a warning.



1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
 
# File 'lib/gem_hadar.rb', line 1818

def write_gemfile
  default_gemfile =<<~EOT
    # vim: set filetype=ruby et sw=2 ts=2:

    source 'https://rubygems.org'

    gemspec
  EOT
  current_gemfile = File.exist?('Gemfile') && File.read('Gemfile')
  case current_gemfile
  when false
    secure_write('Gemfile') do |output|
      output.write default_gemfile
    end
  when default_gemfile
    ;;
  else
    warn "INFO: Current Gemfile differs from default Gemfile."
  end
end

#write_ignore_file ⇒ Object

The write_ignore_file method writes the current ignore_files configuration to a .gitignore file in the project root directory.



1810
1811
1812
1813
1814
 
# File 'lib/gem_hadar.rb', line 1810

def write_ignore_file
  secure_write('.gitignore') do |output|
    output.puts(ignore.sort)
  end
end

#yard_dir ⇒ String

The yard_dir attribute accessor for configuring the output directory for YARD documentation.

This method sets up a DSL accessor for the yard_dir attribute, which specifies the directory where YARD documentation will be generated. It defaults to ‘doc’ and provides a way to customize the documentation output location through the configuration block.

Returns:

  • (String) —

    the path to the directory where YARD documentation will be stored



441
442
443
 
# File 'lib/gem_hadar.rb', line 441

dsl_accessor :yard_dir do
  'doc'
end

#yard_doc_task ⇒ void

This method returns an undefined value.

The yard_doc_task method configures and sets up a YARD documentation generation task.

This method initializes a YARD::Rake::YardocTask that processes Ruby source files and generates comprehensive documentation including private and protected methods. It configures the output directory, handles README files, includes additional documentation files, and sets up a pre-execution cleanup routine.



1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
 
# File 'lib/gem_hadar.rb', line 1502

def yard_doc_task
  YARD::Rake::YardocTask.new(:yard_doc) do |t|
    t.files = doc_code_files.grep(%r(\.rb\z))

    output_dir = yard_dir
    t.options = [ "--output-dir=#{output_dir}" ]

    # Include private & protected methods in documentation
    t.options << '--private' << '--protected'

    # Handle readme if present
    if readme && File.exist?(readme)
      t.options << "--readme=#{readme}"
    end

    # Add additional documentation files
    if doc_files&.any?
      t.files.concat(doc_files.flatten)
    end

    # Add before hook for cleaning
    t.before = proc {
      clean output_dir
      puts "Generating full documentation in #{output_dir}..."
    }
  end
end

#yard_task ⇒ Object

The yard_task method sets up and registers Rake tasks for generating and managing YARD documentation.

It creates multiple subtasks under the :yard namespace, including tasks for creating private documentation, viewing the generated documentation, cleaning up documentation files, and listing undocumented elements. If YARD is not available, the method returns early without defining any tasks.



1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
 
# File 'lib/gem_hadar.rb', line 1537

def yard_task
  defined? YARD or return
  yard_doc_task
  desc 'Create yard documentation (including private)'
  task :doc => :yard_doc
  namespace :yard do
    my_yard_dir = Pathname.new(yard_dir)

    task :private => :yard_doc

    task :public => :yard_doc

    desc 'Create yard documentation'
    task :doc => :yard_doc

    desc 'View the yard documentation'
    task :view do
      index_file = my_yard_dir + 'index.html'
      File.exist?(index_file)
      sh "open #{index_file}"
    end

    desc 'Clean the yard documentation'
    task :clean do
      rm_rf my_yard_dir
    end

    desc 'List all undocumented classes/modules/methods'
    task :'list-undoc' do
      sh "yard stats --list-undoc"
    end
  end

  desc 'Create the yard documentation and view it'
  task :yard => %i[ yard:private yard:view ]
end