Class: GemHadar

Inherits:
Object
  • Object
show all
Extended by:
DSLKit::DSLAccessor
Includes:
Config, PromptTemplate, Utils, Rake::DSL, RbConfig, Term::ANSIColor, Tins::SecureWrite
Defined in:
lib/gem_hadar.rb,
lib/gem_hadar.rb,
lib/gem_hadar/version.rb,
lib/gem_hadar/simplecov.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       '[email protected]'
  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 Classes: RvmConfig, Setup, TemplateCompiler

Constant Summary collapse

VERSION =

GemHadar version

'2.0.4'
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 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



1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
 
# File 'lib/gem_hadar.rb', line 1909

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



1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
 
# File 'lib/gem_hadar.rb', line 1803

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



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

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.



676
677
678
679
 
# File 'lib/gem_hadar.rb', line 676

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



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

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



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

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



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

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.



1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
 
# File 'lib/gem_hadar.rb', line 1425

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 



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
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
 
# File 'lib/gem_hadar.rb', line 1537

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



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
 
# File 'lib/gem_hadar.rb', line 1607

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
  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



1317
1318
1319
1320
1321
1322
 
# File 'lib/gem_hadar.rb', line 1317

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.



651
652
653
654
 
# File 'lib/gem_hadar.rb', line 651

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



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

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



769
770
771
 
# File 'lib/gem_hadar.rb', line 769

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



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

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.



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

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



777
778
779
 
# File 'lib/gem_hadar.rb', line 777

def development_dependency(*args)
  @development_dependencies << args
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



410
411
412
 
# File 'lib/gem_hadar.rb', line 410

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



1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
 
# File 'lib/gem_hadar.rb', line 1657

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



191
192
193
 
# File 'lib/gem_hadar.rb', line 191

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



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

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



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

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

#fail(*args) ⇒ Object

The fail method formats and displays failure messages using red colored output.

Parameters:

  • args (Array) —

    the array of arguments to be formatted and passed to super



1881
1882
1883
1884
1885
1886
 
# File 'lib/gem_hadar.rb', line 1881

def fail(*args)
  args.map! do |a|
    a.respond_to?(:to_str) ? color(196) { a.to_str } : a
  end
  super(*args)
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



463
464
465
 
# File 'lib/gem_hadar.rb', line 463

dsl_accessor :files do
  `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



1932
1933
1934
 
# File 'lib/gem_hadar.rb', line 1932

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.



933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
 
# File 'lib/gem_hadar.rb', line 933

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.



1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
 
# File 'lib/gem_hadar.rb', line 1263

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



788
789
790
791
792
793
794
 
# File 'lib/gem_hadar.rb', line 788

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



1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
 
# File 'lib/gem_hadar.rb', line 1819

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.



969
970
971
972
973
974
975
976
 
# File 'lib/gem_hadar.rb', line 969

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.



1164
1165
1166
 
# File 'lib/gem_hadar.rb', line 1164

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



1896
1897
1898
1899
1900
 
# File 'lib/gem_hadar.rb', line 1896

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.



1300
1301
1302
1303
1304
1305
1306
1307
 
# File 'lib/gem_hadar.rb', line 1300

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.



1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
 
# File 'lib/gem_hadar.rb', line 1332

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.



1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
 
# File 'lib/gem_hadar.rb', line 1983

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

#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



208
209
210
 
# File 'lib/gem_hadar.rb', line 208

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



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

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



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

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



689
690
691
692
693
694
 
# File 'lib/gem_hadar.rb', line 689

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.



994
995
996
 
# File 'lib/gem_hadar.rb', line 994

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



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

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



449
450
451
 
# File 'lib/gem_hadar.rb', line 449

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.



1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
 
# File 'lib/gem_hadar.rb', line 1176

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 #{ssh_account} 'git init --bare #{dir}'"
      sh "git remote add -m master #{remote_name} #{ssh_account}:#{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.



1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
 
# File 'lib/gem_hadar.rb', line 1236

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)



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

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.



1707
1708
1709
1710
1711
1712
1713
1714
1715
 
# File 'lib/gem_hadar.rb', line 1707

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 = 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.



1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
 
# File 'lib/gem_hadar.rb', line 1722

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



1693
1694
1695
 
# File 'lib/gem_hadar.rb', line 1693

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’



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

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



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

def package_ignore(*args)
  if args.empty?
    package_ignore_files
  else
    args.each { |a| package_ignore_files << a }
  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



477
478
479
 
# File 'lib/gem_hadar.rb', line 477

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.



984
985
986
987
988
989
990
 
# File 'lib/gem_hadar.rb', line 984

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



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

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



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

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



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

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.



1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
 
# File 'lib/gem_hadar.rb', line 1391

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



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

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.



1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
 
# File 'lib/gem_hadar.rb', line 1043

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



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

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.



1416
1417
1418
1419
 
# File 'lib/gem_hadar.rb', line 1416

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



265
266
267
268
269
270
271
272
 
# File 'lib/gem_hadar.rb', line 265

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



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

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



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

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:



623
624
625
626
627
628
629
630
 
# File 'lib/gem_hadar.rb', line 623

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.



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

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

#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



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

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



391
392
393
394
395
396
397
 
# File 'lib/gem_hadar.rb', line 391

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.



1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
 
# File 'lib/gem_hadar.rb', line 1023

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



223
224
225
 
# File 'lib/gem_hadar.rb', line 223

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



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

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



361
362
363
364
365
366
367
 
# File 'lib/gem_hadar.rb', line 361

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.



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

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



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

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



516
517
518
519
520
521
 
# File 'lib/gem_hadar.rb', line 516

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.



1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
 
# File 'lib/gem_hadar.rb', line 1081

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)



1737
1738
1739
1740
1741
1742
1743
 
# File 'lib/gem_hadar.rb', line 1737

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.



906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
 
# File 'lib/gem_hadar.rb', line 906

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



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

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



865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
 
# File 'lib/gem_hadar.rb', line 865

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.



1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
 
# File 'lib/gem_hadar.rb', line 1207

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.



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

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



1958
1959
1960
1961
1962
1963
1964
 
# File 'lib/gem_hadar.rb', line 1958

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.



1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
 
# File 'lib/gem_hadar.rb', line 1134

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.



804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
 
# File 'lib/gem_hadar.rb', line 804

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 "        \#{module_type} \#{path_module}\n          # \#{path_module} version\n          VERSION         = '\#{version}'\n          VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:\n          VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:\n          VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:\n          VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:\n        end\n      EOT\n      version_epilogue.full? { |ve| v.puts ve }\n    end\n  end\nend\n"

#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



1971
1972
1973
 
# File 'lib/gem_hadar.rb', line 1971

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



1946
1947
1948
1949
1950
1951
 
# File 'lib/gem_hadar.rb', line 1946

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

#warn(*msgs) ⇒ Object

The warn method displays warning messages using orange colored output.

Parameters:

  • msgs (Array<String>) —

    the array of message strings to display



1872
1873
1874
1875
 
# File 'lib/gem_hadar.rb', line 1872

def warn(*msgs)
  msgs.map! { |m| color(208) { m } }
  super(*msgs, uplevel: 1)
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.



1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
 
# File 'lib/gem_hadar.rb', line 1771

def write_gemfile
  default_gemfile ="    # vim: set filetype=ruby et sw=2 ts=2:\n\n    source 'https://rubygems.org'\n\n    gemspec\n  EOT\n  current_gemfile = File.exist?('Gemfile') && File.read('Gemfile')\n  case current_gemfile\n  when false\n    secure_write('Gemfile') do |output|\n      output.write default_gemfile\n    end\n  when default_gemfile\n    ;;\n  else\n    warn \"INFO: Current Gemfile differs from default Gemfile.\"\n  end\nend\n"

#write_ignore_file ⇒ Object

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



1763
1764
1765
1766
1767
 
# File 'lib/gem_hadar.rb', line 1763

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



423
424
425
 
# File 'lib/gem_hadar.rb', line 423

dsl_accessor :yard_dir do
  'doc'
end

#yard_doc_task ⇒ Object 



1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
 
# File 'lib/gem_hadar.rb', line 1465

def yard_doc_task
  YARD::Rake::YardocTask.new(:yard_doc) do |t|
    t.files = files.select { _1 =~ /\.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.



1500
1501
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
1529
1530
1531
1532
1533
1534
1535
 
# File 'lib/gem_hadar.rb', line 1500

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